关键字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 = ; //  error!
 p++; // ok

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

case 2:

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

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

case 3:

 const int * const p;
 *p = ; // 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[] = ;

    return;
}

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

    printf("before fun called: \n");

    size_t i = ;
    while (i--)
    {
        printf("pA[%d] = %d \n", (-i), pA[-i]);
    }

    fun_SomeManage(pA,);

    printf("after fun called: \n");
    i = ;
    while (i--)
    {
        printf("pA[%d] = %d \n", (-i), pA[-i]);
    }

    return ;
}

编译:

# make const

有警告:

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

运行结果:

# ./const
before fun called:
pA[] =
pA[] =
pA[] =
pA[] =
after fun called:
pA[] =
pA[] =
pA[] =
pA[] =  

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

The End.