关键字const

const关键字常和指针一起使用.

1,const给读代码的人传达非常有用的信息。比如一个函数的参数是const char *，你在调用这个函数时就可以放心地传给它char *或const char *指针，而不必担心指针所指的内存单元被改写。

2,尽可能多地使用const限定符，把不该变的都声明成只读，这样可以依靠编译器检查程序中的Bug，防止意外改写数据。

3,const对编译器优化是一个有用的提示，编译器也许会把const变量优化成常量。

环境: Linux 2.6.32-279.el6.i686

GCC版本: gcc 4.4.6 20120305 (Red Hat 4.4.6-4)

case 1:

const int *p; // int const *p;
*p = 1; //  error!
p++; // ok

两种写法是一样的,const 修饰*p ,p所指向的内存单元(*p)只读,即(*p)++违法;但是指针p可读写,即可以p++.

case 2:

int * const p;
*p = 1; // ok
p++;  // error

const修饰指针p, p的内容只读,即p++违法;p所指向的内存单元(*p)可读写,即(*p)++合法.

case 3:

const int * const p;
*p = 1; // error
p++; // error

第一个const 修饰 *p,*p只读,(*p)++违法;第二个const 修饰指针p,即指针p的内容只读,p++违法.

case 4:

const 指针与非const指针间的传递

1,指向非const变量的指针(非const变量的地址)可以传给指向const变量的指针，编译器可以做隐式类型转换;

函数形参中使用const关键字的,调用函数时可以放心的

char c = 'a';
const char *pC = &c; // ok

2,指向const变量的指针传递给指向非const变量的指针非法,编译器报错:"初始化丢弃了指针目标类型的限定."

const char s = 'b';
char * pS = &s; // error!

case 5:

如果要定义一个指针指向字符串字面值,最好使用const,虽然不用也不会报错,但是这样就存在了隐患.

const char * pB = "abc";
*pB = 'q'; // error
// 编译时就会报错,不允许向只读位置赋值

char *pA = "abc"; // 这里编译无错无警告
*pA = 'd'; // 这里编译也无错无警告

// 但是运行时报段错误

case 6: 

函数形参中使用关键字const ,调用函数时可以放心地把char *和const char *传递给它,而不必担心指针所指的内存单元被改写.

void foo(const char *pS)
{
    ...
    *pS = 'a' // error 无法编译通过
    ...
}
     ...
const char *pC = "abc"; // 指针定义
char a[] = "abc"; // 数组定义
 ...
 foo(pC); // ok
 foo(a); // ok

注:函数的指针形参用数组方式亦可

void foo(const char pS[]);

case 7:

const并不能完全防止值的修改,只要在函数中把const指针再赋给普通指针.

/* file: const.c */

#include <stdio.h>
#include <stdlib.h>

void fun_SomeManage(const int *pA, size_t count)
{
    int *ucpA = pA;
    ucpA[2] = 10;

    return;
}


int main(int argc,char * argv[])
{
    int pA[4] = {1,2,3,4};

    printf("before fun called: 
");
        
    size_t i = 4;
    while (i--)
    {
        printf("pA[%d] = %d 
", (3-i), pA[3-i]);
    }

    fun_SomeManage(pA,4);

    printf("after fun called: 
");

    i = 4;
    while (i--)
    {
        printf("pA[%d] = %d 
", (3-i), pA[3-i]);
    }
    
    return 0;
}

编译:

# make const

有警告:

cc     const.c   -o const
const.c: 在函数‘fun_SomeManage’中:
const.c:8: 警告：初始化丢弃了指针目标类型的限定

运行结果:

# ./const 
before fun called: 
pA[0] = 1 
pA[1] = 2 
pA[2] = 3 
pA[3] = 4 
after fun called: 
pA[0] = 1 
pA[1] = 2 
pA[2] = 10 
pA[3] = 4 

说明const指针传给非const指针后,虽然编译器会有警告,但是并不干涉通过新的指针修改值了.

The End.