进化后的const分析

1 C语言中的const

• const修饰的变量是只读的，本质还是变量。
• const修饰的局部变量在栈上分配空间。
• const修饰的全局变量在只读存储区分配空间。
• const只在编译器有用，在运行期无用。
• const修饰的变量不是真的常量，它只是告诉编译器该变量不能出现在赋值符号的左边。
• C语言中的const使得变量具有只读属性。
• const将具有全局生命周期的变量存储于只读存储区。
• const不能定义真正意义上的常量（enum才是真正意义上的常量）。

#include <stdio.h>

int main()
{
    const int c = 0;    //如果不初始化：error: uninitialized const ‘c’
    int* p = (int*)&c;

    printf("Begin...\n");

    *p = 5;

    printf("c = %d\n", c);

    printf("End...\n");

    return 0;
}

2 C++ 中的const

C++在C的基础上对const进行了处理：

• 当碰见const声明时在符号表中放入常量；
• 编译过程若发现使用常量则直接以符号表中的值替换；
• 编译过程中若发现下述情况则给对应的常量分配存储空间。
  
  • 对const常量使用了extern。
  • 对const常量使用了& 操作符。

注意：C++编译器虽然可能为const常量分配空间，但不会使用其存储空间中的值。

• C语言中的const常量

  • C语言中的const变量是只读变量，会分配存储空间。

• C++中的const常量

  • 可能会分配存储空间：当const常量为全局变量，并且需要在其他文件中使用，当使用& 操作符对const常量取地址。

• C++中的const常量类似于宏定义：

  • cons tint c = 5; ≈ #define c 5

• C++中的const常量与宏定义不同：

  • const常量是由编译器处理；
  • 编译器对const常量进行类型检查和作用域检查；
  • 宏定义由预处理器处理，单纯的文本替换。

实例分析：编程实验：const与宏

#include <stdio.h>

void f()
{
    #define a 3
    const int b = 4;
}

void g()
{
    printf("a = %d\n", a);
    //printf("b = %d\n", b); //error
}

int main()
{
    const int A = 1;
    const int B = 2;
    int array[A + B] = {0};
    int i = 0;

    for(i=0; i<(A + B); i++)
    {
        printf("array[%d] = %d\n", i, array[i]);
    }

    f();
    g();

    return 0;
}

小结

• 与C语言不同，C++中的const不是只读变量。
• C++中的const是一个真正意义上的常量。
• C++编译器可能会为const常量分配空间。
• C++完全兼容C语言中const常量的语法特性。

3 关于const的疑问

const什么时候为只读变量？什么时候是常量？

• const常量的判别准则
  
  • 只有用字面量初始化的const常量才会进入符号表；
  • 使用其他变量初始化的const常量仍然是只读变量；
  • 被volatile修饰的const常量不会进入符号表。

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

• cosnt引用的类型与初始化变量的类型：
  
  • 相同：初始化变量成为只读变量；
  • 不同：生成一个新的只读变量。

编程实验：cosnt典型问题分析

#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);

    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;//char会默认转换为int，编译通过，生成新的只读变量

    rc = 'a';

    printf("c = %c\n", c);//a
    printf("rc = %c\n", rc);//a
    printf("trc = %c\n", trc);//c

    return 0;
}

/*
x = 1
rx = 5
nrx = 5
&x = 0xbf8c849c
&rx = 0xbf8c849c
&nrx = 0xbf8c849c
y = 6
p = 0xbf8c84a0
z = 7
p = 0xbf8c84a4
c = a
rc = a
trc = c
*/

4 const对象

const关键字能否修饰类的对象？如果可以，有什么特性？

• const关键字能够修饰对象

  • const修饰的对象为只读对象；
  • 只读对象的成员变量不允许被改变；
  • 只读对象是编译阶段的概念，运行时无效。

• C++中的const成员函数

  • const对象只能调用const成员函数；
  • cosnt成员函数中只能调用const成员函数；
  • const成员函数中不能直接改写成员变量的值。

• const成员函数的定义：

  • Type ClassName::function(Type p)const
  • 类中的函数声明与实际函数定义中都必须带const关键字。

编程实验：类的const函数初探

#include <stdio.h>

class Test
{
    int mi;
public:
    Test(int i);
    Test(const Test& t);
    int getMi();
};

Test::Test(int i)
{
    mi = i;
}

Test::Test(const Test& t)
{

}

int Test::getMi()
{
    return mi;
}

int main()
{
    Test t(1);

    return 0;
}

小结

• const关键字能够修饰对象，得到只读对象。
• 只读对象只能调用const成员函数。