C++ 变量的引用 &

 

创建变量的引用：int &a = b;  

引用变量a是变量b的别名；对引用操作和对变量本身操作完全相同

注意：与typedef的区别：

typedef对数据类型起别名，&对变量起别名

比如：int num=100;

对int起别名用typedef

对num起别名，用&

注意：引用必须在定义时同时初始化，初始化后绑定的变量不能修改

 

普通引用

#include <iostream>

int main()
{
        
    int a = 10;
    int& b = a;  //b是变量a的引用

    b++;
    std::cout << "a="<<a<<"   b="<<b << std::endl; //a和b的值相同

    int* p = &a;
    int* p1 = &b;

    std::cout << p << std::endl;
    std::cout << p1 << std::endl; //a和b的地址相同

    
    system("pause");  //暂停
}

 

常引用 

int a = 100;
    const int& b = a;//常引用
    //int const & b=a;    与上面等价
    //不能通过常引用b来修改变量值

    //b = 50;  错
    a = 50;

    //普通引用只能用作左值；常引用也叫万能引用，左值右值都可以
    //int& i = 111;   普通引用--错
    const int& i = 111;
  

 

 

 

数组引用 

    int a[3] = { 10,20,30 };
    int(&aa)[3] = a;//数组的引用

 

函数的引用

#include <iostream>
using namespace std;

int add(int a, int b) {
    return a + b;
}


int main()
{
    
    int(&f)(int, int) = add;//函数的引用
    int x = f(10, 20);
    cout << x << endl;
        return 0;
    
}

 

 

 主要用途

引用型函数参数

用作函数的形参，通过将引用变量用作参数，函数将使用原始数据而不是其拷贝

void swip(int &a, int &b)  //a是i的引用，a和i的数据地址相同；b是j的引用，b和j的数据地址相同
{
    int s;
    s = a;
    a = b;
    b = s;
}

int main()
{
    int i = 100;
    int j = 10;
    swip(i, j);//ab数据交换后，ij的数据也就交换了
    cout << "i="<<i << endl;
    cout << "j=" << j << endl;
        
}

 

引用型返回值

 实例一

#include <iostream>

int func(int x,int y) {
    int num = x + y;
    return num;
}
//说明：返回的不是num，它是局部变量，函数结束就消亡，编译器把返回值放到一个临时变量里
//临时变量也是占用内存的;数值的拷贝也影响效率
//临时变量都是右值

int& func1(int x, int y) {
    int num = x + y;
    std::cout << "&num:" << &num << std::endl;
    std::cout << "num=" << num << std::endl;
    return num;
}
//函数的返回类型声明为引用,这是函数的返回结果就是return后面数据的别名
//这样可以避免返回值带来的开销，提高代码执行效率
//函数调用表达式的结果将变成一个左值

int main()
{
    int &a = func1(10, 20);
    std::cout << "&a:" << &a << std::endl;  //a的地址与num地址相同，说明a是num的引用
    std::cout << "a=" << a << std::endl; 
    //a的值并不是num的值，因为num已经消亡
    //注意：不要返回局部变量的引用--有危险;可以返回成员变量、静态变量、全局变量的引用
    

    system("pause");  //暂停
}

 

 

实例二 

 

#include <iostream>
using namespace std;

struct A {
    int data;
    int& func(void) {
        return data;  //返回变量data的引用
        //返回值变成了左值，data不是局部变量，可以返回它的引用
    }
};

int main()
{
    
    A a = { 105 };
    cout << a.data << endl;
    a.func() = 200;
    //a.func()是a.data的引用，a.func()是a.data的别名
    //所以这句是修改a.data的值
    cout << a.data << endl;
        return 0;
    
}

 

 

 &左值引用   &&右值引用

 

引用与指针 

引用的本质就是指针

#include <iostream>

int main()
{
    int i = 100;
    int* p = &i;
    std::cout << "p:" << p << std::endl;

    int& r = i;
    std::cout << "&r:" << &r << std::endl;

    //p与&r的值相同，说明引用的本质就是指针


    system("pause");  //暂停
}

 

指针可以为空指针，引用不能为空

指针可以不初始化，引用必须初始化

指针的目标可以改变(常指针除外)，引用的目标不能改变

可以定义多级指针，不能定义多级引用 

可以定义指针数组，不能定义引用数组

int i=10,j=20,k=30;

int* p[3] = {&i,&j,&k} ;  //oK   指针数组

int& p1[3] = {i,j,k};  //错    不能定义引用数组