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

妖狐艹你老母 2023-09-23 13:51 126阅读 0赞

C++ &以及&&的用法总结

首先，&有两种用法：

1、取地址

2、引用

**取地址和引用没有任何关系，不要瞎联系！**

1、取地址：

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

2、引用：

a）引用是某一个变量或者对象的**别名**，对引用的操作与对其所绑定的变量或对象的操作完全等价。而引用中使用 & ，**跟地址没有任何关系**，仅仅是起到**标志作用**。

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

b）引用相当于变量或者对象的别名，不能将已有的引用名作为其他变量或者对象的引用名。

c） 引用不是定义一个新的变量，**不会**为引用开辟新的[内存][Link 1]空间。

d）对数组的引用需要加上数组的大小

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

e）对指针的引用

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

f）引用作为函数的参数

#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;
    }

其中需要指出的是：

I）当引用作为参数的时候，其效果跟**利用指针作为参数**的效果相当。当调用函数时，函数中的形参就会被当成实参变量或者对象的一个别名使用，也就是说函数中**对形参的各种操作**实际上就是**对实参本身的操作**，而非简单的实参变量或者对象的值拷贝给形参。

II）通常函数调用时，采用值传递的方式。系统会在内存中**开辟空间**用来**存储形参变量**，并将实参变量的值**拷贝给形参变量**，所以形参变量只是实参变量的副本而已，并且如果函数传递的是类的对象，系统还会调用类中的拷贝构造函数来构造形参对象。而**使用引用作为参数传递时，由于此时形参只是传递函数的实参变量或者对象的别名而非副本，故系统不会耗费时间在内存中开辟空间来存储形参**，因此如果参数传递的数据较大，建议使用引用作为函数的形参，提高函数的时间效率，节省内存空间。

使用指针作为函数的形参，虽然达到的效果跟使用引用一样，但当调用函数时**仍然需要为形参指针分配空间**，引用则不需要【引用在底层也会分配指针大小的空间，在汇编底层角度，引用和指针是一样的，不过引用类似于常量指针】。推荐使用引用而非指针作为函数的传递函数。

如果既希望通过引用作为函数形参提高效率，又**希望保护传递的参数在函数中不被改变**，则可以**使用对常量的引用**作为函数的形参。

另外，如果使用**数组的引用作为函数形参**，引用传递时指明的是数组则**必须指定数组的长度**。

#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;
    }

g）常引用

常引用，不允许通过该引用对其所绑定的变量或者对象进行修改。

值得注意的是，C++ 中所有的临时变量都是 const 类型的。

#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;
    }

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

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

#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;
    }

i）在C++中，**引用是除了指针外另一个可以产生多态效果的手段**。也就是说一个基类的引用可以用来绑定其派生类的实例。**ptr只能用来访问派生类对象中从基类继承下来的成员**。**如果基类（类Father）中定义的有虚函数，那么就可以通过在派生类（类Son）中重写这个虚函数来实现类的多态。**

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

在引用的使用中，单纯给某个变量去别名是毫无意义的，**引用的目的主要用于在函数参数的传递中，解决大块数据或对象的传递效率和空间不如意的问题**

用引用传递函数的参数，能**保证参数在传递的过程中不产生副本**，从而提高传递效率，同时**通过const的使用，还可以保证参数在传递过程中的安全性**

引用本身是目标变量或对象的别名，对引用的操作本质上就是对目标变量或对象的操作。因此**能使用引用时尽量使用引用而非指针**.

其次，&& 是右值引用。

**左值和右值**

左值的英文简写为“lvalue”，右值的英文简写为“rvalue”。很多人认为它们分别是"left value"、“right value” 的缩写，其实不然。lvalue 是“loactor value”的缩写，可意为存储在内存中、有明确存储地址（可寻址）的数据，而 rvalue 译为 “read value”，指的是那些可以提供数据值的数据（不一定可以寻址，例如存储于寄存器中的数据）。

左值和右值在C语言中可以简单的理解为：左值可以位于赋值运算符的左侧，右值则不能位于运算符左侧；但是在C++中左值和右值就明显的复杂很多，C++中的左值和右值在《C++ primer》中这样归纳：当一个对象被用作右值的时候用的是对象的值(内容)，当一个对象被用作左值的时候，用的是对象的身份(在内存中的位置)。 简单说来就是左值可以被修改(可以取地址),而右值不能被修改(不能取地址)。

**左值引用在声名时必须初始化。**

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

[Link 1]: https://so.csdn.net/so/search?q=%E5%86%85%E5%AD%98&spm=1001.2101.3001.7020