C++对C语言的拓展（1）—— 引用

 1、变量名

变量名实质上是一段连续存储空间的别名，是一个标号（门牌号）；

通过变量来申请并命名内存空间；

通过变量的名字可以使用内存空间。

2、引用的概念

变量名，本身是一段内存的引用，即别名（alias）。引用可以看作一个已定义变量的别名。

引用的语法：Type & name = var；

用法如下：

#include <iostream>
using namespace std;

int main(void)
{
    int a = 10;//C编译器分配4个字节内存，a内存空间的别名
    int &b = a;//b就是a的别名

    a = 11;
    {
        int *p = &a;
        *p = 12;
        cout << a << endl;//12
    }
    b = 14;
    cout << "a=" << a << ",b=" << b << endl;//a=14,b=14
    return 0;
}

 3、规则

（1）引用没用定义，是一种关系型声明。声明它和原有某一变量（实体）的关系。故类型与原类型保持一致，且不分配内存，与被引用的变量有相同的地址。

（2）声明的时候必须初始化，一经声明，不可更改。

（3）可对引用，再次引用，多次引用的结果是某一变量具有多个别名。

（4）&符号前有数据类型时是引用，其它皆为地址。

#include <iostream>
using namespace std;

int main(void)
{
    int a,b;
    int &r = a;
    int &r = b;//error,不可更改原有的引用关系——规则（2）
    float &rr = b;//error，引用类型不匹配——规则（1）
    cout <<"&r="<< &r << ",&a=" << &a << endl;//变量与引用具有相同的地址——规则（1）
    int &ra = r;//可对引用再次引用，表示a变量有两个别名，分别是r和ra——规则（3）

    return 0;
}

 4、引用作为函数参数

普通引用在声明时必须用其它的变量进行初始化，引用作为函数参数声明时不进行初始化。

#include <iostream>
using namespace std;

struct Teacher
{
    char name[64];
    int age;
};
void printfT(Teacher *pT)
{
    cout << pT->age << endl;
}

void printfT2(Teacher &pT)//pT是t1的别名，相当于修改了t1
{
    pT.age = 33;
    cout << pT.age << endl;
}

void printfT3(Teacher pT)//pT和t1是两个不同的变量
{
    cout << pT.age << endl;
    pT.age = 45;//只会修改pT变量，不会修改t1变量
}

int main(void)
{
    Teacher t1;
    t1.age = 35;

    printfT(&t1);//35

    printfT2(t1);//33,pT是t1的别名
    printf("t1.age:%d
", t1.age);//33

    printfT3(t1);//33,pT是形参，t1拷贝一份数据给pT
    printf("t1.age:%d
", t1.age);//33

    return 0;
}

5、引用的意义

（1）引用作为其它变量的别名而存在，因此在一些场合可以代替指针；

（2）引用相对于指针来说具有更好的可读性和实用性。

c++中引入引用后,可以用引用解决的问题避免用指针来解决。

#include <iostream>
using namespace std;

struct student
{
    int age;
    char name[64];
};
void swap1(int *a, int *b) 
{
    int temp;
    temp = *a;
    *a = *b;
    *b = temp;
}

void swap2(int &a, int &b)
{
    int temp;
    temp = a;
    a = b;
    b = temp;
}

void printS1(struct student s)//子拷贝方式：student s=s1;结构体整个值拷贝的动作
{
    cout << s.age << " " << s.name << endl;
}

void printS2(struct student *sp)//指针方式
{
    cout << sp->age << " " << sp->name << endl;
}

void printS3(struct student &sp)//引用方式：student &s=s1;
{
    cout << sp.age << " " << sp.name << endl;
}

int main(void)
{
    int a = 10;
    int b = 20;
    swap1(&a, &b);
    cout << "a=" << a << ",b=" << b << endl;//a=20,b=10

    int c = 100;
    int d = 200;
    swap2(c, d);
    cout << "c=" << c << ",d=" << d << endl;//c=200,d=100

    student s1 = { 10,"zhang3" };
    printS1(s1);//10 zhang3
    printS2(&s1);//10 zhang3
    printS3(s1);//10 zhang3
    return 0;
}

 6、引用的本质

 引用做参数传递时，编译器会替我们将实参取地址给引用，即：int &a = main :: &b;//a是b的引用；

当对引用进行操作赋值时，编译器帮我们隐藏*操作，即：cout<<a其实是cout<<*a；*被编译器隐去了。

思考一：C++编译器定义引用时，背后做了什么工作？

引用所占大小与指针相同；常量要初始化，引用也要初始化，引用可能是一个常量；综上两点，引用可能是一个常指针。

• 当我们去研究引用的时候，可以将引用当作一个常指针去研究；
• 当使用引用编程时，就把引用理解为变量的别名就可以了。

思考二：普通引用有自己的空间吗？

（1）引用在C++中的内部实现是一个常指针：Type & name  <===>  Type* const name；

（2）C++编译器在编译过程中使用常指针作为引用的内部实现，因此引用所占用的空间大小与指针相同；

（3）从使用的角度，引用会让人误会其只是一个别名，没有自己的存储空间，这是C++为了实用性而做出的细节隐藏。

间接赋值的三个必要条件：

• 定义两个变量（一个实参，一个形参）；
• 建立关联，实参取地址传给形参；
• *p形参去间接的修改实参的值。

引用在实现上，只不过是把间接赋值成立的三个必要条件的后两个合二为一了。

当实参传给形参引用的时候，只不过是C++编译器帮我们程序员手工取了一个实参地址，传给了形参引用（常量指针）。

7、引用作为函数的返回值（引用当左值）

（1）当函数返回值为引用时，若返回栈变量，不能成为其它引用的初始值（不能作为左值使用）；

#include <iostream>
using namespace std;

int get1()
{
    int a;
    a = 10;
    return a;
}

int& get2()//返回值为引用
{
    int a;
    a = 10;
    return a;
}

int main(void)
{
    int a1 = 0;
    int a2 = 0;

    a1 = get1();//值拷贝
    a2 = get2();//将一个引用赋给一个变量，会有拷贝操作，可以理解为：编译器类似做了如下隐藏操作，a2=*(get2())
    int &a3 = get2();//将一个引用赋给另一个引用作为初始值，由于是栈的引用，内存非法
    
    cout << a1 << endl;//10
    cout << a2 << endl;//10
    cout << a3 << endl;//10
    cout << a3 << endl;//不一定为10

    return 0;
}

（2）当函数返回值为引用时，若返回静态变量或全局变量，可以成为其它引用的初始值（可作为右值使用，也可作为左值使用）

#include <iostream>
using namespace std;

int get1()
{
    static int a;
    a = 10;
    return a;
}

int& get2()//返回值为引用
{
    static int a;
    a = 10;
    return a;
}

int main(void)
{
    int a1 = 0;
    int a2 = 0;

    a1 = get1();//值拷贝
    a2 = get2();//将一个引用赋给一个变量，会有拷贝操作，可以理解为：编译器类似做了如下隐藏操作，a2=*(get2())
    int &a3 = get2();//将一个引用赋给另一个引用作为初始值，由于是静态区域，内存合法
    
    cout << a1 << endl;//10
    cout << a2 << endl;//10
    cout << a3 << endl;//10
    cout << a3 << endl;//10

    return 0;
}

（3）引用作为函数返回值，如果返回值为引用可以当左值，如果返回值为普通变量不可以当左值。

#include <iostream>
using namespace std;
 
int get1()//返回值为普通变量，函数当左值，返回的是变量的值
{
    static int a=10;
    return a;
}

int& get2()//返回值为引用，返回的是变量本身
{
    static int a = 10;
    return a;
}

int main(void)
{
    int c1 = get1();//函数当右值
    cout << "c1=" << c1 << endl;
    
    int c2 = get2();//函数返回值是一个引用，并且当右值
    cout << "c2=" << c2 << endl;
    
   //get1()=100;//error,函数当左值
    get2() = 100;//函数返回值是一个引用，并且当左值

    c2 = get2();
    cout << "c2=" << c2 << endl;

    return 0;
}

8、指针引用

指针是一个存放地址的变量，而指针引用指的是这个变量的引用，即对指针的引用，众所周知C++中如果参数不是引用的话会调用参数对象的拷贝构造函数，所以如果有需求想改变指针所指的对象（换句话说，就是要改变指针里面存的地址），就要使用指针引用。

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;

struct teacher
{
    int id;
    char name[64];
};

int get_mem(struct teacher** tpp)
{
    struct teacher *tp = NULL;
    tp = (struct teacher*)malloc(sizeof(struct teacher));
    if (tp == NULL)
    {
        return -1;
    }
    tp->id = 100;
    strcpy(tp->name, "li4");

    *tpp = tp;//tpp是实参的地址，*实参的地址去间接的修改实参的值
    return 0;
}

void free_teacher(struct teacher **tpp)
{
    if(tpp==NULL)
    {
        return ;
    }
    struct teacher *tp = *tpp;
    if (tpp != NULL)
    {
        free(tp);
        *tpp = NULL;
    }
}

int get_mem2(struct teacher* &tp)//指针的引用做函数参数
{
    tp = (struct teacher*)malloc(sizeof(struct teacher));//给tp赋值，相当于给main函数中的tp赋值
    if (tp == NULL)
    {
        return -1;
    }
    tp->id = 300;
    strcpy(tp->name, "wang5");
    return 0;
}

void free_teacher2(struct teacher *&tp)
{
    if (tp != NULL)
    {
        free(tp);
        tp = NULL;
    }
}

int main(void)
{
    struct teacher *tp = NULL;
    get_mem(&tp);//C语言中的二级指针
    cout << "id=" << tp->id << ",name=" << tp->name << endl;//id=100,name=li4
    free_teacher(&tp);

    get_mem2(tp);//指针的引用
    cout << "id=" << tp->id << ",name=" << tp->name << endl;//id=300,name=wang5
    free_teacher2(tp);
    return 0;
}

 9、const引用

 const引用可以防止对象的值被随意修改。

（1）const对象的引用必须是const的，将普通引用绑定到const对象是不合法的，原因：既然对象是const的，表示不能被修改，引用当然也不能修改，必须使用const引用。

const int a=1;

int &b=a;//这种写法是不合法的，编译不过。

（2）const引用可使用相关类型的对象（常量，非同类型的变量或表达式） 初始化。这个是const引用与普通引用最大的区别。

即：

const int &a=2；//是合法的；

double a=3.14；

const int &b=a；//也是合法的

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;

int main(void)
{
    //普通引用
    int a = 10;
    int &b = a;
    cout << "b=" << b << endl;//b=10

    //const引用
    const int c = 20;
    const int &d = c;//如果想对一个常量进行引用，必须是一个const引用
    cout << "c=" << c << endl;//x=20
    cout << "d=" << d << endl;//y=20

    //const引用
    int x = 100;
    const int &y = x;//相反，如果一个普通变量，用一个const引用接收是可以的
    cout << "x=" << x << endl;//x=100
    cout << "y=" << y << endl;//y=100
    
    x = 21;
    //y = 22;//error,常引用限制为只读，不能通过y去修改x的值
    cout << "x=" << x << endl;//x=21
    cout << "y=" << y << endl;//y=21
    
    return 0;
}

10、const引用的原理 

const引用的目的是，禁止通过修改引用值来改变被引用的对象。const引用的 初始化特性较为微妙,可通过如下代码说明:

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;

int main(void)
{
    double val = 3.14;
    const int &ref = val;
    double &ref2 = val;
    cout << "ref=" << ref<<",ref2="<<ref2 << endl;//ref=3,ref2=3.14

    val = 4.14;
    cout << "ref=" << ref << ",ref2=" << ref2 << endl;//ref=3,ref2=4.14

    return 0;
}

上述输出结果为 ref=3,ref2=3.14 和 ref=3,ref2=4.14。因为 ref 是 const 的,在初始化的过程中已经给定值,不允许修改。而被引用的对象是 val,是非 const 的,所以 val的修改并未影响ref的值,而 ref2 的值发生了相应的改变。

那么,为什么非 const 的引用不能使用相关类型初始化呢?实际上,const引用 使用相关类型对象初始化时发生了如下过程:

int temp = val;
const int &ref = temp;

 如果 ref 不是 const 的,那么改变 ref 值,修改的是 temp,而不是 val。期望对 ref 的赋值会修改 val 的程序员会发现 val 实际并未修改。

结论：

1）const int & e 相当于 const int * const e

2）普通引用 相当于 int *const e

3）当使用常量（字面量）对const引用进行初始化时，C++编译器会为常量值分配空间，并将引用名作为这段空间的别名

4）使用字面量对const引用初始化后，将生成一个只读变量