C++中 const成员变量为何不能初始化啊？？

约束啊。。。

你好：通常我们在定义一个变量语句时候通常是，“数据类型+变量名+赋值号（=）+变量的数值”，如int a=10;那么这个变量a，在接下来的程序中可以改变它的数值的，也就是重新赋值。而const定义的变量，成为常量，是不允许改变的，const定义只需要放在数据类型之前即可，如const int a=10;

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

double x[10][10];const double *a[10]=x;这样如果需要赋值时使用x数组名，实际使用时用a来访问数组。

class a{ const int s=100;}

我看过C primer Plus最后面 C跟C++的区别里面讲到，C++中const默认的是内部链接 ，相当于: static const 。我觉得，这样应该可以解释了吧~

define宏定义和const常变量区别：1.define是宏定义，程序在预处理阶段将用define定义的内容进行了替换。因此程序运行时，常量表中并没有用define定义的常量，系统不为它分配内存。const定义的常量，在程序运行时在常量表中，系统为它分配内存。2.define定义的常量，预处理时只是直接进行了替换。所以编译时不能进行数据类型检验。const定义的常量，在编译时进行严格的类型检验，可以避免出错。3.define定义表达式时要注意“边缘效应”，例如如下定义：#define N 2+3 //我们预想的N值是5，我们这样使用N，int a = N/2; //我们预想的a的值是2，可实际上a的值是3。原因在于在预处理阶段，编译器将 a = N/2处理成了 a = 2+3/2；这就是宏定义的字符串替换的“边缘效应”因此要如下定义：#define N (2+3)。const定义的表达式则没有上述问题。const定义的常量叫做常变量原因有二：const定义常量像变量一样检查类型；const可以在任何地方定义常量，编译器对它的处理过程与变量相似，只是分配内存的地方不同。

const int *p表示所指向的值是常量，不能改变，地址可以改变int *const p=&i表示该指针的地址值是常量const int *const p=&i这就很明显了

第一步 设置const变量 export const ADDNUM = "addnum"; export const JIANNUM = "jiannum"; export const INPUTNUM="inputnum" 第二步 导入const变量 import { ADDNUM,JIANNUM,INPUTNUM } from "common/until/const"; 第三步 设置变量 ADDNUM { this.$store.commit(ADDNUM, iid);},

受教了，学习了！

既然用const定义了变量，就不要改变其值。若程序中需改变变量的值，就不要定义为const。保持好编程习惯

（1）const定义常量:const dataType constData=value;//const修饰的类型为dataType的变量value不可变.（2）指针中使用const，主要有三种方式a.指针本身是常量,它本身不可变char* const ptr;b.指针所指向的内容是常量，指向的内容不可变const char* ptr;c.两者都不可变const char* const ptr; （3）函数中使用consta.传指针参数前添加constvoid* A(const char* Str); //Str指向的内容被修饰为常量b.传引用参数前添加constvoid* A(const ClassType &obj); //obj在函数体内被修饰为常量（4）类中使用consta.使用const修饰成员变量使用const修饰类的成员函数，表示成员常量，它只能在初始化列表中赋值。如：class A{A(int x): val(x) { } ; //在初始化列表中定义const int val; //成员常量}b.使用const修饰类的成员函数，如 int getNum(int a)const;这样当程序修改了类的数据成员或调用了非const成员函数时，编译器就会报错。c.使用const修饰类的对象，或者类对象引用或指针这对象中的所有数据成员都不能被修改，对于对象指针或对象引用也一样。在这种情况下，同时不能通过对象名调用对象中的非const成员，这符合安全规则。

const类型定义：指明变量或对象的值是不能被更新,引入目的是为了取代预编译指令 1）修饰一般常量,常数组，常对象　　 修饰符const可以用在类型说明符前，也可以用在类型说明符后。 例如： int const x=2;　　或　　const int x=2;　　 int const a[5]={1, 2, 3, 4, 5}; 或 const int a[5]={1, 2, 3, 4, 5}; class A;　 const A a; 或 A const a;　 （2）修饰指针 const int *A; 或 int const *A; //const修饰指向的对象，A可变，A指向的对象不可变 int *const A; 　 //const修饰指针A， A不可变，A指向的对象可变 const int *const A; //指针A和A指向的对象都不可变 （3）修饰引用 　　 const double & v; 该引用所引用的对象不能被更新　（4）修饰函数的返回值： const修饰符也可以修饰函数的返回值，是返回值不可被改变，格式如下： const int Fun1(); const MyClass Fun2(); （5）修饰类的成员函数： const修饰符也可以修饰类的成员函数，格式如下： class ClassName { public: 　 　int Fun() const; }； 这样，在调用函数Fun时就不能修改类里面的数据 （6）在另一连接文件中引用const常量 extern const int i; //正确的引用 extern const int j=10; //错误！常量不可以被再次赋值

const关键字至少有下列n个作用：　　（1）欲阻止一个变量被改变，可以使用const关键字。在定义该const变量时，通常需要对它进行初始化，因为以后就没有机会再去改变它了；　　（2）对指针来说，可以指定指针本身为const，也可以指定指针所指的数据为const，或二者同时指定为const；　　（3）在一个函数声明中，const可以修饰形参，表明它是一个输入参数，在函数内部不能改变其值；　　（4）对于类的成员函数，若指定其为const类型，则表明其是一个常函数，不能修改类的成员变量；　　（5）对于类的成员函数，有时候必须指定其返回值为const类型，以使得其返回值不为“左值”。例如：const classA operator*(const classA& a1,const classA& a2);　　operator*的返回结果必须是一个const对象。如果不是，这样的变态代码也不会编译出错：classA a, b, c;(a * b) = c; // 对a*b的结果赋值　　操作(a * b) = c显然不符合编程者的初衷，也没有任何意义。

我原来学c的，最近在看c++，好像const只是声明存储类型，并不能这样声明变量；比方说const int x;如果你要定义静态类型就直接声明得了，或者在传参时用上&，func( int &par);也可以，试试吧

任何变量“初始化”都只有一次。const修饰的是只读变量，在程序全程中其值永远不变。static修饰的变量的值可以无数次改变，但无论在哪里改变，其改变后的值一直保留至下次改变之前。const修饰的变量在内存中存放在无const修饰的同类变量同一区域，static修饰的变量则在专门的另一区域。

const 是常量的意思，申明后就不能再变了。所以要申明时给个值

不能。const是一个C语言的关键字，具有着举足轻重的地位。它限定一个变量不允许被改变，产生静态作用。const不能对一个变量声明多次，只能声明一次。

关于C的关键字——const的理解和用法const在C中的用法很灵活（相信C++中也一样），个人感觉对之既爱又恨，有时候感觉const很好用，同时又经常会因为它的优点而犯错，犯错的原因除了粗心之外，另一个更重要的，就是以前对const理解不到位。于是今天自己写成一篇小总结。如果是初学者，建议好好看一下，相信帮助比较大；如果是高手，请不吝赐教！上面写了一段废话，就算是小序吧：）接下来就是正文；一、关于const的具体定义：——个人感觉很难对它下一个标准的定义，因为的用法很灵活，似乎对它定义后总无法让人能够明白它的意思，而且容易让人产生误解（也许是偶水平太菜了）。例如，把它有定义：一个能够让变量变成无法修改的常量的关键字。那么，这样的话，就可能让人误解为只要有const在定义变量里面，那变量就无论怎样都无法修改。这样的理解是很片面的（下面用法方面将对这问题做探讨）。因此，本人在此不敢对它下定义，其他参考书好象也没有下定义。二、关于const的具体作用——const作用就灵活了，一个表达式中const放置的位置不同，效果可能就不一样了。下面分具体情况分析（当然，所举的情况并非覆盖全部情况）A。const最经常的用法1.为了防止传递的函数参数不被修改，在调用函数的形参中用const关键字.//Example ->int FindNum(const int array[], int num, int conut);//声明函数//code...int FindNum(const int array[], int num, int count){int i;int flag = 1;for (i = 0; (i < count) && flag; i++){if (array[i] == num){flag = 0;break;}}return flag;}//code...上面这例子中，编译器会把array[]当作常量数据的数组看待。所以，假如你不小心给数组赋值，那么，编译器就会报错了。因此，当你不需要也不想修改数组的数据时，最好用const把数组定义为常量数组。2.const可以用来创建数组常量、指针常量、指向常量的指针等：const char ch = "a";const int a[5] = {1, 2, 3, 4, 5}; const int *p = a; //a是一个数组的首地址.p是指向常量的指针int * const p = a; //a是一个数组的首地址.p是指针常量；const int * const p = a; //a是一个数组的首地址。p是指向常量的指针常量前两种情况很简单，现在着重分析一下后三种用法，因为这3种情况容易出错，偶就有时候怕用错了刚脆不用const.——const int *p = a; //p是指向常量的指针，因此，不可以通过给指针赋值来改变数组//中的数据，例如：// *p = 10; /*错误*/// *(p + 2) = 1; /*错误*///假如指向常量指针可以改变值，那么，就等于也改变了数组的数 //据了。假如你不理解，偶倒有一个办法让你理解，你就想你和一 //个人绑在一起，有可能你移动了位置而他不跟着你移动吗！哈哈——int * const p = a; //看这表达式，const的位置和第一个不同吧！他们的用法和作用 //就完全不一样了。这时候p是指针常量，我们知道，指针是指向 //了一个数组的首地址，那么，它的位置就不可以改变了。但是你 //现在应该和第一个表达式比较了，现在的数组并不是常量数组， //所以数组的数据是可以改变的，而指针这时候它是不可以移动的 //，指向数组第一个数据，所以它可以而且只可以改变数组第一个 //数据的值。这一点请别误解，指针常量只是它的地址不可以改变 //，并不是它指向的内容一定不可以改变，这一点切记！//好啦。假如你又不理解，偶又有一个比较形象的例子来说明：//假如有一个固定的人拉着另外一个人的手，注意，固定的人相当 //于他是不可以由其他人来替换的。但是他可以拉其他人的手啊， //并不一定规定他必须拉同一个人的手啊。现在你应该可以有个比 //较深的印象和理解吧：P//下面举几个例子帮助理解：// *p = 2; /*可以*/// *(p+1) = 10; /*可以*/// p++; /*不可以*/——const int * const p = a; //假如前面两种表达式的本质你理解了，这种表达式你来理解根本//没有问题，const现在有两个，而且一个const的位置是第一种情 //况的位置,第二个const是第二种情况的位置，所以这表达式的功 //能就是前两种情况的作用总合。这里不多说！//下面举几个例子帮助理解：// *p = 2; /*不可以*/ // *(p + 2) = 10; /*不可以*/// p++; /*不可以*/B。const并不会阻止参数的修改之所以把这作为一点来谈，就是因为有一些朋友可能会以为在函数参数中用了const就一定不可以改变参数，这实际上是错误的理解，因为，它并不阻止参数的修改，下面举个简单的例子来阐述一下；#include<stdio.h>#include<ctype.h>void ChangeStr(const char *String);int main(void){char str[] = "The C programme";Change(str);printf(str);system("Pause");return 0;}void ChangeStr(const char *String){char *Source = (char *)String;while (*Source){*Source = toupper(*Source);Source++;}}//end上面的程序把字符串中的每个字符都转换成大写字母了。因为*String把地址给了*Source，而*Source的值的改变编译器并不干涉，可能有的编译器会发出警告之类。上面的程序只是为了说明const并不会阻止参数的修改，如果象上面程序那样，个人感觉没什么意义，只会让人容易混乱而已。关于CONST的用法和理解本人也就只能说这么多了，当然，很可能有更多高级或者少用的用法，由于水平和经验有限，确实不能再说些什么。 三、参考文献——《C primer plus 5th》

强制类型转换。A& b = ((A&)EXP);或者A* b = (A*)&EXP;然后就可以修改了

（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[5]={1, 2, 3, 4, 5}; const int a[5]={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[3]={10,20,50}; int array[size[2]]; 有什么问题吗？对了，编译通不过！为什么呢？ Const可以用于集合，但编译器不能把一个集合存放在它的符号表里，所以必须分配内存。在这种情况下，const意味着“不能改变的一块存储”。然而，其值在编译时不能被使用，因为编译器在编译时不需要知道存储的内容。自然，作为数组的大小就不行了：） 你再看看下面的例子： class A { public: A(int i=0):test[2]({1,2}) {}//你认为行吗？ private: const int test[2]; }； vc6下编译通不过，为什么呢？ 关于这个问题，前些时间，njboy问我是怎么回事？我反问他：“你认为呢？”他想了想，给出了一下解释，大家可以看看：我们知道编译器堆初始化列表的操作是在构造函数之内，显式调用可用代码之前，初始化的次序依据数据声明的次序。初始化时机应该没有什么问题，那么就只有是编译器对数组做了什么手脚！其实做什么手脚，我也不知道，我只好对他进行猜测：编译器搜索到test发现是一个非静态的数组，于是，为他分配内存空间，这里需要注意了，它应该是一下分配完，并非先分配test[0],然后利用初始化列表初始化，再分配test[1],这就导致数组的初始化实际上是赋值！然而，常量不允许赋值，所以无法通过。 呵呵，看了这一段冠冕堂皇的话，真让我笑死了！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

通常const修饰符用于明确表示此“变量”不能修改。而常量更普通的意义在于它不是变量。不同的系统约定也不一样，比如简单常量，有的系统可能就当“立即数”处理，存在于代码段；字符串、结构体常量，就和静态变量一样，存在于静态储存区（数据段）。另外，delphi里还存在一种“静态变量”，也是以const修饰，它实际上等同于c里的static修饰。左值是一个动态概念。常量可以作左值，左值很显然可以是变量，表达式。

const变量是指常量。即恒定的变量，即不可改变的变量。比如constinta=10;那么你在后面就不可以改变a的指。又比如constint*a；指的这个指针不会改变它所指向的内容intb；再比如int*consta=&b；指的这个指针只能指向b的地址，而不能是其它地址

vVAR Variable，变量。vCONST Constant，常量。vPERS Persistent，可变量。

常量定义详细内容： 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[5]={1, 2, 3, 4, 5}; const int a[5]={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[3]={10,20,50}; int array[size[2]]; 有什么问题吗？对了，编译通不过！为什么呢？ Const可以用于集合，但编译器不能把一个集合存放在它的符号表里，所以必须分配内存。在这种情况下，const意味着“不能改变的一块存储”。然而，其值在编译时不能被使用，因为编译器在编译时不需要知道存储的内容。自然，作为数组的大小就不行了：） 你再看看下面的例子： class A { public: A(int i=0):test[2]({1,2}) {}//你认为行吗？ private: const int test[2]; }； vc6下编译通不过，为什么呢？ 关于这个问题，前些时间，njboy问我是怎么回事？我反问他：“你认为呢？”他想了想，给出了一下解释，大家可以看看：我们知道编译器堆初始化列表的操作是在构造函数之内，显式调用可用代码之前，初始化的次序依据数据声明的次序。初始化时机应该没有什么问题，那么就只有是编译器对数组做了什么手脚！其实做什么手脚，我也不知道，我只好对他进行猜测：编译器搜索到test发现是一个非静态的数组，于是，为他分配内存空间，这里需要注意了，它应该是一下分配完，并非先分配test[0],然后利用初始化列表初始化，再分配test[1],这就导致数组的初始化实际上是赋值！然而，常量不允许赋值，所以无法通过。 呵呵，看了这一段冠冕堂皇的话，真让我笑死了！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程序中，只有C语言的常量表达式才能用来定义一个数组的初始大小。然而，在C++中，情况有所不同。一个常量表达式的值在程序运行期间是不变的，并且是编译程序能计算出来的一个值。在定义数组的大小时，你必须使用常量表达式，例如，你可以使用数字： char a[512];或者使用一个预定义的常量标识符： #define MAX 512 /*．．． */ char a[MAX];或者使用一个sizeof表达式： char a[sizeof(structcacheObject)];或者使用一个由常量表达式组成的表达式： char buf[sizeof(struct cacheObject) *MAX];或者使用枚举常量。在C中，一个初始化了的constint变量并不是一个常量表达式： int max=512; /* not a constant expression in C */ char buffer[max]; /* notvalid C */然而，在C++中，用const int变量定义数组的大小是完全合法的，并且是C++所推荐的。尽管这会增加C++编译程序的负担(即跟踪const int变量的值)，而C编译程序没有这种负担，但这也使C++程序摆脱了对C预处理程序的依赖。

static 是静态的修饰符,const是定义常量的修饰符．

终极办法 memcpy

es6的解构赋值，意思是取出config.body里面的username字段赋值给变量username

CONSTC中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[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++是错误的。 问题：const变量 & 字符串常量 请问下面的代码有什么问题？ char *p = "i"m hungry!"; p[0]= "I"; 答案与分析： 上面的代码可能会造成内存的非法写操作。分析如下， “i"m hungry”实质上是字符串常量，而常量往往被编译器放在只读的内存区，不可写。p初始指向这个只读的内存区，而p[0] = "I"则企图去写这个地方，编译器当然不会答应。 问题：const变量 & 字符串常量2 请问char a[3] = "abc" 合法吗？使用它有什么隐患？ 答案与分析： 在标准C中这是合法的，但是它的生存环境非常狭小；它定义一个大小为3的数组，初始化为“abc”，，注意，它没有通常的字符串终止符""，因此这个数组只是看起来像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。

const int 常整型变量 &a：常整型地址 const int* const pi=&a; //常整型常指针，a值不可变，pi不可指向其他地址。int 整型变量 &i ：整型地址 int* const pi = &i; //整型常指针，pi的不可指向其他地址，i可变。

被修饰的函数或者变量他的值不能改变

堆区。const变量在单片机中是会堆区的。因为单片微控制器不像数字芯片一样是完成一种特定的功能。单片机（Microcontrollers）又称微控制器，由中央处理器、存储器、输入输出端口(包括并行I/O、串行I/O、模数转换器)、计时器和计数器等组成。

用mutable修饰成员变量

事实上，这个函数只有一个形参——matrix，二维数组以及第一维的size n，都是matrix的类型而已，所以首先纠正一下，n不是参数，既不是实参也不是形参。另一个问题，测试了visual studio和gcc两套编译器，gcc standard低至c++03标准，仍然可以通过编译，看起来很早就支持了const作为数组维数的特性。不知道你的编译器是什么

&a的类型是const int *,强制转换成int*#include <iostream> using namespace std; int main() { int const a = 19; int *p = const_cast <int*> (&a); *p = 133; cout < < a < < endl;cout < < *p < < endl; cout < < &a < < endl; cout < < p < < endl; return 0;}相信你看了输出结果就会明白你的问题的 这个是你的编译器的问题，你换个编译器就可以了

C语言中const修饰的量是常变量，它与普通变量的编译方式一样，唯一的区别是常变量定义后不能做左值。C++中const修饰的才是常量。1、 const修饰的变量是常量还是变量对于这个问题，很多同学认为const修饰的变量是不能改变，结果就误认为该变量变成了常量。那么对于const修饰的变量该如何理解那？下面我们来看一个例子：int main{char buf[4];const int a = 0;a = 10;}这个比较容易理解，编译器直接报错，原因在于“a = 10；”这句话，对const修饰的变量，后面进行赋值操作。这好像说明了const修饰的变量是不能被修改的，那究竟是不是那，那么下面我们把这个例子修改下：int main{char buf[4];const int a = 0;buf[4] = 97;printf(“the a is %d ”,a);}其中最后一句printf的目的是看下变量a的值是否改变，根据const的理解，如果const修饰的是变量是不能被修改的话，那么a的值一定不会改变，肯定还是0。但是在实际运行的结果中，我们发现a的值已经变为97了。这说明const修饰的变量a，已经被我们程序修改了。那综合这两个例子，我们来分析下，对于第二例子，修改的原因是buf[4]的赋值操作，我们知道buf[4]这个变量已经造成了buf这个数组变量的越界访问。buf数组的成员本身只有0,1,2,3，那么buf[4]访问的是谁那，根据局部变量的地址分配，可以知道buf[4]的地址和int a的地址是一样，那么buf[4]实际上就是访问了const int a；那么对buf[4]的修改，自然也修改了const int a的空间，这也是为什么我们在最后打印a的值的时候看到了97这个结果。那么我们现在可以知道了，const修饰的变量是不具备不允许修改的特性的，那么对于第一个例子的现象我们又如何解释那。第一个例子，错误是在程序编译的时候给出的，注意这里，这个时候并没有生成可执行文件，说明const修饰的变量可否修改是由编译器来帮我们保护了。而第二个例子里，变量的修改是在可执行程序执行的时候修改的，说明a还是一个变量。综上所述，我们可以得出一个结论，那就是const修饰的变量，其实质是告诉程序员或编译器该变量为只读，如果程序员在程序中显示的修改一个只读变量，编译器会毫不留情的给出一个error。而对于由于像数组溢出，隐式修改等程序不规范书写造成的运行过程中的修改，编译器是无能为力的，也说明const修饰的变量仍然是具备变量属性的。2、 被const修饰的变量，会被操作系统保护，防止修改如果对于第一个问题，有了理解的话，那么这个问题，就非常容易知道答案了。Const修饰的变量是不会被操作系统保护的。其原因是操作系统只保护常量，而不会保护变量的读写。那么什么是常量？比如“hello world”这个字符串就是被称为字符串常量。对于这个问题的另一种证明方法，可以看下面这个程序：int main{const int a;char *buf = “hello world”;printf(“the &a is %p, the buf is %p ”,&a, buf);}可以发现buf保存的地址是在0x08048000这个地址附近的，而a的地址是在0xbf000000这个地址附近的，而0x08048000附近的地址在我们linux操作系统上是代码段。这也说明了常量和变量是存放在不同区域的，自然操作系统是会保护常量的。

不是的，在对象生存期内是不可以改变的，过了生存期就是普通变量了。在C++中，const成员变量也不能在类定义处初始化，只能通过构造函数初始化列表进行，并且必须有构造函数。const数据成员只在某个对象生存期内是常量，而对于整个类而言却是可变的。因为类可以创建多个对象，不同的对象其const数据成员的值可以不同。所以不能在类的声明中初始化const数据成员，因为类的对象没被创建时，编译器不知道const数据成员的值是什么。const数据成员的初始化只能在类的构造函数的初始化列表中进行。要想建立在整个类中都恒定的常量，应该用类中的枚举常量来实现，或者static cosnt。class Test{public:Test():a(0){}enum {size1=100,size2=200};private:const int a;//只能在构造函数初始化列表中初始化static int b;//在类的实现文件中定义并初始化const static int c;//与 static const int c;相同。};int Test::b=0;//static成员变量不能在构造函数初始化列表中初始化，因为它不属于某个对象。cosnt int Test::c=0;//注意：给静态成员变量赋值时，不需要加static修饰符。但要加cosnt

全局变量的定义为本函数和其他函数所共用。const定义是指使用类型修饰符const说明的类型。一、全局变量全局变量是编程术语中的一种，源自于变量之分。变量分为局部与全局，局部变量又可称之为内部变量。变量由某对象或某个函数所创建的变量通常都是局部变量，只能被内部引用，而无法被其它对象或函数引用。全局变量既可以是某对象函数创建，也可以是在本程序任何地方创建。全局变量是可以被本程序所有对象或函数引用。二、CONST（C中的CONST）const是一个C语言（ANSI C）的关键字，具有着举足轻重的地位。const它限定一个变量不允许被改变，产生静态作用。使用const在一定程度上可以提高程序的安全性和可靠性。清晰理解const所起的作用，对理解对方的程序也有一定帮助。CONST在其它编程语言中也有出现，例如Pascal、C++、PHP5、B#.net、HC08 C、C#等。

名词，有以下几种含义：常数，常量，结构，构造，康铜，铜镍合金，建筑，建筑物 。c语言中const 的含义及用法：const 表示常量，相当于宏定义，只能读取，不能修改。常变量：const 数据类型 符号常变量 = 数值，如：const float PI=3.14;指针常量：数据类型 *const 指针变量=变量名，如：char *const p="abc";const修饰的是指针变量，而不是指针的值，所以指针指向的值是可以修改的。常指针：const 数据类型 *指针变量=变量名或者是数据类型 const *指针变量=变量名，这是指针指向的值就是不可以改变的。还有一种情况就是指针变量本身不可以修改，指针指向的值也是不允许修改的，就是指针常量和常指针组合，这种称为常指针常量：const 数据类型 *const 指针变量=变量名或数据类型 const *const 指针变量=变量名

const在pascal 中是常量说明。

const定义的是常量，运行中不能改，再间接的方式也不能改，这不符合规定。想改的话就不要定义成const常量“我指的是如何用一种间接的方式使得用const定义的变量在程序运行中可以被修改”，不知道你用的是何种间接的方式，贴出来分离一下？？

const int aa的值是不可以改变的，常变量在常量区分配，必须初始化

（1）可以定义const常量（2）const可以修饰函数的参数、返回值.详细内容：1、什么是const?常类型是指使用类型修饰符const说明的类型，常类型的变量或对象的值是不能被更新的。（当然，我们可以偷梁换柱进行更新：）2、为什么引入const？const推出的初始目的，正是为了取代预编译指令，消除它的缺点，同时继承它的优点。3、cons有什么主要的作用？（1）可以定义const常量，具有不可变性。例如：constintMax=100;intArray[Max];

const 表示常量，相当于宏定义，只能读取，不能修改。常变量：const 数据类型 符号常变量 = 数值如：const float PI=3.14;指针常量：数据类型 *const 指针变量=变量名如：char *const p="abc";const修饰的是指针变量，而不是指针的值，所以指针指向的值是可以修改的。常指针：const 数据类型 *指针变量=变量名或者是数据类型 const *指针变量=变量名这是指针指向的值就是不可以改变的。还有一种情况就是指针变量本身不可以修改，指针指向的值也是不允许修改的，就是指针常量和常指针组合，这种称为常指针常量：const 数据类型 *const 指针变量=变量名或数据类型 const *const 指针变量=变量名

并不是所有的常量都可以用来定义一个数组的初始大小，在C程序中，只有C语言的常量表达式才能用来定义一个数组的初始大小。然而，在C++中，情况有所不同。一个常量表达式的值在程序运行期间是不变的，并且是编译程序能计算出来的一个值。在定义数组的大小时，你必须使用常量表达式，例如，你可以使用数字：char a[512];或者使用一个预定义的常量标识符：#define MAX 512/*．．． */char a[MAX];或者使用一个sizeof表达式：char a[sizeof(structcacheObject)];或者使用一个由常量表达式组成的表达式：char buf[sizeof(struct cacheObject) *MAX];或者使用枚举常量。在C中，一个初始化了的constint变量并不是一个常量表达式：int max=512; /* not a constant expression in C */然而，在C++中，用const int变量定义数组的大小是完全合法的，并且是C++所推荐的。

这么长的程序，你有疑问在哪一行代码也不指出，真想让人从头到尾的看你的程序啊？？？

const修饰的翻译期标识符具有常量语义，对于编译期（源代码）而言，必须在定义时同时被初始化，且一旦被定义即无法修改，否则产生编译错误。对于编译器而言，如果用于初始化const对象的值在编译期即能被确定，则可以把这个const对象优化掉，即通过类型检查后用这个值代替这个对象本身（这点效果和宏定义替换类似，但更安全），这被称为编译期const对象。编译期const对象在编译期完全确定，对于运行期而言相当于不存在。由于内嵌至数据段中，只是直接复制到内存，无所谓“初始化”（但是这点行为上和基本类型数据的初始化类似）。对于无法在编译期确定的运行期常量，一旦通过编译链接，在运行期的初始化行为，和对象本身被创建的时机相同——例如全局/静态对象在进程初始化时被初始化，作为函数参数的const对象（包括任何引用类型）在参数传递生成参数时同时初始化。====[原创回答团]

const int ic;错——const变量必须初始化，如const int ic=3;才正确。int *const cpi=&ic;错——指向int型目标的常指针不得用const变量的地址初始化。cpi=pic;错——指向常指针cpi不得重新赋值。cpic=&ic;错——同3.。ic=*cpic;错——const变量不得重新赋值。

const int * a=&b;const修饰*，表示常量指针，即指针指向的地址固定，但变量可变。const * int a=&b;直接语法错误，*不可以出现在类型int前面呀。int * const a=&b;表示指针常量，指针指向的地址中的内容不可变，但是指针本身指向的地址可变（即可以将该常量赋予不同的指针）。