经典问题解析

一、关于const的疑问

 1.const常量的判别准则

     --- 只用用字面量初始化的const常量才会进入符号表

     --- 使用其它变量初始化的const常量仍然是只读变量

     --- 被volatile修饰的const的常量不会进入符号表，只是的得到一个只读变量，而这个只读变量不能出现在赋值符号的左边

  

    注意：在编译期间不能直接确定初始值的const标识符，都被作为只读变量处理

 

 2.const引用的类型与初始化变量的类型

        --相同：初始化变量称为只读变量

        --不同：生成一个新的只读变量

#include<stdio.h>
int main()
{
	
	const int x=1;  //x进入符号表
	
	const int& rx=x; //rx为只读变量，内存空间由编译器为x分配的
	
	int& nrx =const_cast<int&>(rx); //	去掉rx的只读属性
	
	nrx=5;
	
	printf(" x = %d\n",x);
	printf(" rx =%d\n",rx);
	printf("nrx = %d\n",nrx);
	
	printf(" &x = %p\n",&x);
	printf(" &rx =%p\n",&rx);
	printf("&nrx = %p\n",&nrx);
	
	
	volatile const int y =2; //只读变量而不是常量
	
	int* p =const_cast<int*>(&y);
	
	*p =6;
	printf(" y = %d\n",y);
	printf(" &y = %p\n",&y);
	
	const int z=y; //y 只是一个变量，所以z也是只读变量
	 p =const_cast<int*>(&z);
	
	*p =7;
	printf(" z = %d\n",z);
	printf(" &p = %p\n",&p);
	
	/*用不同的变量类型初始化const引用*/
	char c ='c';
	char& rc =c;
	const int& trc = c;
	 
	 rc='a';
	
	printf("  c = %c\n",c);
	printf("  rc = %c\n",rc);
	printf(" trc = %c\n",trc);  //const引用初始变量类型不同，将产生一个新的只读变量
	return 0;
}

二、引用与指针的关系

     1.指针是一个变量

         --值为一个内存地址，不需要初始化，可以保存不同的地址

          --通过指针可以访问对应内存地址中的值

          --指针被const修饰称为常量或者只读变量

      2.引用只是一个变量的新名字

        --对引用的操作(赋值,取地址等)等会传递到代表的变量上

         --const引用使其代表的变量具有只读属性

        --引用必须在定义时初始化，之后无法代表其它变量

      3.从使用C++语言的角度看

          -- 引用与指针没有任何关系

          --引用是变量的新名字，操作引用就是操作对应的变量

     4.从C++编译器的角度看

         -- 在编译器内部，使用指针常量来实现“引用”

          --因此 “引用”在定义时必须初始化

    5.c++中不支持引用数组

#include<stdio.h>
int a =1;
struct SV
{
	int &x;
	int &y;
	int &z;
	
};
int main()
{
	int b=2;
	int* pc = new int(3);
	
	//
	//&array[1] - &array[0] = ? 期望是4，实际地址差异很大
	//int& array[]={a,b,*pc};  //报错，因为数组中的每个元素是顺序存放的
	
	SV sv={a,b,*pc};
	/*地址差异很大，因为成员存在的区不一样*/
	printf("&sv.x = %p\n",&sv.x);
	printf("&sv.y = %p\n",&sv.y);
	printf("&sv.z = %p\n",&sv.z);
	
	delete pc;
	return 0;
		
}