// 很常规，仅此而已
std::string *p = &s;   

int a = 10;
 
// 引用的类型必须和其所绑定的变量的类型相同；且必须初始化。
int &b = a;

int a[3] = {1, 2, 3};
int (&b) [3] = a;

int a = 1;
int *p = &a;
 
// 指针引用
int * &pp = p;

#include<iostream>
using namespace std;
 
void swap(int &a,int &b){
    int temp=a;
    a=b;
    b=temp;
}
int main(){
    
    int value1=10,value2=20;
    
    cout<<"----------------------交换前----------------------------"<<endl;
    cout<<"value1的值为："<<value1<<endl;
    cout<<"value2的值为："<<value2<<endl;
    
    swap(value1,value2);
    
    cout<<"----------------------交换后----------------------------"<<endl;
    cout<<"value1的值为："<<value1<<endl;
    cout<<"value2的值为："<<value2<<endl;
 
    return 0;
}

#include<iostream>
using namespace std;
 
void func(int(&a)[5]){
// !-! 数组引用作为函数的参数，必须指明数组的长度
 
// do something ...
}
 
int main(){
    int number[5]={0,1,2,3,4};
    func(number);
    return 0;
}

#include<iostream>
#include<string>
using namespace std;
 
string func1(){
    string temp="This is func1";
    return temp;
}
void func2(const string &str){
    cout<<str<<endl;
}
 
 
int main(){
    // 在 main 中会将 func1() 返回的对象 temp 首先赋予一个临时对象，
    // 之后再对该临时变量操作，如赋值给新的变量等。
    string returned_temp = func1();
    
    // 所以将 func1() 产生的临时对象值传递给 func2() 时，
    // 必须要注意的是: 要使用 const 的形参 void func2(const string &str)...
    // 否则会出现“试图将 const 对象赋值给非 cosnt 对象的错误”。
    func2(func1());
 
    // “Tomwenxing” 类似。
    func2("Tomwenxing");
    return 0;
}

#include<iostream>
using namespace std;
 
float temp;
 
float fn1(float r){
    temp = r*r*3.14;
    return temp;
} 
 
float &fn2(float r){ 
    // & 说明返回的是 temp 的引用，也就是返回 temp 本身
    temp = r*r*3.14;
    return temp;
}
 
int main(){
 
    // case 1：返回值 -----------------------------------------------------------------
    // 在内存中创建临时变量，并将 temp 的值拷贝给该临时变量。
    // 当返回到主函数 main 后，赋值语句 a = fn1(5.0) 
    // 会把临时变量的值再拷贝给变量 a。
    float a = fn1(5.0); 
 
 
    // case 2: 用函数的返回值作为引用的初始化值 ---------------------------------------
    // float &b = fn1(5.0);
    // [Error] invalid initialization of non-const reference of type 'float&' from an
    // rvalue of type 'float' 
    // 逻辑是首先拷贝 temp 的值给临时变量。返回到主函数后，用临时变量来初始化引用变量 b
    // 使得b成为该临时变量到的别名。但是临时变量的作用域短暂（仅仅是一句表达式）会使得 b
    // 有无效的风险。所以建议使用
    float x = fn1(5.0);
    float &b = x;
     
 
    // case 3：返回引用 --------------------------------------------------------------
    // 函数 fn2() 的返回值不产生副本，而是直接将变量 temp 返回给主函数，即主函数的赋值语
    // 句中的左值是直接从变量 temp 中拷贝而来（也就是说 c 只是变量 temp 的一个拷贝而非别
    // 名, 拷贝是从赋值语句来的）
    float c = fn2(5.0);
 
 
    // case 4：用函数返回的引用作为新引用的初始化值 ----------------------------------
    // 函数 fn2() 的返回值不产生副本，而是直接将变量 temp 返回给主函数。在主函数中，一个
    // 引用声明 d 用该返回值初始化，也就是说此时 d 成为变量 temp 的别名。由于 temp 是全
    // 局变量，所以在 d 的有效期内 temp 始终保持有效，故这种做法是安全的。
    float &d = fn2(5.0);  
 
    // 不能返回局部变量的引用。如上面的例子，如果 temp 是局部变量，那么它会在函数返回后
    // 被销毁，此时对 temp 的引用就会成为“无所指”的引用，程序会进入未知状态。
 
    // 不能返回函数内部通过 new 分配的内存的引用。虽然不存在局部变量的被动销毁问题，但如
    // 果被返回的函数的引用只是作为一个临时变量出现，而没有将其赋值给一个实际的变量，那么
    // 就可能造成这个引用所指向的空间（有 new 分配）无法释放的情况（由于没有具体的变量名，
    // 故无法用 delete 手动释放该内存），从而造成内存泄漏。
 
    // 当返回类成员的引用时，最好是 const 引用。这样可以避免在无意的情况下破坏该类的成员。
 
    cout<<a<<endl;    //78.5
    //cout<<b<<endl;  //78.5
    cout<<c<<endl;    //78.5
    cout<<d<<endl;    //78.5
 
    return 0;
}

class Father;                   //基类（父类）
class Son：public Father{.....} //Son是Father的派生类
Son son;                        //son是类Son的一个实例
Father &ptr=son;                //用派生类的对象初始化基类对象的使用

// 左值引用
int num = 10;
int &b = num;     // 正确
int &c = 10;      // 错误
 
int num = 10;
const int &b = num;   // 正确
const int &c = 10;    // 正确
 
 
// 右值引用
int num = 10;
//int && a = num;    // 错误，右值引用不能初始化为左值
int && a = 10;       // 正确
 
a = 100;
cout << a << endl;   // 输出为100，右值引用可以修改值
 
 
// 右值引用的使用
// 如 thread argv 的传入
template<typename _Callable, typename... _Args>
explicit thread(_Callable&& __f, _Args&&... __args) { 
//.... 
}
// Args&&... args 是对函数参数的类型 Args&& 进行展开
// args... 是对函数参数 args 进行展开
// explicit 只对构造函数起作用，用来抑制隐式转换