C++中的引用

变量名回顾

c++中的引用

在C++中新增加了引用的概念
引用可以看作一个已定义变量的别名
引用的语法：Type& name = var;

#include <stdio.h>

int main(int argc, char *argv[])
{
    int a = 4;
    int& b = a; //定义引用
    
    b = 5;
    
    printf("a = %d\n", a);
    printf("b = %d\n", b);
    printf("&a = %08X\n", &a);
    printf("&b = %08X\n", &b); //
    
    printf("Press enter to continue ...");
    getchar();	
    return 0;
}

运行结果：

注意：普通引用在声明时必须用其它的变量进行初始化。

引用的意义：

引用作为其它变量的别名而存在，因此在一些场合可以代替指针
引用相对于指针来说具有更好的可读性和实用性

注意：

引用作为函数参数声明时不进行初始化。

#include <stdio.h>

void swap(int& a, int& b)
{
    int t = a;
    a = b;
    b = t;
}

int main(int argc, char *argv[])
{
    int a = 4;
    int b = 5;
    
    swap(a, b);
    
    printf("a = %d\n", a);
    printf("b = %d\n", b);
    
    printf("Press enter to continue ...");
    getchar();	
    return 0;
}

const常引用：

在C++中可以声明const引用
const Type& name = var；
const引用让变量拥有只读属性（不能出现在赋值符号的左边）

#include <stdio.h> 
int main()
{
	int a = 4;
	const int& b = a;
	
	b = 5; //error
	
	printf("a = %d\n", a);
	printf("b = %d\n", b);
}

那么如何修改const引用的值那？

A：用指针

#include <stdio.h> 
int main()
{
	int a = 4;
	const int& b = a;
    
    int* p = (int*)&b;
	
	//b = 5; //error
	*p = 5;
	
	printf("a = %d\n", a);
	printf("b = %d\n", b);
}

const常引用 用常量初始化

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

#include <stdio.h> 

int main()
{
	const int& b = 1;
	
//	b = 5; //error
	
	printf("b = %d\n", b);
}

Tip:
使用常量对const引用初始化后将生成一个只读变量。

#include <stdio.h> 

int main()
{
	const int& b = 1;
	
	int* p = (int*)&b;
	
//	b = 5; //error
	*p = 5;
	
	printf("b = %d\n", b);
}

引用有自己的存储空间吗？

引用既然是变量的别名，那么引用有自己的存储空间吗？

#include <stdio.h>

struct TRef
{
    int& a;
    int& b;
};

int main(int argc, char *argv[])
{
    printf("sizeof(TRef) = %d\n", sizeof(TRef));
    
    printf("Press enter to continue ...");
    getchar();	
    return 0;
}

运行结果：

分析：证明引用有自己的存储空间。

引用在C++中的内部实现是一个常指针

Type& name <- -> Type* const name

Improtance：
C++编译器在编译过程中使用常指针作为引用的内部实现，因此引用所占用的空间大小与指针相同。
从使用的角度，引用会让人误会其只是一个别名，没有自己的存储空间。这是C++为了实用性而做出的细节隐藏。

void f(int& a)
{
    a = 5;
}

//等价于

void f(int* const a)
{
    *a = 5;
}

证据

#include <iostream>
using namespace std;

struct TRef{
	int& a;
	int& b;
	int& c;
};

int main()
{	
	int a;
	int b;
	int c;
	
	TRef rA = {a,b,c};
	
	cout << &a << endl;
	cout << &b << endl;
	cout << &c << endl; //a,b,c的内存地址是连续的，相差4字节 
	
	cout << &rA << endl; //&rA与&c相差恰好12个字节 
	cout << sizeof(TRef) <<endl; //12
	 	
	return 0;
}

当函数返回值为引用时

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

若返回静态变量或全局变量
可以成为其他引用的初始值
即可作为右值使用，也可作为左值使用

#include <stdio.h>

int& f()
{
    static int a = 0;
    
    return a;
}

int& g()
{
    int a = 0;
    
    return a; //[Warning] reference to local variable 'a' returned [-Wreturn-local-addr]
}

int main()
{
    int a = g();
    int& b = g(); //局部变量不能成为其它引用的初始值 此处b的值将是随机的
    
    f() = 10;
    
    printf("a = %d\n", a);
    printf("b = %d\n", b);
    printf("f() = %d\n", f());
    
    printf("Press enter to continue ...");
    getchar();	
    return 0;
}

tips：

引用的实质是指针，返回局部变量的引用相当于 返回局部变量的指针。

C++对三目运算符做了什么？

当三目运算符的可能返回都是变量时，返回的是变量引用

当三目运算符的可能返回中有常量时，返回的是值

int a = 1;
int b = 2;
(a < b ? a : b) = 3; //正确，返回a或b的引用，可以作为左值使用

(a < b ? 11 : b) = 3; //错误，可能返回中有常量，返回的是值，不能作为左值使用