C++_05_引用

C++_05_引用

1、普通引用

　　C++引用概念（C++特有新增加引用）：引用可以看作一个已定义变量的别名（Type& name = var;）
　　注意：普通引用在声明时必须用其它的变量进行初始化；引用作为函数参数声明时不进行初始化
　　注意：引用在定义时需要添加&，在使用时不能添加&，使用时添加&表示取地址。

　　引用的意义：
　　　　　　1、引用作为其它变量的别名而存在，因此在一些场合可以代替指针；
　　　　　　2、引用相对于指针来说具有更好的可读性和实用性
　　　　　　3、可以通过引用更改const变量的值（让const稀释引用&b，更改未被const修饰的a，可以更改const修饰的

　　引用的本质：
　　　　　　1、引用在C++中的内部实现是一个常指针    Type& name çèType* const name
　　　　　　2、C++编译器在编译过程中使用常指针作为引用的内部实现，因此引用所占用的空间大小与指针相同。
　　　　　　3、从使用的角度，引用会让人误会其只是一个别名，没有自己的存储空间。这是C++为了实用性而做出的细节隐藏

 

　　引用作为函数参数（形参）：

#include <iostream>
using namespace std;

void swap1(int a, int b);
void swap2(int *p1, int *p2);
void swap3(int &r1, int &r2);


int main() {
    int num1, num2;
    cout << "Input two integers: ";
    cin >> num1 >> num2;
    swap1(num1, num2);
    cout << num1 << " " << num2 << endl;

    cout << "Input two integers: ";
    cin >> num1 >> num2;
    swap2(&num1, &num2);
    cout << num1 << " " << num2 << endl;

    cout << "Input two integers: ";
    cin >> num1 >> num2;
    swap3(num1, num2);
    cout << num1 << " " << num2 << endl;

    return 0;
}

//直接传递参数内容 
void swap1(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
}
//直接传递参数，只能在函数内修改接收到的形参
//（副本——局部变量）的值，不能改变实参（原件）的值。
//拷贝关系

//传递指针
void swap2(int *p1, int *p2) {
    int temp = *p1;
    *p1 = *p2;
    *p2 = temp;
}
//将地址（&）和指针（*）联系起来，可以通过一方（局部）改变另一方（全局）
//指向关系

//按引用传参
void swap3(int &r1, int &r2) {
    int temp = r1;
    r1 = r2;
    r2 = temp;
}
//通过引用将两个变量引用到同一内存空间同一位置；
//引用公用关系

运行结果：
Input two integers: 12 34↙
12 34
Input two integers: 88 99↙
99 88
Input two integers: 100 200↙
200 100

　　

　　引用作为函数返回值(引用当左值）：

#include <iostream>
using namespace std;
class A
{
    public:
        int &fun()   
        //引用函数返回值  当时用&在含糊明前时候，&fun()可以作为可以被修改的左值
        {
            return a;   //返回私有成员变量a，返回全局变量的引用
        }
    private :
        int a;      //私有成员变量a
};
int main(int argc, char const *argv[])
{
    A m;
    m.fun() = 1000;   //没有&fun()    m.fun是不能在表达式的左边出现的
    cout << m.fun() << endl;
    //私有成员变量a无法直接访问修改，可以通过引用函数农户返回值来修改和打印a的值
    return 0;
}

 

 

2、常引用

常引用又叫常量引用

#include<iostream>
using namespace std;

int main()
{
    //普通引用
    int a = 10;
    int &b = a;

    //常量引用 ：让变量引用只读属性
    const int &c = a;  

　　/**错误写法
  　　  const int a =100;
  　　  int &b = a;
　　 **正确写法
　　　　int a = 100;
　　　　const int &b = a;
　　*/

　　/**    被引用的变量不能被const修饰---修改----》
           变量不能引用const常量，const常量可以引用const常量
    */
　　/**     const修饰的值不能修改，可以通过另一个非const修饰的“引用”或者“
            被引用”的值来修改(一般就是被引用a)
    */

    //常量引用初始化 分为两种
    //1 用变量 初始化 常量引用
    {
        int x = 20;
        const int& y = x;
        printf("y:%d \n", y);
    }
    //2 用常量 初始化 常量引用
    {
        //int &m = 10; //引用是内存空间的别名 字面量10没有内存空间 没有方法做引用
        const int &m = 10; 
    }
    cout<<"hello..."<<endl;
    system("pause");
    return 0;
}

 

 

3、指针引用

　　指针引用 *& 可以 替代 二级指针 **；使用时，更简单；可以被重新赋值。
　　　　指针引用相当于 一级指针 + 引用 （二级指针的一级变为引用）

#include <iostream>
using namespace std;

int m_value = 1;

//指针引用参数
void func(int *& p, int dest)
{
    m_value = dest;
    p = &m_value;        //指针引用 *&P 相当于 **p   p中存放引用一级指针
}

int main(int argc, char *argv[]) {
    int n = 2;
    int *pn = &n;
    cout << *pn << endl; //初始值
    
    func(pn, 77); //传递一级指针                     
    cout << *pn <<endl; //经过 func 函数后
    
    m_value = 88;         
//m_value的地址已经和pn绑定引用————>> 导致 m_value 和 *pn 是同一个数据
    cout << *pn <<endl; //改变 m_value 后
}

/mnt/d/VsCode$ g++ 05-指针引用.cpp -o 05-指针引用
zl@LAPTOP-2ABL2N6V:/mnt/d/VsCode$ ./05-指针引用
2
77
88
zl@LAPTOP-2ABL2N6V:/mnt/d/VsCode$ 

　　

 

4、const引用

　　在C++中可以声明const引用   const Type& name = var；    const引用让变量拥有只读属性

　　1、Const & cst int * const e
　　2、普通引用 相当于 int *const e1
　　3、当使用常量（字面量）对const引用进行初始化时，C++编译器会为常量值分配空间，并将引用名作为这段空间的别名
　　4、使用字面量对const引用初始化后，将生成一个只读变量

5、const修饰类

后续~