狄泰C++课程学习笔记：第十二课：经典问题解析一 - 引用

1、如何区分某个被const修饰的变量到底是只读变量还是真正意义上的常量？

    从根本上来说：就是看编译器在编译的过程中能否直接确定该变量的值，能，则为真正意义上的常量，否则，即为只读变量（只读变量的意义就是在改变量的作用域内，该变量不能出现在赋值符号的左边）

    从细节上来说，大致可以分为以下几种情况：

    * 在定义时直接使用字面量来进行初始化的，可以被直接编译进入符号表，成为真正意义上的常量。

        如：const int x = 5;    // 常量

    * 在定义时是使用已经存在的变量进行初始化的，则会生成一个只读变量

        如： int y = 0; const int& ry = y;    此时，引用ry即具有只读属性

    * 某个变量在定义的时候同时使用 volatile 和 const 进行修饰，则会生成一个只读变量

        如： volatile const int z = 0;    // z为只读变量

    * 在定义某个已有变量的引用时，引用的类型和变量的类型不相同，则会生成一个新的变量

        如：char c = 'a';    const int& rc = c;    // 此时rc所代表的的内存空间为从栈中新开辟的内存空间，和变量c所占空间不同

小例如下：

    

// ConsoleApplication1.cpp : 定义控制台应用程序的入口点。

#include "stdafx.h"

#include <stdio.h>

int main(int argc, char** argv)
{
	const int x = 0;
	const int& rx = x;
	int& crx = const_cast<int&>(rx);
	
	crx = 5;

	printf("x = %d\n", x);
	printf("rx = %d\n", rx);
	printf("crx = %d\n", crx);
	printf("&x = %p\n", &x);
	printf("&rx = %p\n", &rx);
	printf("&crx = %p\n", &crx);

	int i = 1;
	const int y = i;
	const int& ry = y;
	int& cry = const_cast<int&>(ry);

	cry = 10;

	printf("y = %d\n", y);
	printf("ry = %d\n", ry);
	printf("cry = %d\n", cry);
	printf("&y = %p\n", &y);
	printf("&ry = %p\n", &ry);
	printf("&cry = %p\n", &cry);

	char c = 'c';
	char& rc = c;
	const int& nrc = c;

	rc = 'a';

	printf("c = %d\n", c);
	printf("rc = %d\n", rc);
	printf("nrc = %d\n", nrc);
	printf("&c = %p\n", &c);
	printf("&rc = %p\n", &rc);
	printf("&nrc = %p\n", &nrc);

	volatile const int z = 0;
	int* p = const_cast<int*>(&z);

	*p = 5;

	printf("z = %d\n", z);
	printf("*p = %d\n", *p);

	return 0;
}

2、引用的本质

在用户的角度：引用就是一个已存在的变量的别名，操作引用就是操作对应的变量所占用的内存空间

在编译器的角度：引用的本质就是一个指针常量，类似于 int* const p；也正是因为指针常量的缘故，引用一旦定义且初始化后不能更改，因为p的值一旦定义变不能更改。

注：C++中不支持引用数组。