C/C++中CONST的意义

const 关键字来声明某个常量字段或常量局部变量。 常量字段和常量局部变量不是变量并且不能修改。 常量可以为数字、布尔值、字符串或 null 引用。 采用符号常量写出的代码更容易维护；指针常常是边读边移动，而不是边写边移动；许多函数参数是只读不写的。const最常见用途是作为数组的界和switch分情况标号(也可以用枚举符代替)

常变量： const 类型说明符 变量名

常引用： const 类型说明符 &引用名

常对象： 类名 const 对象名

常成员函数： 类名::fun(形参) const

常数组： 类型说明符 const 数组名[大小]

常指针： const 类型说明符* 指针名 ，类型说明符* const 指针名

首先提示的是：在常变量（**const 类型说明符 变量名）、**常引用（const 类型说明符 &引用名）、常对象（类名 const 对象名）、 常数组（类型说明符 const 数组名[大小]）， const” 与 “类型说明符”或“类名”（其实类名是一种自定义的类型说明符） 的位置可以互换。如：

const int a=5; 与 int const a=5; 等同

​ 类名 const 对象名 与 const 类名 对象名 等同

用法1：常量
取代了C中的宏定义，声明时必须进行初始化(!c++类中则不然）。const限制了常量的使用方式，并没有描述常量应该如何分配。如果编译器知道了某const的所有使用，它甚至可以不为该const分配空间。最简单的常见情况就是常量的值在编译时已知，而且不需要分配存储。―《C++ Program Language》
用const声明的变量虽然增加了分配空间，但是可以保证类型安全。
C标准中，const定义的常量是全局的，C++中视声明位置而定。

用法2：指针和常量
使用指针时涉及到两个对象：该指针本身和被它所指的对象。将一个指针的声明用const“预先固定”将使那个对象而不是使这个指针成为常量。要将指针本身而不是被指对象声明为常量，必须使用声明运算符*const。
所以出现在 * 之前的const是作为基础类型的一部分：

char *const cp; //到char的const指针
char const *pc1; //到const char的指针
const char pc2; //到const char的指针（后两个声明是等同的）
从右向左读的记忆方式：
cp is a const pointer to char. 故pc不能指向别的字符串，但可以修改其指向的字符串的内容
pc2 is a pointer to const char. 故pc2的内容不可以改变，但pc2可以指向别的字符串

且注意：允许把非 const 对象的地址赋给指向 const 对象的指针,不允许把一个 const 对象的地址赋给一个普通的、非 const 对象的指针。

用法3：const修饰函数传入参数
将函数传入参数声明为const，以指明使用这种参数仅仅是为了效率的原因，而不是想让调用函数能够修改对象的值。同理，将指针参数声明为const，函数将不修改由这个参数所指的对象。
通常修饰指针参数和引用参数：

void Fun( const A *in); //修饰指针型传入参数
void Fun(const A &in); //修饰引用型传入参数

用法4：修饰函数返回值
可以阻止用户修改返回值。返回值也要相应的付给一个常量或常指针。

用法5：const修饰成员函数(c++特性)
const对象只能访问const成员函数，而非const对象可以访问任意的成员函数，包括const成员函数；
const对象的成员是不能修改的，而通过指针维护的对象确实可以修改的；
const成员函数不可以修改对象的数据，不管对象是否具有const性质。编译时以是否修改成员数据为依据进行检查。

具体展开来讲：
(一). 常量与指针

常量与指针放在一起很容易让人迷糊。对于常量指针和指针常量也不是所有的学习C/C++的人都能说清除。例如：

  const int *m1 = new int(10);

  int* const m2 = new int(20);

在上面的两个表达式中，最容易让人迷惑的是const到底是修饰指针还是指针指向的内存区域？其实，只要知道：const只对它左边的东西起作用，唯一的例外就是const本身就是最左边的修饰符，那么它才会对右边的东西起作用。根据这个规则来判断，m1应该是常量指针（即，不能通过m1来修改它所指向的内容。）；而m2应该是指针常量（即，不能让m2指向其他的内存模块）。由此可见：

\1. 对于常量指针，不能通过该指针来改变所指的内容。即，下面的操作是错误的：

  int i = 10;

   const int *pi = &i;

   *pi = 100;

因为你在试图通过pi改变它所指向的内容。但是，并不是说该内存块中的内容不能被修改。我们仍然可以通过其他方式去修改其中的值。例如：

 // 1: 通过i直接修改。

   i = 100;

   // 2:　使用另外一个指针来修改。

   int *p = (int*)pi;

   *p = 100;

实际上，在将程序载入内存的时候，会有专门的一块内存区域来存放常量。但是，上面的i本身不是常量，是存放在栈或者堆中的。我们仍然可以修改它的值。而pi不能修改指向的值应该说是编译器的一个限制。
\2. 根据上面const的规则，const int *m1 = new int(10);我们也可写作：

 int const　*m1 = new int(10);

这是，理由就不须作过多说明了。
\3. 在函数参数中指针常量时表示不允许将该指针指向其他内容。

void func_02(int* const p) {
   
   int *pi = new int(100);
   //错误！P是指针常量。不能对它赋值。
   p = pi;
   }
  int main()  {
   
   int* p = new int(10);
   func_02(p);
   delete p;

   return 0;
   }

\4. 在函数参数中使用常量指针时表示在函数中不能改变指针所指向的内容。

 void func(const int *pi)  {
   
  //错误！不能通过pi去改变pi所指向的内容！
  *pi = 100;
  }
  int main()  {
   
  int* p = new int(10);
  func(p);　
  delete p;
  return 0;
  }

我们可以使用这样的方法来防止函数调用者改变参数的值。但是，这样的限制是有限的，作为参数调用者，我们也不要试图去改变参数中的值。因此，下面的操作是在语法上是正确的，但是可能破还参数的值：

  #include <iostream>
  #include <string>
  void func(const int *pi)  {
   
  //这里相当于重新构建了一个指针，指向相同的内存区域。当然就可以通过该指针修改内存中的值了。
  int* pp = (int*)pi;
  *pp = 100;
  }
 int main() {
   
  using namespace std;
  int* p = new int(10);
  cout << "*p = " << *p << endl;
  func(p);
  cout << "*p = " << *p << endl;

  delete p;
  return 0;
  }

(二)：常量与引用

常量与引用的关系稍微简单一点。因为引用就是另一个变量的别名，它本身就是一个常量。也就是说不能再让一个引用成为另外一个变量的别名, 那么他们只剩下代表的内存区域是否可变。即：

int i = 10;

// 正确：表示不能通过该引用去修改对应的内存的内容。

const int& ri = i;

// 错误！不能这样写。

int& const rci = i;

由此可见，如果我们不希望函数的调用者改变参数的值。最可靠的方法应该是使用引用。下面的操作会存在编译错误：

void func(const int& i)  {
   
  // 错误！不能通过i去改变它所代表的内存区域
  i = 100;
  }
int main()  {
   
  int i = 10;
  func(i);
  return 0;
  }

这里已经明白了常量与指针以及常量与引用的关系。但是，有必要深入的说明以下。在系统加载程序的时候，系统会将内存分为4个区域：堆区 栈区全局区（静态）和代码区。从这里可以看出，对于常量来说，系统没有划定专门的区域来保护其中的数据不能被更改。也就是说，使用常量的方式对数据进行保护是通过编译器作语法限制来实现的。我们仍然可以绕过编译器的限制去修改被定义为“常量”的内存区域。看下面的代码：

 const int i = 10;
  // 这里i已经被定义为常量，但是我们仍然可以通过另外的方式去修改它的值。
  // 这说明把i定义为常量，实际上是防止通过i去修改所代表的内存。
  int *pi = (int*) &i;

(三)：常量函数

常量函数是C++对常量的一个扩展，它很好的确保了C++中类的封装性。在C++中，为了防止类的数据成员被非法访问，将类的成员函数分成了两类，一类是常量成员函数（也被称为观察着）；另一类是非常量成员函数（也被成为变异者）。在一个函数的签名后面加上关键字const后该函数就成了常量函数。对于常量函数，最关键的不同是编译器不允许其修改类的数据成员。例如：

 class Test  {
   
 public:
	 void func() const;

private:
  int intValue;

  };
void Test::func() const  {
   
  intValue = 100;