const用法（const有什么用）

本文目录

• const有什么用
• c语言中const 是什么意思，怎么用，什么时候用
• 总结C++中const的用法
• c++中const是怎么使用的
• C语言对const使用该如何理解

const有什么用

（1）可以定义 const 常量
（2）const 可以修饰函数的参数、返回值.

详细内容：
1、什么是const?
常类型是指使用类型修饰符const说明的类型，常类型的变量或对象的值是不能被更新的。（当然，我们可以偷梁换柱进行更新：）

2、为什么引入const？
const 推出的初始目的，正是为了取代预编译指令，消除它的缺点，同时继承它的优点。

3、cons有什么主要的作用？
（1）可以定义const常量，具有不可变性。 例如：
const int Max=100; int Array[Max];
（2）便于进行类型检查，使编译器对处理内容有更多了解，消除了一些隐患。例如： void f(const int i) { .........} 编译器就会知道i是一个常量，不允许修改； （3）可以避免意义模糊的数字出现，同样可以很方便地进行参数的调整和修改。 同宏定义一样，可以做到不变则已，一变都变！如（1）中，如果想修改Max的内容，只需要：const int Max=you want;即可！
（4）可以保护被修饰的东西，防止意外的修改，增强程序的健壮性。 还是上面的例子，如果在函数体内修改了i，编译器就会报错； 例如：
void f(const int i) { i=10;//error! }
（5） 为函数重载提供了一个参考。
class A { ......
void f(int i) {......} //一个函数
void f(int i) const {......} //上一个函数的重载 ......
};
（6） 可以节省空间，避免不必要的内存分配。 例如：
#define PI 3.14159 //常量宏
const doulbe Pi=3.14159; //此时并未将Pi放入ROM中 ......
double i=Pi; //此时为Pi分配内存，以后不再分配！
double I=PI; //编译期间进行宏替换，分配内存
double j=Pi; //没有内存分配
double J=PI; //再进行宏替换，又一次分配内存！
const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象#define一样给出的是立即数，所以，const定义的常量在程序运行过程中只有一份拷贝，而#define定义的常量在内存中有若干个拷贝。
（7） 提高了效率。 编译器通常不为普通const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。

4、如何使用const？
（1）修饰一般常量 一般常量是指简单类型的常量。这种常量在定义时，修饰符const可以用在类型说明符前，也可以用在类型说明符后。 例如：
int const x=2; 或 const int x=2;
（2）修饰常数组 定义或说明一个常数组可采用如下格式：
int const a={1, 2, 3, 4, 5};
const int a={1, 2, 3, 4, 5};
（3）修饰常对象 常对象是指对象常量，定义格式如下：
class A; const A a;
A const a; 定义常对象时，同样要进行初始化，并且该对象不能再被更新，修饰符const可以放在类名后面，也可以放在类名前面。
（4）修饰常指针
const int *A; //const修饰指向的对象，A可变，A指向的对象不可变
int const *A; //const修饰指向的对象，A可变，A指向的对象不可变
int *const A; //const修饰指针A， A不可变，A指向的对象可变
const int *const A;//指针A和A指向的对象都不可变
（5）修饰常引用 使用const修饰符也可以说明引用，被说明的引用为常引用，该引用所引用的对象不能被更新。其定义格式如下：
const double & v;
（6）修饰函数的常参数 const修饰符也可以修饰函数的传递参数，格式如下：
void Fun(const int Var); 告诉编译器Var在函数体中的无法改变，从而防止了使用者的一些无意的或错误的修改。
（7）修饰函数的返回值： const修饰符也可以修饰函数的返回值，是返回值不可被改变，格式如下：
const int Fun1(); const MyClass Fun2();
（8）修饰类的成员函数： const修饰符也可以修饰类的成员函数，格式如下：
class ClassName {
public:
int Fun() const; .....
}； 这样，在调用函数Fun时就不能修改类里面的数据
（9）在另一连接文件中引用const常量
extern const int i;//正确的引用
extern const int j=10;//错误！常量不可以被再次赋值 另外，还要注意，常量必须初始化！ 例如： const int i=5;

5、几点值得讨论的地方：
（1）const究竟意味着什么？
说了这么多，你认为const意味着什么？一种修饰符？接口抽象？一种新类型？ 也许都是，在Stroustup最初引入这个关键字时，只是为对象放入ROM做出了一种可能，对于const对象，C++既允许对其进行静态初始化，也允许对他进行动态初始化。理想的const对象应该在其构造函数完成之前都是可写的，在析够函数执行开始后也都是可写的，换句话说，const对象具有从构造函数完成到析够函数执行之前的不变性，如果违反了这条规则，结果都是未定义的！虽然我们把const放入ROM中，但这并不能够保证const的任何形式的堕落，我们后面会给出具体的办法。无论const对象被放入ROM中，还是通过存储保护机制加以保护，都只能保证，对于用户而言这个对象没有改变。换句话说，废料收集器（我们以后会详细讨论，这就一笔带过）或数据库系统对一个const的修改怎没有任何问题。
（2）位元const V.S. 抽象const?
对于关键字const的解释有好几种方式，最常见的就是位元const 和 抽象const。下面我们看一个例子： class A { public: ...... A f(const A& a); ...... }; 如果采用抽象const进行解释，那就是f函数不会去改变所引用对象的抽象值，如果采用位元const进行解释，那就成了f函数不会去改变所引用对象的任何位元。 我们可以看到位元解释正是c++对const问题的定义，const成员函数不被允许修改它所在对象的任何一个数据成员。 为什么这样呢？因为使用位元const有2个好处： 最大的好处是可以很容易地检测到违反位元const规定的事件：编译器只用去寻找有没有对数据成员的赋值就可以了。另外，如果我们采用了位元const，那么，对于一些比较简单的const对象，我们就可以把它安全的放入ROM中，对于一些程序而言，这无疑是一个很重要的优化方式。（关于优化处理，我们到时候专门进行讨论） 当然，位元const也有缺点，要不然，抽象const也就没有产生的必要了。 首先，位元const的抽象性比抽象const的级别更低！实际上，大家都知道，一个库接口的抽象性级别越低，使用这个库就越困难。 其次，使用位元const的库接口会暴露库的一些实现细节，而这往往会带来一些负面效应。所以，在库接口和程序实现细节上，我们都应该采用抽象const。 有时，我们可能希望对const做出一些其它的解释，那么，就要注意了，目前，大多数对const的解释都是类型不安全的，这里我们就不举例子了，你可以自己考虑一下，总之，我们尽量避免对const的重新解释。
（3）放在类内部的常量有什么限制？
看看下面这个例子：
class A {
private:
const int c3 = 7; // ???
static int c4 = 7; // ???
static const float c5 = 7; // ??? ......
};
你认为上面的3句对吗？呵呵，都不对！使用这种类内部的初始化语法的时候，常量必须是被一个常量表达式初始化的整型或枚举类型，而且必须是static和const形式。这显然是一个很严重的限制！ 那么，我们的标准委员会为什么做这样的规定呢？一般来说，类在一个头文件中被声明，而头文件被包含到许多互相调用的单元去。但是，为了避免复杂的编译器规则，C++要求每一个对象只有一个单独的定义。如果C++允许在类内部定义一个和对象一样占据内存的实体的话，这种规则就被破坏了。
（4）如何初始化类内部的常量？
一种方法就是static 和 const 并用，在内部初始化，如上面的例子； 另一个很常见的方法就是初始化列表：
class A {
public:
A(int i=0):test(i) {}
private:
const int i;
}； 还有一种方式就是在外部初始化，例如：
class A {
public:
A() {}
private:
static const int i;//注意必须是静态的！
}；
const int A::i=3;
（5）常量与数组的组合有什么特殊吗？ 我们给出下面的代码：
const int size={10,20,50};
int array[size];
有什么问题吗？对了，编译通不过！为什么呢？
Const可以用于集合，但编译器不能把一个集合存放在它的符号表里，所以必须分配内存。在这种情况下，const意味着“不能改变的一块存储”。然而，其值在编译时不能被使用，因为编译器在编译时不需要知道存储的内容。自然，作为数组的大小就不行了：） 你再看看下面的例子：
class A {
public:
A(int i=0):test({1,2}) {}//你认为行吗？
private:
const int test;
}；
vc6下编译通不过，为什么呢？ 关于这个问题，前些时间，njboy问我是怎么回事？我反问他：“你认为呢？”他想了想，给出了一下解释，大家可以看看：我们知道编译器堆初始化列表的操作是在构造函数之内，显式调用可用代码之前，初始化的次序依据数据声明的次序。初始化时机应该没有什么问题，那么就只有是编译器对数组做了什么手脚！其实做什么手脚，我也不知道，我只好对他进行猜测：编译器搜索到test发现是一个非静态的数组，于是，为他分配内存空间，这里需要注意了，它应该是一下分配完，并非先分配test,然后利用初始化列表初始化，再分配test,这就导致数组的初始化实际上是赋值！然而，常量不允许赋值，所以无法通过。 呵呵，看了这一段冠冕堂皇的话，真让我笑死了！njboy别怪我揭你短呀：）我对此的解释是这样的：C++标准有一个规定，不允许无序对象在类内部初始化，数组显然是一个无序的，所以这样的初始化是错误的！对于他，只能在类的外部进行初始化，如果想让它通过，只需要声明为静态的，然后初始化。 这里我们看到，常量与数组的组合没有什么特殊！一切都是数组惹的祸！
（6）this指针是不是const类型的？
this指针是一个很重要的概念，那该如何理解她呢？也许这个话题太大了，那我们缩小一些：this指针是个什么类型的？这要看具体情况：如果在非const成员函数中，this指针只是一个类类型的；如果在const成员函数中，this指针是一个const类类型的；如果在volatile成员函数中,this指针就是一个volatile类类型的。
（7）const到底是不是一个重载的参考对象？
先看一下下面的例子：
class A {
......
void f(int i) {......}//一个函数
void f(int i) const {......}//上一个函数的重载
......
}; 上面是重载是没有问题的了，那么下面的呢？
class A {
......
void f(int i) {......}//一个函数
void f(const int i) {......}//？？？？？
......
}; 这个是错误的，编译通不过。那么是不是说明内部参数的const不予重载呢？再看下面的例子：
class A {
......
void f(int& ) {......}//一个函数
void f(const int& ) {......}//？？？？？
......
}; 这个程序是正确的，看来上面的结论是错误的。为什么会这样呢？这要涉及到接口的透明度问题。按值传递时，对用户而言，这是透明的，用户不知道函数对形参做了什么手脚，在这种情况下进行重载是没有意义的，所以规定不能重载！当指针或引用被引入时，用户就会对函数的操作有了一定的了解，不再是透明的了，这时重载是有意义的，所以规定可以重载。
（8）什么情况下为const分配内存？
以下是我想到的可能情况，当然，有的编译器进行了优化，可能不分配内存。
A、作为非静态的类成员时；
B、用于集合时；
C、被取地址时；
D、在main函数体内部通过函数来获得值时；
E、const的 class或struct有用户定义的构造函数、析构函数或基类时；。
F、当const的长度比计算机字长还长时；
G、参数中的const；
H、使用了extern时。 不知道还有没有其他情况，欢迎高手指点：）
（9）临时变量到底是不是常量？
很多情况下，编译器必须建立临时对象。像其他任何对象一样，它们需要存储空间而且必须被构造和删除。区别是我们从来看不到编译器负责决定它们的去留以及它们存在的细节。对于C++标准草案而言：临时对象自动地成为常量。因为我们通常接触不到临时对象，不能使用与之相关的信息，所以告诉临时对象做一些改变有可能会出错。当然，这与编译器有关，例如：vc6、vc7都对此作了扩展，所以，用临时对象做左值，编译器并没有报错。
（10）与static搭配会不会有问题？ 假设有一个类：
class A {
public:
......
static void f() const { ......}
......
}; 我们发现编译器会报错，因为在这种情况下static不能够与const共存！ 为什么呢？因为static没有this指针，但是const修饰this指针，所以...
（11）如何修改常量？
有时候我们却不得不对类内的数据进行修改，但是我们的接口却被声明了const，那该怎么处理呢？我对这个问题的看法如下：
1）标准用法：
mutable class A {
public:
A(int i=0):test(i) { }
void SetValue(int i)const { test=i; }
private: mutable int test;//这里处理！
}；
2）强制转换：
const_cast class A {
public:
A(int i=0):test(i) { }
void SetValue(int i)const {
const_cast (test)=i;
}//这里处理！
private:
int test;
}；
3）灵活的指针：
int* class A {
public:
A(int i=0):test(i) { }
void SetValue(int i)const { *test=i; }
private:
int* test; //这里处理！
}；
4）未定义的处理
class A {
public:
A(int i=0):test(i) { }
void SetValue(int i)const {
int *p=(int*)&test *p=i;
}//这里处理！
private:
int test;
}； 注意，这里虽然说可以这样修改，但结果是未定义的，避免使用！
5）内部处理：this指针
class A {
public:
A(int i=0):test(i) { }
void SetValue(int i)const {
((A*)this)-》test=i;
}//这里处理！
private:
int test;
}；
6）最另类的处理：空间布局
class A {
public:
A(int i=0):test(i),c(’a’) { }
private:
char c;
const int test;
};
int main()
{
A a(3);
A* pa=&a
char* p=(char*)pa;
int* pi=(int*)(p+4）；//利用边缘调整
*pi=5;//此处改变了test的值！
return 0;
}
虽然我给出了6中方法，但是我只是想说明如何更改，但出了第一种用法之外，另外5种用法，我们并不提倡，不要因为我这么写了，你就这么用，否则，我真是要误人子弟了：）
（12）最后我们来讨论一下常量对象的动态创建。 既然编译器可以动态初始化常量，就自然可以动态创建，例如：
const int* pi=new const int(10); 这里要注意2点：
1）const对象必须被初始化！所以(10)是不能够少的。
2）new返回的指针必须是const类型的。 那么我们可不可以动态创建一个数组呢？ 答案是否定的，因为new内置类型的数组，不能被初始化。 这里我们忽视了数组是类类型的，同样对于类内部数组初始化我们也做出了这样的忽视，因为这涉及到数组的问题，我们以后再讨论。
来源：http://zhidao.baidu.com/question/91670015.html?si=3

c语言中const 是什么意思，怎么用，什么时候用

const 表示常量，相当于宏定义，只能读取，不能修改。

常变量：const 数据类型 符号常变量 = 数值
如：const float PI=3.14;

指针常量：
数据类型 *const 指针变量=变量名
如：char *const p=“abc“;
const修饰的是指针变量，而不是指针的值，所以指针指向的值是可以修改的。

常指针：
const 数据类型 *指针变量=变量名
或者是
数据类型 const *指针变量=变量名
这是指针指向的值就是不可以改变的。

还有一种情况就是指针变量本身不可以修改，指针指向的值也是不允许修改的，就是指针常量和常指针组合，这种称为
常指针常量：
const 数据类型 *const 指针变量=变量名
或
数据类型 const *const 指针变量=变量名

还有一个比较重要的就是常函数：这个我自己还是前一段时间刚刚理解，建议你看看这个网页：

总结C++中const的用法

const有两种用法：
class A
{
public:
void fun1()const;
void fun2(const int& arg);
private:
int m_arg;
static int m_static;
}
先看第一种用法，这个const关键词表示在该成员函数中不可以对该类的数据成员m_arg进行修改。这就是const成员函数的意义。
再看第二种用法，表示向该成员函数传递过来的int型引用不可以在成员函数中修改。这就是const参数的意义。

static的用法：
你首先要知道，一般的成员函数（也算就是不带有static修饰）经过C＋＋编译器预处理之后会给它加上一个this参数，再次以上一个类为例：
其中成员函数fun2，在编译器预处理之后会变成fun2(this,arg);这时候要访问成员数据都是通过这个this指针来访问的，如this-》m_arg。由于每一个类对象的this指针不同，所以他们可以访问自己的成员变量。
要是没有static修饰，这个成员函数在预处理之后就不会加上this参数。这样的成员函数由于没有this参数就没法访问m_arg数据成员。这可以访问被static修饰的m_static数据成员。注意，这里的static成员被该类的所有对象共享，而不属于任何一个具体的对象。
所以，总结一句static就是，类中静态数据成员一般使用静态成员函数来访问，这也是static的本意。当然也可以在一般的成员函数中访问，但是非静态数据成员必须使用非静态成员函数访问，不可以使用静态成员函数访问。

over！不知你有没有懂，一般对于出初学者来说要想理解，还是有点为难的。但是坚持一下，你就会发现你懂的人家不懂，那是你会很有成就感的。不懂就问，很好。

c++中const是怎么使用的

用来修饰变量或函数（包括成员函数）及其参数：
(1)const修饰基本数据类型
(2)const应用到函数中
(3)const在类中的用法
(4)const修饰类对象，定义常量对象
一、const修饰基本数据类型
1.const修饰一般常量及数组
const int a=10; 等价的书写方式： int const a=10;
const int arr={1,2,3}; int const arr={1,2,3};

对于类似这些基本数据类型，修饰符const可以用在类型说明符前，也可以用在类型说明符后，其结果是一样的。在使用这些常量的时候，只要不改变这些常量的值便好。
2.const修饰指针变量*及引用变量&
介绍本部分内容之前，先说说指针和引用的一些基本知识。
指针(pointer)是用来指向实际内存地址的变量，一般来说，指针是整型，而且一般的大家会接受十六进制的输出格式。
引用(reference)是其相应变量的别名，用于向函数提供直接访问参数（而不是参数的副本）的途径，与指针相比，引用是一种受限制的指针类型，或者说是指针的一个子集，而从其功能上来看，似乎可以说引用是指针功能的一种高层实现。
关于运算符&和*：
在C++里，沿袭C中的语法，有两个一元运算符用于指针操作：&和*。按照本来的定义，&应当是取址符，*是指针符，也就是说， &用于返回变量的实际地址，*用于返回地址所指向的变量，他们应当互为逆运算。实际的情况也是如此。
在定义变量的引用的时候，&只是个定义引用的标志，不代表取地址。
***************************const修饰指针（*）：*********************
const int* a = & //非常量数据的常量指针 指针常量
int const *a = & //非常量数据的常量指针 a is a pointer to the constant char variable

int* const a = & //常量数据的非常量指针指针常量 常量指针 a is a constant pointer to the (non-constant) char variable

const int* const a = & //常量数据的常量指针
可以参考《Effective c++》Item21上的做法，
如果const位于星号*的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；
如果const位于星号的右侧，const就是修饰指针本身，即指针本身是常量。
因此，和的情况相同，都是指针所指向的内容为常量，这种情况下不允许对内容进行更改操作，如不能*a = 3 ；
为指针本身是常量，而指针所指向的内容不是常量，这种情况下不能对指针本身进行更改操作，如a++是错误的；
为指针本身和指向的内容均为常量。
****************const修饰引用（&）：***************************
int const &a=x;
const int &a=x;
int &const a=x;//这种方式定义是C、C++编译器未定义，虽然不会报错，但是该句效果和int &a一样。
这两种定义方式是等价的，此时的引用a不能被更新。如：a++ 这是错误的。
二、const应用到函数中
1.作为参数的const修饰符
2.作为函数返回值的const修饰符
其实，不论是参数还是返回值，道理都是一样的，参数传入时候和函数返回的时候，初始化const变量
1 修饰参数的const，如 void fun0(const A* a ); void fun1(const A& a);
调用函数的时候，用相应的变量初始化const常量，则在函数体中，按照const所修饰的部分进行常量化，如形参为const A* a，
则不能对传递进来的指针的内容 进行改变，保护了原指针所指向的内容；如形参为const A& a，则不能对传递进来的引用对象进行改变，
保护了原对象的属性。
[注意]：参数const通常用于参数为指针或引用的情况;
2 修饰返回值的const，如const A fun2( ); const A* fun3( );
这样声明了返回值后，const按照“修饰原则“进行修饰，起到相应的保护作用。
const Rational operator*(const Rational& lhs, const Rational& rhs)
{
return Rational(lhs.numerator() * rhs.numerator(),
lhs.denominator() * rhs.denominator());
}
返回值用const修饰可以防止允许这样的操作发生:
Rational a,b;
Radional c;
(a*b) = c;
一般用const修饰返回值为对象本身（非引用和指针）的情况多用于二目操作符重载函数并产生新对象的时候。
类中的成员函数：A fun4()const; 其意义上是不能修改所在类的的任何变量。
三、类中定义常量（const的特殊用法）

在类中实现常量的定义大致有这么几种方式实现：
1.使用枚举类型
class test
{
enum { SIZE1 = 10, SIZE2 = 20}; // 枚举常量
int array1[SIZE1];
int array2[SIZE2];
};
2.使用const
不能在类声明中初始化const数据成员。以下用法是错误的，因为类的对象未被创建时，编译器不知道SIZE的值是什么。
class test
{
const int SIZE = 100; // 错误，企图在类声明中初始化const数据成员
int array[SIZE]; // 错误，未知的SIZE
};
正确的使用const实现方法为：const数据成员的初始化只能在类构造函数的初始化表中进行。
注意：对const成员变量的初始化，不能在变量声明的地方，必须在类的构造函数的初始化列表中完成，即使是在构造函数内部赋值也是不行的。
具体原因请参见 【初始化列表和赋值的区别】
3.使用static const
通过结合静态变量来实现：

#include《iostream.h》
class Year
{
private:
int y;
public:
static int const Inity;
public:
Year()
{
y=Inity;
}
};
int const Year::Inity=1997;//静态变量的赋值方法,注意必须放在类外定义
void main()
{
cout《《Year.Inity《《endl;//注意调用方式，这里是用类名调用的。
}

到这里就把在类中定义常量的方法都陈列出来了。
四、const定义常量对象，以及常量对象的用法
class test
{
public:
test():x(1)
{
y=2;
}
~test()
{}
void set(int yy)
{
y=yy;
}
int getx() const
{
return x;
}
//protected:
const int x;
int y;
};
void main()
{
const test t;
t.set(33);//error
t.getx();
}
常量对象只能调用常量函数，别的成员函数都不能调用。
五、使用const的一些建议
《1》要大胆的使用const，这将给你带来无尽的益处，但前提是你必须搞清楚原委；
《2》 要避免最一般的赋值操作错误，如将const变量赋值，具体可见思考题；
《3》 在参数中使用const应该使用引用或指针，而不是一般的对象实例，原因同上；
《4》 const在成员函数中的三种用法（参数、返回值、函数）要很好的使用；
《5》不要轻易的将函数的返回值类型定为const;
《6》除了重载操作符外一般不要将返回值类型定为对某个对象的const引用;

C语言对const使用该如何理解

CONST
C中CONST的使用：
const是一个C语言的关键字，它限定一个变量不允许被改变。使用const在一定程度上可以提高程序的健壮性，另外，在观看别人代码的时候，清晰理解const所起的作用，对理解对方的程序也有一些帮助。
虽然这听起来很简单，但实际上，const的使用也是c语言中一个比较微妙的地方，微妙在何处呢？请看下面几个问题。

问题：const变量 & 常量

为什么我象下面的例子一样用一个const变量来初始化数组，ANSI C的编译器会报告一个错误呢？

const int n = 5;
int a[n];

答案与分析:

1）、这个问题讨论的是“常量”与“只读变量”的区别。常量肯定是只读的，例如5， “abc”，等，肯定是只读的，因为程序中根本没有地方存放它的值，当然也就不能够去修改它。而“只读变量”则是在内存中开辟一个地方来存放它的值，只不过这个值由编译器限定不允许被修改。C语言关键字const就是用来限定一个变量不允许被改变的修饰符（Qualifier）。上述代码中变量n被修饰为只读变量，可惜再怎么修饰也不是常量。而ANSI C规定数组定义时维度必须是“常量”，“只读变量”也是不可以的。

2)、注意：在ANSI C中，这种写法是错误的，因为数组的大小应该是个常量，而const int n,n只是一个变量（常量 != 不可变的变量，但在标准C++中，这样定义的是一个常量，这种写法是对的），实际上，根据编译过程及内存分配来看，这种用法本来就应该是合理的，只是 ANSI C对数组的规定限制了它。

3)、那么，在ANSI C 语言中用什么来定义常量呢？答案是enum类型和#define宏，这两个都可以用来定义常量。

问题：const变量 & const 限定的内容

下面的代码编译器会报一个错误，请问，哪一个语句是错误的呢？

typedef char * pStr;
char string = “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++是错误的。

问题：const变量 & 字符串常量

请问下面的代码有什么问题？

char *p = “i’m hungry!“;
p= ’I’;

答案与分析：

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

问题：const变量 & 字符串常量2

请问char a = “abc“ 合法吗？使用它有什么隐患？

答案与分析：

在标准C中这是合法的，但是它的生存环境非常狭小；它定义一个大小为3的数组，初始化为“abc”，，注意，它没有通常的字符串终止符’\0’，因此这个数组只是看起来像C语言中的字符串，实质上却不是，因此所有对字符串进行处理的函数，比如strcpy、printf等，都不能够被使用在这个假字符串上。

问题5：const & 指针

类型声明中const用来修饰一个常量，有如下两种写法，那么，请问，下面分别用const限定不可变的内容是什么?

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就是修饰指针本身，即指针本身是常量。你可以根据这个规则来看上面声明的实际意义，相信定会一目了然。

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