指针常量与常量指针（const用法总结）

const是一个C语言的关键字，它限定一个变量不允许被改变。使用const在一定程度上可以提高程序的安全性和可靠性

指向常量的指针：

const int *pa;

int const *pa;

两者等价。因为指向常量的指针有时候会指向常量，所以它具有这个性质：“不能靠解引用改变它指向的对象的值”，以此保护它所指向的常量的常量性：

*pa =d; // 不可行（d是已经声明过的整型）

但指针本身的值是可变的：

pa=& d; // 可行（d是已经声明过的整型）

而且指向常量的指针有时候也会指向变量，如下：

int t,u;

const int *pa;

pa =&t; //可行，指向变量t

pa =&u; //也可行，指向变量u

我们可以把它理解成：“为了指向常量而发明的指针”，这样比较贴切。

常量指针：

int *const pa =&n; // n是之前已经声明过的整型变量，注意必须是变量，理由见下

“常量指针”即指针本身的值是常量，但“能靠解引用改变它指向的对象的值”，如下：

pa=&d; // 不可行（d是已经声明过的整型）

*pa =d; // 可行（d是已经声明过的整型）

因为常量指针也是一种const常量，所以它同样必须在第一次声明时就初始化，不过它的初始值缩小为只能是变量（的地址），因为只有变量才能确保以后能靠解引用而改变它指向的对象的值。这使得常量指针不象一般的const常量，用变量或常量初始化都可以。

也就是说，常量指针反而总是指向变量的。

举例：

typedef char * pStr; char string[4] = "abc"; const char *p1 = string; const pStr p2 = string; p1++; p2++;

　　答案与分析：

　　问题出在p2++上。

　　1)、const使用的基本形式： const char m;

　　限定m不可变。

　　2)、替换1式中的m, const char *pm;

　　限定*pm不可变，当然pm是可变的，因此问题中p1++是对的。

　　3)、替换1式char, const newType m;

　　限定m不可变，问题中的charptr就是一种新类型，因此问题中p2不可变，p2++是错误的。

char *p = "i'm hungry!"; p[0]= 'I';

　　答案与分析：

　　上面的代码可能会造成内存的非法写操作。分析如下， “i'm hungry”实质上是字符串常量，而常量往往被编译器放在只读的内存区，不可写。p初始指向这个只读的内存区，而p[0] = 'I'则企图去写这个地方，编译器当然不会答应。

总结：

　　1)、const在前面

const int nValue； //nValue是const const char *pContent; //*pContent是const, pContent可变 const (char *) pContent;//pContent是const,*pContent可变 char* const pContent; //pContent是const,*pContent可变 const char* const pContent; //pContent和*pContent都是const

　　2)、const在后面，与上面的声明对等

int const nValue； // nValue是const char const * pContent;// *pContent是const, pContent可变 (char *) const pContent;//pContent是const,*pContent可变 char* const pContent;// pContent是const,*pContent可变 char const* const pContent;// pContent和*pContent都是const

　　答案与分析：

　　const和指针一起使用是C语言中一个很常见的困惑之处，在实际开发中，特别是在看别人代码的时候，常常会因为这样而不好判断作者的意图，下面讲一下我的判断原则：

　　沿着*号划一条线，const和谁在一边，那么谁就是const，即const限定的元素就是它。你可以根据这个规则来看上面声明的实际意义，相信定会一目了然。

　　另外，需要注意：对于const (char *) ; 因为char *是一个整体，相当于一个类型(如 char)，因此，这是限定指针是const。

const用法主要是防止定义的对象再次被修改,定义对象变量时要初始化变量

下面我就介绍一下几种常见的用法

1.用于定义常量变量,这样这个变量在后面就不可以再被修改

const int Val = 10;

//Val = 20; //错误,不可被修改

2. 保护传参时参数不被修改,如果使用引用传递参数或按地址传递参数给一个函数,在这个函数里这个参数的值若被修改,

则函数外部传进来的变量的值也发生改变,若想保护传进来的变量不被修改,可以使用const保护

void fun1(const int &val)

{

//val = 10; //出错

}

void fun2(int &val)

{

val = 10; //没有出错

}

void main()

{

int a = 2;

int b = 2;

fun1(a); //因为出错,这个函数结束时a的值还是2

fun2(b);//因为没有出错,函数结束时b的值为10

}

如果只想把值传给函数,而且这个不能被修改,则可以使用const保护变量,有人会问为什么不按值传递,按值传递还需要把这个值复制一遍,

而引用不需要,使用引用是为了提高效率//如果按值传递的话,没必要加const,那样根本没意义

3. 节约内存空间,

#define PI 3.14 //使用#define宏

const double Pi = 3.14 //使用const,这时候Pi并没有放入内存中

double a = Pi; //这时候才为Pi分配内存,不过后面再有这样的定义也不会再分配内存

double b = PI; //编译时分配内存

double c = Pi; //不会再分配内存,

double d = PI; //编译时再分配内存

const定义的变量,系统只为它分配一次内存,而使用#define定义的常量宏,能分配好多次,这样const就很节约空间

4.类中使用const修饰函数防止修改非static类成员变量

class

{

public:

void fun() const //加const修饰

{

a = 10; //出错,不可修改非static变量

b = 10; //对,可以修改

}

private:

int a ;

static int b;

}

5.修饰指针

const int *A; 或 int const *A; //const修饰指向的对象，A可变，A指向的对象不可变

int *const A; 　 //const修饰指针A， A不可变，A指向的对象可变

const int *const A; //指针A和A指向的对象都不可变



6.修饰函数返回值,防止返回值被改变

const int fun();

接收返回值的变量也必须加const

const int a = fun(); //接收的变量也要是const的,int a = fun()是错误的

7.修饰类的成员变量

使用const修饰的变量必须初始化,在类中又不能在定义时初始化,

如;

class

{

private:

int a = 10;

const int b = 10;

static const int c = 10;

//这样初始化都是错的,

}

初始化const int类型(没有static),在类的构造函数上初始化

Class Test

{

Public:

Test():b(23) //构造函数上初始化b的值为23

{

}

private:

const int b ;

}

初始化staticconst int这个类型的(带有static的),在类的外面初始化

class Test

{

private:

static const int c;

}

const int Test::c=10; //类的外部初始化c为10

8.const定义的对象变量只能作用于这个程序该C/C++文件,不能被该程序的其他C/C++文件调用,

如file1.cpp中 const int val;

在file2.cpp中, extern intval; //错误,无法调用,

要想const定义的对象变量能被其他文件调用,定义时必须使用extern修饰为

extern const int val;

非const变量默认为extern,要是const能被其他文件访问必须显示指定为extern