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;

指针和引用

指针是一个变量
- 值为一个内存地址，不需要初始化，可以保存不同的地址
- 通过指针可以访问对应内存地址中的值
- 指针可以被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;
}

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

const常量的判别标准

指针和引用

猜你喜欢