【C++】12 经典问题剖析

const的疑问

const 常量的判别准则

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

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

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

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

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

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

#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("xr&= %p\n",&rx);

    printf("xnr&= %p\n",&nrx);
    volatile const int y = 2;
    int* p = const_cast<int*>(&y);
    
    *p = 6;
    
    printf("y = %d\n", y);
    printf("p = %p\n", p);
    
    const int z = y;
    
    p = const_cast<int*>(&z);
    
    *p = 7;
    
    printf("z = %d\n", z);
    printf("p = %p\n", p);
    
    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);

}

输出结果：

x= 1
rx= 5
nrx= 5
x&= 0xbf902fc8
xr&= 0xbf902fc8
xnr&= 0xbf902fc8
y = 6
p = 0xbf902fbc
z = 7
p = 0xbf902fb4
c = a
rc = a
trc = c

引用的疑问

指针时一个变量

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

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

指针可以被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
    
    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;
}

C++不支持引用数组；