修饰变量

  1. const int a = 2048;// a不能改变值

修饰指针* 或者引用&

  1. /* const 在 * 前面 ，则认为其修饰的是 *p 这个整体*/
  2. const int * p = &a;//不允许修改*p ，但是可以修改p指向的对象，a本身也可以修改
  3. int const * p = &a;//同上
  4. /* const 在 * 后面 ，则认为其修饰的是 p 这个指针*/
  5. int * const p = &a;//允许修改*p , 但是不能修改p指向的对象，a本身可以修改
  1. /*对于引用 & 对const的位置不敏感（引用本身定义好后，不用 const 也不能变化）*/
  2. const int & z = a;//因为引用本质是同一个东西，所以都是不能变化
  3. int const & z = a;//同上

用在函数中

  1. /*在参数中使用const*/
  2. int main(const int * a,const Stock & b){
  3.     return 0;
  4. }
  5. //如果没有参数可以选择在()后面加const
  6. int fun() cosnt {
  7. }
  8. //若函数不修改原来的变量的值，最好使用const修饰确保函数中不会对原来的引用或者指针造成修改
  9. //此时若有一个数组
  10. const int a [3] ={1,4,5};
  11. //函数声明
  12. void ( int * nums){}
  13. //或者
  14. void ( int nums[]){}
  15. //都不可以输入a数组，因为a数组输入时是作为const指针，实际行为是想将const指针赋值给非const变量，这样就会引起权限错误，因为逻辑上造成了：可以用非const的指针去修改一个const变量。
  1. //一般是为了防止运算符重载等二元运算赋值时出现 v1+v2 =v3; 的无效语句
  2. class Stock{
  3.     int val;
  4.     public:
  5.         /*在声明中修饰返回值*/
  6.         const Stock operator+(Stock & b){
  7.             Stock z;
  8.             z.val =this.val + b.val
  9.             return z;}//注意此时不能在函数返回处声明为 & 引用，因为此时返回的是临时变量，如果不直接返回副本，则会导致运行完后临时变量消失，返回的引用也消失。
  10. }

在类中使用const

dad类只能通过构造函数初始化，在类的定义中只能声明类型，产生了const 和 & 的问题。
注意：只有构造函数可以使用这种 成员初始化列表的语法（解决const 和 & 这种需要定义声明同步进行的类型）

  1. //因为类在声明的时候不进行初始化，创造实例是才会初始化，此时如果在变量中有一个const类型，同时声明+初始化是可以的，但是想先声明再初始化，需要借助构造函数的成员初始化表结构，想用传统的构造函数中赋值初始化是不允许的，这违反了 const 值不可以修改的原则。
  2. //成员初始化列表是保证了顺序  运行初始化列表赋值 -> 运行构造函数
  3. class Stock{
  4.        private:
  5.         const int b;//只声明，需要创建实例时的参数来初始化
  6.         short & c;//引用同上规则
  7.         long d;//普通变量
  8.        public:
  9.         Stock(int in_b, short in_c,long in_d):b(in_b),c(in_c),d(in_d){
  10.             }
  11. }