9. c++中的const，引用和指针

const常量的判别标准

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

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

被volatie 修饰const常量不会进入符号表

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

const引用的类型和初始化变量的类型

相同：初始化成为只读变量

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

char c = 'c';
const char& trc = c;
c = 'a';
printf("&c = %p\n", &c);
printf("&trc = %p\n", &trc);
printf("c = %c\n", c);
printf("trc = %c\n", trc);
输出：&c = 008FFD13
&trc = 008FFD13
c = a
trc = a          //地址相同，改变了c   trc也改变
当const引用的类型和初始化变量的类型相同，则地址相同，说明初始化成为了一个只读变量trc

char c = 'c';
const int& trc = c;
printf("&c = %p\n", &c);
printf("&trc = %p\n", &trc);
printf("c = %c\n", c);
printf("trc = %c\n", trc);
输出：&c = 00AFFCDB
&trc = 00AFFCC0
c = a
trc = c           //地址不相同，改变c  trc不变
当const引用的类型和初始化变量的类型不同，则地址不相同，说明生成一个新的只读变量trc

#include <stdio.h>

int main()
{
const int x = 1;      //常量
const int& rx = x;     //只读变量

int& nrx = const_cast<int&>(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);
//输出结果：
x = 1
rx = 5
nrx = 5
&x = 010FFCDC
&rx = 010FFCDC
&nrx = 010FFCDC
-----------------------------------------------------------------------
volatile const int y = 2;      //具有只读属性
int* p = const_cast<int*>(&y);  //去除其只读属性

*p = 6;

printf("y = %d\n", y);   // y 值改变  输出y = 6
printf("p = %p\n", p);

const int z = y;            //用变量初始化，只具有只读属性

p = const_cast<int*>(&z);   //去除只读属性

*p = 7;

printf("z = %d\n", z);     //z = 7
printf("p = %p\n", p);
---------------------------------------------------------------------

const int z = 99;          //常量

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

*p = 7;
printf("z = %d\n", z);    //***** z值不变   z = 99   从符号表中取，在编译期间这里已经是99了
printf("*p = %d\n", *p);  // *p =7
printf("p = %p\n", p);    //地址和  &z 相同
printf("&z = %p\n", &z);
-------------------------------------------------------
char c = 'c';
char& rc = c;
const int& trc = c;

rc = 'a';

printf("c = %c \n",c);      //a
printf("rc = %c \n",rc);    //a
printf("trc = %c \n",trc);  //c   const引用的类型和初始化变量的类型不同,生成一个新的只读变量
return 0;
}

默认情况，const对象只在文件内有效，要想在别文件也引用， 不管是申明还是定义==都==在前面加上 extern

//file_1.cpp
extern const int test = 0;

//file_2.cpp
extern const int test;

-

typedef char* pstring;

const pstring cstr = 0; //等价于 char* const cstr = 0;

指针和引用

4000

指针是一个变量

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

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

指针可以被const修饰成常量或者只读变量

引用是一个变量的新名字

对引用的操作（赋值，取地址等）都会传递到代表的变量上

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

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

不能使用引用数组，==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);
SV sv = {a, b, *pc};
int& array[] = {a, b, *pc}; // &array[1] - &array[0] = ?  Expected ==> 4
//error，c++不支持引用数组

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;
}