C++入门学习：引用和常引用

在C中有个关键字typedef 用来给类型（int, char *, double....）取别名,但不能给变量a取别名（int a；）

在C++新增了一个概念：引用——给空间取别名（变量名a就代表了一块内存空间）

引用的方式：  类型 &要取的别名 = 原来的变量名；（引用变量必须要初始化）

eg：int &b = a；//b是a的引用，也就是a所代表的4字节空间的别名，a和b代表的是同一块空间；对b的操作就是对a的操作，反之亦然。

引用在一定的场合可以代替指针：

void swap(int &a1, int &b1)//传过来的是a和b的引用，就像之前说的对a1，b1的操作就是对a， b的操作

{

    int tmp = a1;//将 a和a1所代表的空间里的值 给 tmp保存
    a1 = b1;       //将  b和b1所代表的空间里的值  赋值  给a和a1所代表的空间

    b1 = tmp;     //将tmp保存的值 赋值给  b和b1所代表的空间里

}

int main()

{
    int a = 10;
    int b = 20;
    swap(a, b);
    printf("a = %d, b = %d\n", a, b);
    return 0;

}

复杂数据类型（例如结构体）做参数进行参数传递的时候，不要直接传变量名（传参的过程是一个值传递的过程，会有一个复制的过程，将实参的值复制给形参），可以传指针或引用，以便节省内存空间的开销提高效率。

eg：

struct Student
{
int id;
char name[20];
};

void print(Student *ps)
{
printf ("id = %d, name = %s\n", ps->id, ps->name);
}
// 传引用
void print1(Student &s1)
{
printf ("id = %d, name = %s\n", s1.id, s1.name);

}

//传指针的引用
void init (Student* &t)
{
t = (Teacher *)malloc(sizeof(Teacher)/sizeof(char));
t->id = 1;
strcpy(t->name, "小明");
}

int main()
{
Student s = {1, "小明"};
print (&s);

print1 (s);

        Student *p = NULL;
        init (p);
        printf ("id = %d, name = %s\n", p->id, p->name);

return 0;

}

引用：占4个字节的空间，必须要初始化

引用的内部实现：const 常量指针 //了解就行，还是用上面的方式使用引用

eg： int &b = a; =====>int *const b = &a;

函数的返回值 返回一个引用：不能返回一个栈上变量的引用（返回栈上变量的引用的相当于返回了栈上变量的地址，函数结束后函数内变量所用的空间释放，返回的引用不再可用），可以返回的引用：全局变量，静态变量，堆上的变量。。。

若返回栈变量
       不能成为其它引用的初始值
       不能作为左值使用

int &  func()
{
static int a = 10;
printf ("a = %d\n", a);
return a;

}

4种处理方式

int main()
{

func();                        //1 不接收

int b = func();             //2 用普通变量取收,收回来的是值，也就是10这个数，不是变量a代表的空间
b = 20;                      //不对静态变量a产生影响
func();                          

int &c = func();       //3 用引用去收，收回来的是空间，a所代表的空间
c = 25;                     //c和a代表同一块空间， 将他们代表的空间赋值为225
func();                      //显示改动后a的值

func() = 30;             //4 函数的返回值可以作为左值来使用，将返回的变量a的空间赋值为30

func();                    //显示改动后a的值

return 0;
}

常引用

目的：不想通过引用来改变原来空间的值

形式： const int &c = a//相当于  const int * const c = &a

常引用的初始化的两种方法：

int main()
{
int a = 10;
int &b = a;
//1 用变量对常引用进行初始化
const int &c = a;//const int * const pc = &a;
/*
c = 100;
printf("a = %d\n", a);
编译报错error C3892: “c”: 不能给常量赋值
*/


//2 用常量对常引用进行初始化
//引用是一个空间的别名 ----缺空间
//编译器会为这个常量开辟新的空间，将这个常量的值赋值给这个空间
//同时将d作为这个空间的别名
const int &d = 20;   //const int * const d = &20
printf("d = %d\n", d);


int *p = (int*)&d;
*p = 40;
printf("d = %d\n", d);


return 0;
}

常引用与引用的对比事例:

int add(const int &a, const int &b)//   常引用
{
return a + b;
}
/*

int add(int &a, int &b)//  引用，  主函数中 c = add(a, 10)；在调用函数add的时候会报错， int &b 与常量10的类型不匹配，
{                                 //不能用常量对引用赋值（引用——给空间取别名），形参需改成常引用           
return a + b;
}

*/

int main()
{
int a = 10;
int b = 20;
int c = add(a, b);

printf("c = %d\n", c);

c = add(a, 10);
printf("c = %d\n", c);
return 0;
}