被const关键字修饰的变量类型的值都不可改

 对于int，double，char等基础类型举例

  const int i = 3;//i在初始化后，其值不可改变
  i = 4;//错误

  const double d = 3.3;//d在初始化后，其值不可改变
  d = 4.4;//错误

  const char c = 'a';//a在初始化后，其值不可改变
  a = 'A';//错误

 对于指针举例：

1. const在*左边，修饰的是基础类型

2. const在*右边，修饰的是指针

  int i = 0;
  
  const int* cp = &i;   //const在*左边，所以修饰的是基础类型int，
                        //意思是指向的变量的值不可以改。
                        //仅是不能通过指针cp解引用更改，如果该变量没有const修饰，可以通过本身修改（如 i = 1;）

  int const * cp = &i;  //const在*左边，所以修饰的是基础类型int，

  int* const pc = &i;   //const在*右边，所以修饰的是指针
                        //意思是，指针pc不能再指向别的变量了。

对于引用而言，因为引用自身就包含了一层const的含义（不能改变指向），所以const修饰引用，只会让引用不能改变指向的值。

  int i = 0;
  
  const int& p = i; //不能通过p更改i的值
  int const& p = i; //不能通过p更改i的值

  int& p const = i; //错误，不合语法

 对于数组而言，只能修饰数组里面的元素或者元素指向的值。

  int a = 0, b = 1, c = 2;

  const int p[] = {a, b, c};      //指的是数组中元素的值不可改，如（p[1],p[2])
  int const p[] = {a, b, c};      //指的是数组中元素的值不可改
  

  const int* p[] = {&a, &b, &c};  //const修饰的是int
  int const* p[] = {&a, &b, &c};  //const修饰的是int
  int* const p[] = {&a, &b, &c};  //const修饰的是指针
 
  int p[] const = {a, b, c};      //错误，把const放在[]后面是错误的，不合语法

 const修饰结构体，意味着，结构体内部成员值不可改。

#include <iostream>

struct data {
  int i;
  int* p;
};

int main(void) {
  int s = 0, t = 1;
  const data d = {1, &s};

  d.i = 1;    //错误，i的值不可改
  d.p = &t;   //错误，指针p的指向不可改

  *(d.p) = 2; //正确

  return 0;

}

值得注意的是，如果结构体里面有指针，那么const修饰的是指针本身，也就是说指针的指向不能更改