// 很常规，仅此而已

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 只对构造函数起作用，用来抑制隐式转换