c语言深度剖析(9)—const和volatile分析

1. const只读变量——（注意不是真正常量，只是告诉编译器不能出现在赋值号左边！）

• const修饰的变量是只读的，本质还是变量
• const修饰的局部变量在栈上分配空间
• const修饰的全局变量在全局数据区分配空间(vc、gcc会将其放入常量区，bcc放入全局数据区)
• const只在编译期有用（只能出现在赋值符号左边），在运行期无用

#include <stdio.h>

const int g_cc = 2; // bcc下放入全局数据区，可修改。
                   // vc、gcc将其放入常量区，不可修改

int main()
{
    const int cc = 1;  //栈中
    
    int *p = (int *)&cc;
    
    printf("cc = %d\n", cc);
    
    *p = 3;
    
    printf("cc = %d\n", cc);
    
    p = (int *)&g_cc;
    
    printf("g_cc = %d\n", g_cc);
    
    *p = 4; //bcc编译器下没问题，vc\gcc下会出错。
    
    printf("g_cc = %d\n", g_cc);
    
    return 0;
}

 

2. const的本质——不能定义真正意义上的常量

• C语言中的const使得变量具有只读属性
• 现代C编译器(如Vc、gcc)中的const将具有全局生命周期（如全局变量，static属性的变量）存储于只读存储区，修改该变量时将导致程序崩溃。

#include <stdio.h>

const int g_array[5] = {0};

void modify(int *p, int v)
{
    *p = v;
}

int main()
{
    int const i = 0;      //相当于const int i=0;
    const static int j = 0;
    int const array[5] = {0}; //相当于const int array[5]={0};
    
    modify((int *)&i, 1);           // ok
    modify((int *)&j, 2);           // error
    modify((int *)&array[0], 3);    // ok
    modify((int *)&g_array[0], 4);  // error
    
    printf("i = %d\n", i);
    printf("j = %d\n", j);
    printf("array[0] = %d\n", array[0]);
    printf("g_array[0] = %d\n", g_array[0]);
    
    return 0;
}

3. const修饰函数参数和返回值

• const修饰函数参数表示在函数体内不希望改变参数的值
• const修饰函数返回值表示返回值不可改变，多用于返回指针的情形。
• C语言中的字符串字面量存储于只读存储区中，在程序中需要使用const char*指针

#include <stdio.h>

int main()
{

    const char* s= "I like programming!"; //存储于只读存读区

}

4.编程实验

#include <stdio.h>

const char* f(const int i)
{
    i = 5;//错误，i不能作为左值
    
    return "I like programming!";
}

int main()
{
    char *pc = f(0); // 警告，f的返回值为const char*
    
    printf("%s\n", pc);
    
    pc[1] = '_'; // 错误，试图修改只读存储区中的数据
    
    printf("%s\n", pc);
    
    return 0;
}

5. 深藏不露的volatile

• volatile可理解为“编译器警告指示字”
• volatile告诉编译器必须每次去内存中取变量值
• volatile主要修饰可能被多个线程访问的变量
• volatile也可以修饰可能被未知因数更改的变量

void code()
{
    int obj = 100;
    
    int a = 0;
    int b = 0;
    
    a = obj;
    sleep(100);
    b = obj;
}

• 编译器做了什么？
  • 编译器在编译时发现obj没有被当成左值使用，因此会"聪明"的直接替换成10，而把a和b都赋值为10。
  • 因为编译器会自作聪明不去在读取内存，如果是多线程的编程或者有中断，当a = obj；以后在中断或者另一个线程里面改变了obj的值，那么之后b = obj；得到的不是想要的值。

6.有趣的问题——const volatile int i=0;

• 变量i具有什么样的特性：i为int型变量，每次都必须到内存取值，且i是只读变量。
• 编译器如何处理这个变量：i不能作为左值
• const和volatile放在一起的意义在于：
  • 本程序段中不能对a作修改，任何修改都是非法的，或者至少是粗心，编译器应该报错，防止这种粗心；
  • 另一个程序段则完全有可能修改，因此编译器最好不要做太激进的优化。

7. 小结

• const使得变量具有只读属性
• const不能定义真正意义上的常量
• const将具有全局生命期（含static属性的）的变量存储于只读存储区中
• volatile强制编译器减少优化，必须每次到内存中去取值