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 <<"直接传参==拷贝副本==》原值不变！！！"<< endl;
    cout << num1 << " " << num2 << endl;

    cout << "Input two integers: ";
    cin >> num1 >> num2;
    swap2(&num1, &num2);
    cout << "指针传参==地址链接==》原值改变！！！" << endl;
    cout << num1 << " " << num2 << endl;

    cout << "Input two integers: ";
    cin >> num1 >> num2;
    cout << "引用传参==空间共用==》原值改变！！！" << endl;
    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;
}
//通过引用将两个变量引用到同一内存空间同一位置；
//引用公用关系

?

1 2 3 4 5 6 7

运行结果： Input two integers: 12 34↙<br>直接传参==拷贝副本==》原值不变！！！ 12 34 Input two integers: 88 99↙<br>指针传参==地址链接==》原值改变！！！ 99 88 Input two integers: 100 200↙<br>引用传参==空间共用==》原值改变！！！ 200 100

　　

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

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

 

 

2、常引用

常引用又叫常量引用

左值：const修饰 引用的变量
右值：正常情况下变量；如果右值是个常量，则左值必须是const修饰

#include<iostream>
using namespace std;

int main()
{
    //普通引用
    cout << "---------------普通引用------------------" << endl;
    int a = 10;
    int& b = a;  //没有const修饰时，可以任意修改a或者b的值
    cout << "初始值：a = " << a << "\t" << "b = " << b << endl;
    b = 20; //【1】普通引用改 引用值或者被引用值都可以
    cout << "修改1 ：a = " << a << "\t" << "b = " << b << endl;
    a = 10; //【1】普通引用改 引用值或者被引用值都可以
    cout << "还原值：a = " << a << "\t" << "b = " << b << endl;
   
    cout << "---------------const常引用------------------" << endl;
    //常量引用 ：让变量引用只读属性
    const int& c = a;   //当const修饰引用c的时候，c不能重新赋值，但a可以重新赋值更改
    cout << "初始值：a = " << a << "\t" << "c = " << c << endl;
    //c = 200；//【2】err const 常引用的就不能修改 引用值c 
    a = 30;    //【2】常引用只能修改 被引用值 a 
    cout << "修改1 ：a = " << a << "\t" << "c = " << c << endl;
    a = 10;
    cout << "还原值：a = " << a << "\t" << "c = " << c << endl;

/**
错误写法：const只能修饰 引用值 ，不能放在被引用值前面；
          引用值 和 被引用值 在数据类型上 要“对等”
    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;
    cout << "y = " << y << endl;
}
//2 用常量 初始化 常量引用
{
    //int &m = 10; //引用是内存空间的别名 字面量10没有内存空间 没有方法做引用
    const int& m = 10;
    //注意：这里是唯一可见引用右值为常量的地方，引用值一定需要const修饰
    cout << "m = " << m << endl;
}
    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; //初始值  输出：2

    cout << pn << endl;        //  输出：0000004F2F8FFA34
    func(pn, 77); //传递一级指针 指针p 引用 指针pn 
    cout << &pn << endl;       //  输出：0000004F2F8FFA58
    cout << *pn << endl; //经过 func 函数后 输出：77

    // p 和 pn 引用绑定 , p 中存放的是 m_value 的地址 
    // ==》 pn中存放的是 m_value 的地址
    m_value = 88;   //m_value的地址已经和pn绑定引用————>> 导致 m_value 和 *pn 是同一个数据
    cout << *pn << endl; //改变 m_value 后  输出：88
}

 

?

1 2 3 4 5 6

zl@LAPTOP-2ABL2N6V:/mnt/d/VsCode$ g++ 05-指针引用.cpp -o 05-指针引用 zl@LAPTOP-2ABL2N6V:/mnt/d/VsCode$ ./05-指针引用 2<br>0000004F2F8FFA34<br>0000004F2F8FFA58 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修饰类

后续~