C++（常）引用，const，指针引用

---

一、引用
1.基本引用语法

/*变量引用*/
int i = 10;
int & s = i;//声明引用变量s，引用了i，则后续对s或者i变动都会导致s和i的值变动。此时s和i等价
//声明一个引用，不是新定义了一个变量，它只表示该引用名是目标变量名的一个别名，它本身不是一种数据类型，因此引用本身不占存储单元，系统也不给引用分配存储单元。故：对引用求地址，就是对目标变量求地址。&s与&i相等。从而减少内存空间和提高运行效率！这就是引用最大的好处。

2.引用作为函数参数，这里的主要好处是，在进行主函数调用的时候，不需要给形参赋值，分配空间，而是直接对实参进行操作。这样节省了空间和提高了效率。
虽然指针也能达到此类效果，但是仍然需要对指针变量进行赋值，需要占据内存空间。

//定义对调函数，a，b为引用作为函数参数
void swap(int &a, int &b)
{
int c = a;
a = b;
b = c;
}
//定义主函数
void main()
{
int m , n;
cin>>m>>n;
swap(m,n);//直接调用，无需实参变量任何要求。ps，这里疑惑，不引用不也不用特殊要求吗？？？
cout<<m<<' '<<n<<endl;
}

3 常引用
语法：const int &a = s；//这里不能对a进行修改而改变s的值，但是可以改变s。

int main()
{
    int a = 20;
    int const &s = a;//这里const int &s =a效果等效。
    cout << a << endl;
    cout << s << endl;
    a = 30;
    //s = 40;//这里不能赋值！！！因为s是常引用
    cout << a << endl;
    cout << s << endl;
    return 0;
}

4.引用作为函数的返回值，这个最大的好处在于少占用内存，因为没有返回值副本。
案例：

//引用作为函数返回值，最大的好处是不用占据内存（内存中不占用返回值副本）

int swap1(int a, int b)
{
    int temp = a;
    a = b;
    b = temp;
    cout << "swap1" << endl;
    return a / b;
}

//引用作为函数返回值
float &swap2(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
    float c = (a*1.0) / b;
    cout << "swap2" << endl;
    return  c;
}

int main()
{
    int a = swap1(2, 3);
    float b = swap2(2, 3);
    cout << a << endl;
    cout << b << endl;
//  int &c = swap1(2, 3);//这里错误，不能引用c
    float &d = swap2(2, 3);
//  cout << c << endl;
    cout << d << endl;

    return 0;
}

1. 区分几种引用：
   T*；T* const； const T*； const T* const； T&； T& const； const T&； const T& const；const T* &；T*const &

//这里有个记忆的窍门：const靠近哪个，哪个就没法更改。

//常指针与常引用
#include"stdio.h"
#include"iostream"
using namespace std;
int main()
{
//  T*；T* const； const T*； const T* const； T&； T& const； const T&； const T& const；const T* &；T*const &
/*指针与常指针*/
    int a = 18;
    int b = 20;
    int *p=&a;//表示T类型的指针p

    int * const p1=&a;//这里必须赋值，因为是常指针
    cout << p1 << endl;//p1=00000000,64位编译器
    *p1 = 11;
    cout << *p1 << endl;
//    p1 = &b;//错误
// 由上面可以看出int *const指针是个常指针，他只能指向一个固定的地方，可以修改这个固定地方的数字，但是不能再指向其他地方了。


//  const int *p2;
    int const *p2;//这两种定义方式都可以
    p2 = &a;
    cout << p2 << endl;
    p2 = &b;
    cout << p2 << endl;
//  *p2 = 25;//这里错误，不能给p2重新赋值
//由上面可以看出，const int *p2，表示指针指向的地方是常量，这个地方的值不能进行更改，但是指针可以指向其他地方。

    const int * const p3=&a;//这里必须直接赋值
//  p3 = &a;//错误，相当于上面两种情况都包括
    cout << p3 << endl;
    cout << *p3 << endl;
//  p3 = &b;//错误，这里p3是个常指针，他只能指向一个固定的地方，并且这个固定的地方也是常量，不可更改。
    cout << p3 << endl;
    cout << *p3 << endl;



/*引用与常引用*/
    int &c = a;//引用c和a等价，可以互相改变
    c = 100;
    cout << c << endl;
    cout << a << endl;
    a = 200;
    cout << a << endl;
    cout << c << endl;

//
    int & const d = a;//个人感觉这里const没啥用啊！等价于int &d=a；
    d = 300;//a和d都是300
    cout << d << endl;
    cout << a << endl;
    a = 500;
    cout << d << endl;//d此时变成了500
    cout << a << endl;


    const int & e = a;//等价于int const &e=a
//  e = 400;//错误，这里e是常引用，不能更改
    a = 400;//不可以该更改e的值，但是可以更改a的值从而更改e的值。
    cout << e << endl;
    cout << a << endl;

    const int & const f=a;//f不能赋值，但是a却可以赋值
    cout << f << endl;
    cout << a << endl;
//  f = 1000;//不能对f进行赋值；f是常量。
    cout << f << endl;
    cout << a << endl;
    a = 2000;
    cout << f << endl;
    cout << a << endl;
//综上所述，我们发现，即使常引用时候，不能改变引用的值，但是可以通过改变变量的值来改变常引用的值！这里不理解，为什么常引用应该是一个常数了，还能被更改？！


// const T* &，这里可以这么看，const在*前面，表示指针指向内容不能改变，但是指针可以指向其他地方
    const int *p10=&a;
    const int *p11=&b;
    const int * &p12 = p10;//p12为p10的引用
    cout << p12 << endl;//输出相同，因为p12为p10引用
    cout << p10 << endl;
//  *p12 = 4000;这里错误，不能改变常指针指向的内容,但是可以指向其他地方
    p12 = p11;
    cout << p12 << endl;
    cout << *p12 << endl;
    cout << p11 << endl;
    cout << *p11 << endl;

//T * const &，const在指针之外，表示该引用只能指向一个固定的地方，但是这个固定地方值可以改
    int *const p14=&a;  
    int *const p15 = &b;//声明指针p14和p15指向a和b
    int *const &p16 = p14;//引用，p16与p14等价，这里p16只能和p14一样指向a，不能指向其他地方了。但是可以改变a的值。
    cout << p16 << endl;
    cout << p14 << endl;
    cout << *p16 << endl;
    cout << *p14 << endl;
    *p16 = 1314;//*p14=1314一样可以
    cout << p16 << endl;
    cout << p14 << endl;
    cout << *p16 << endl;
    cout << *p14 << endl;
//  int *const &p16 = p15;//这里错误，p16不能再指向其他地方了
    cout << p15 << endl;
    cout << p16 << endl;
    cout << *p15 << endl;
    cout << *p16 << endl;

//T *const &

    return 0;
}

总结：由上述实验可以发现，对于指针引用的话，const靠近哪里，那里无法更改。如int *const &p，则表示该p为常指针，其指向的地方不可更改，但是可以更改其指向地方的数字。或者理解为指针变量p为常数不可更改了。
int const *&p，const 距离指针星号较近，则表示该指针指向的地方为常数，不可更改！但是指针变量p可以指向其他地方。

//指针常引用套路
int const *p1=&a;
int const *p2=&b;
int const *&p3=p1;
int const *&p3=p2;

而对于变量的常引用，实验发现 int const &a=b，int const &const a=b居然都可以通过改变b的值来改变a的值，但是这个时候单独改变a不可以！这里存在一点疑惑，但是实验结果确实这么证明的！