const和volatile分析

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

（1）const修饰的变量是只读的，本质还是变量

（2）const修饰的局部变量在栈上分配空间

（3）const修饰的全局变量在全局数据区分配空间(vc、gcc会将其放入常量区，bcc放入全局数据区)

（4）const只在编译期有用，在运行期无用（可用指针改变）

【编程实验】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的本质——不能定义真正意义上的常量

（1）C语言中的const使得变量具有只读属性

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

    【注意】标准C语言编译器（如bcc）不会被const修饰的全局变量存储于只读存储区，而是存储于可修改的全局数据区，其值依然可以改变。

【编程实验】const本质的分析

#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修饰函数参数和返回值

（1）const修饰函数参数表示在函数体内不希望改变参数的值

（2）const修饰函数返回值表示返回值不可改变。多用于返回指针的情形，即该指针所指的内容不可被改变。

【小贴士】C语言中的字符串字面量存储于只读存储区中，在程序中需要使用const char*指针

#include <stdio.h>

int main(){
    const char* s= "I like programming!"; //存储于只读存读区
}

【实例分析】const修饰函数参数与返回值

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

4. const修饰数组

（1）在C语言中const修饰的数组数只读的

（2）const修饰的数组空间的不可被改变

const int A[5]={1, 2, 3, 4, 5};
int* p = (int *)A;

int i = 0;
for(i=0; i<5; i++)
{
    p[i] = 5 -i; //oops!
}

5. const修饰指针

（1）const int* p;     //p可变，p指向的内容不可变

（2）int const* p;     //p可变，p指向的内容不可变

（3）int* const p;     //p不可变，p指向的内容可变

（4）const int* const p;   //p不可变，p指向的内容不可变

口诀：左数右值

      当const出现在*号左边时指针指向的数据为常量；当const出现在*号右边时指针本身为常量。

 

int main()
{
     int i = 0;
     const int* p = &i;
     
     *p = 3;  //编译出错，数值不可改变
      p =NULL;  //编译通过
}

 

6. 深藏不露的volatile

（1）volatile可理解为“编译器警告指示字”

（2）volatile告诉编译器必须每次去内存中取变量值

（3）volatile主要修饰可能被多个线程访问的变量

（4）volatile也可以修饰可能被未知因数更改的变量

 

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

（1）变量i具有什么样的特性：i为int型变量，每次都必须到内存取值，且i是只读变量。

（2）编译器如何处理这个变量：i不能作为左值

8. 小结

（1）const使得变量具有只读属性

（2）const不能定义真正意义上的常量

（3）const将具有全局生命期（含static属性的）的变量存储于只读存储区中

（4）volatile强制编译器减少优化，必须每次到内存中去取值