C++入门（2）--引用

6.引用

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

类型& 引用变量名(对象名) = 引用实体；

//引用
//类型& 引用变量名(对象名) = 引用实体；
int main()
{
    int a = 0;
    int& b = a;
    int& c = b;
    int& d = a;

    b++;
    d++;

    cout << a << endl;

    int x =11;
    d = x;

    cout << a << endl;
    return 0;
}

注：引用类型必须和引用实体时同种类型

6.1 引用特性

1. 引用在定义时必须初始化

2. 一个变量可以有多个引用

3. 引用一旦引用一个实体，再不能引用其他实体

void TestRef()
{
    int a = 10;
    // int& ra; // 该条语句编译时会出错
    int& ra = a;
    int& rra = a;
    printf("%p %p %p\n", &a, &ra, &rra);
}

6.2 常引用

引用过程中，权限不能放大，但权限可以平移或者缩小

int main()
{
    //不可以，引用过程中，权限不能放大
    const int a = 10;
    //int& ra = a; // 该语句编译时会出错，a为常量
    const int& ra = a;
    
    // 可以，c拷贝给d，没有放大权限，因为d的改变不影响c
    const int c = 0；
    int d = c;
    
    // 可以
    // 引用过程中，权限可以平移或者缩小
    int x = 0;
    int& y = x;
    const int& z = x;
    ++x;//z的值也会变
    ++z;//error
    
    

    double d = 12.34;
    int i=d;//会产生int临时变量，临时变量具有常性
    //int& ri = d; // 该语句编译时会出错，类型不同
    const int& ri = d;
    
    return 0;
}


int func1()
{
    static int x = 0;
    return x;
}

int& func2()
{
    static int x = 0;
    return x;
}

int main()
{
    // int& ret1 = func1();  // 权限放大
    //const int& ret1 = func1(); // 权限平移
    // int ret1 = func1();  // 拷贝

    int& ret2 = func2();        // 权限平移
    const int& rret2 = func2();  // 权限缩小

    return 0;
}

6.3 使用场景

1.做参数

引用参数（输出型参数）；

引用参数（减少拷贝提高效率）（大对象/深拷贝类对象）

void Swap(int& a, int& b)
{
    int tmp = a;
    a = b;
    b = tmp;
}

void Swap(int*& a, int*& b)
{
    int* tmp=a;
    a = b;
    b = tmp;
}

int main()
{
    int x = 0, y = 1;
    Swap(x, y);
    cout << x << " " << y << endl;

    int* px = &x, * py = &y;
    cout << px << " " << py << endl;
    Swap(px, py);
    cout << px << " " << py << endl;

    cout << x << " " << y << endl;

    return 0;
}

2.做返回值

引用做返回值（减少拷贝提高效率）（大对象/深拷贝类对象）

引用做返回值修改返回值+获取返回值

获取返回值
传值返回
int Count()
{
    static int n = 0;
    n++;

    return n;
}

int main()
{
    int ret = Count();
    cout << ret << endl;
    return 0;
}


传引用返回
int& Count()
{
    static int n = 0;
    n++;

    return n;
}

int main()
{
    int ret = Count();
    cout << ret << endl;
    return 0;
}


int& Count()
{
    int n=0;
    n++;
    
    return n;
}

int main()
{
    int ret=Count();
    cout<<ret<<endl;
    return 0;
}
这里打印ret的值是不确定的
如果Count函数结束，栈帧销毁，没有清理栈帧，那么ret的结果侥幸是正确的
如果Count函数结束，栈帧销毁，清理栈帧，那么ret的结果是随机值



//修改返回值
void SLModify( SeqList* ps, int pos, int x)
{
    assert(pos >= 0 && pos < 100);

    ps->a[pos] = x;
}

int SLGet(SeqList* ps, int pos)
{
    assert(pos >= 0 && pos < 100);
    
    return ps->a[pos];
}

 //读写功能都有
int& SLAt(SeqList* ps, int pos)
{
    assert(pos >= 0 && pos < 100);

    return ps->a[pos];
}


int main()
{
    SeqList s;
    SLModify(&s, 0, 1);
    cout << SLGet(&s, 0) << endl;

    //对第0个位置的值+5
    int ret1 = SLGet(&s, 0);
    SLModify(&s, 0, ret1 + 5);
    cout << SLGet(&s, 0) << endl;

    SLAt(&s, 0) = 2;
    cout << SLGet(&s, 0) << endl;
    SLAt(&s, 0) += 5;
    cout << SLGet(&s, 0) << endl;

    return 0;
}

总结：

1.基本任何场景都可以用引用传参；

2.谨慎使用引用做返回值，除了函数作用域，对象不在了，就不能用引用返回，还在就可以用引用返回

6.4 引用和指针的区别

int main()
{
    int a = 10;

    // 语法层面：不开空间，是对a取别名
    int& ra = a;
    ra = 20;

    // 语法层面：开空间，存储a的地址
    int* pa = &a;
    *pa = 30;

    return 0;
}