【C++】&与&&用法总结

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

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

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

int a = 1;
int *p = &a;
 
// 指针引用
int * &pp = p;
1
2
3
4
5

#include
using namespace std;
 
void swap(int &a,int &b){
    int temp=a;
    a=b;
    b=temp;
}
int main(){
    
    int value1=10,value2=20;
    
    cout<<"----------------------交换前----------------------------"<

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

#include
#include
using namespace std;
 
string func1(){
    string temp="This is func1";
    return temp;
}
void func2(const string &str){
    cout<

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27

h）引用作为函数的返回值

引用作为函数返回值时，必须在定义函数时在函数名前加 &；使用引用作为函数的返回值的最大的好处是在内存中不产生返回值的副本。

#include
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<