C++

我，今天才知道，之前做题写的取地址符&，原来，它是有名字的，它叫做——引用。服了。

应用的作用：给变量起别名
引用的语法： 数据类型 &别名 = 原名

原名对应的值和别名对应的值，可以一起改变，因为操作的是同一块内存。

正确用法

#include<iostream>

using namespace std;

void w(int&x)
{
    cout<<x<<endl;//5
    x=111;
}

int main()
{
    int x=5;
    w(x);
    cout<<x<<endl; //111

    int a=10;
    int&b=a;
    cout<<a<<" "<<b<<endl; //10 10

    b=100;
    cout<<a<<" "<<b<<endl;//100 100
    return 0;
}

错误用法

int &c; 错误，引用必须初始化 
int &c = a; //一旦初始化后，就不可以更改 
int &c = 10; // 引用必须引用一段合法的内存空间 10是一个字面量，int前面加上const就行了
c = b; //这是赋值操作，不是更改引用

交换两个变量

//1. 值传递 不改变实参的值
void w1(int a,int b)
{
    int t=a;
    a=b;
    b=t;
}

//2. 地址传递 
void w2(int*a,int*b)
{
    int t=*a;
    *a=*b;
    *b=t;
}

// 3. 引用传递 
void w3(int&a,int&b)
{
    int t=a;
    a=b;
    b=t;
}

不要返回局部变量的引用

#include<iostream>
using namespace std;

int& w()
{
    int a=10; // 局部变量存放在内存四区中的 栈区
    //栈区特点：局部变量在w()执行完之后局部变量就释放掉了
    return a;
}

int main()
{
    int &x=w();
    cout<<x<<endl; // 10 第一次结果正确，因为编译器做了保留
    cout<<x<<endl; // 3267 第二次结果错误，因为a的内存已经释放
    return 0;
}

函数调用作为左值

如果函数的返回值是引用，那么这个 函数调用w() 可以作为左值：

#include<iostream>
using namespace std;

int& w()
{
    static int a=10; // 静态变量存放在全局区，
    // 全局区的数据在程序结束后系统释放
    return a; //返回a的引用，相当于a的变量
}

int main()
{
    int &x=w();
    cout<<x<<endl; // 10
    cout<<x<<endl; // 10
    w()=1000; //相当于对a进行操作
    cout<<x<<endl; //1000
    //x通过别名也可以访问到这一块内存
    cout<<x<<endl; //1000
    return 0;
}

指针常量

引用的本质在C++内部的实现是一个指针常量。

指针常量：指针的指向不能修改，指针指向的值可以改动。

#include<iostream>
using namespace std;

//发现是引用，转换为int*const x=&a;

void func(int&x)
{
    x=100;
    // x是引用，转换为*x = 100
}

int main()
{
    int a=10;
    //自动转换为 int* const x = &a;
    //相当于一个指针，指向了a的地址
    //const 修饰 指针的指向是固定的，不能再指向另外一块地址了
    // 指针常量是指针指向不可改，也说明为什么引用不可更改

    int&x=a;
    x=20; //内部发现x是引用，自动帮我们转换为: *x = 20;
    // * 相当于解引用，指针解引用之后找到它指向的那一块数据改为20
    cout<<"a: "<<a<<endl;
    cout<<"x: "<<x<<endl;

    func(a);
    return 0;
}

常量引用

作用：常量引用主要用来修饰形参，防止误操作。

在函数形参列表中，可以加 const 修饰形参，防止形参改变实参。

#include<iostream>
using namespace std;

void w(int&x)
{
    x=1000;
    cout<<"x = "<<x<<endl; //1000
}

void w1(const int&y)
{
    // y=1000; 加了const之后不能修改；了
    cout<<"y = "<<y<<endl; //111
}

int main()
{
    int x=10;
    //加入const就可以了，编译器优化代码，
    //代码修改为int temp = 10; const int & y = temp;
    const int&y=10;
    //int & y=10; 不允许
    // y=20;//加入const之后变为只读，不可以修改变量

    int q=100;
    w(q);
    cout<<"q = "<<q<<endl; //1000

    // 函数中利用常量引用防止误操作修改实参
    int p=111;
    w1(p);
    cout<<"p = "<<p<<endl; //111
    return 0;
}