const 是 constant 的缩写，本意是不变的，不易改变的意思。在 C++ 中是用来修饰内置类型变量，自定义对象，成员函数，返回值，函数参数。

一. const修饰普通类型的变量

const int  a = 7; 
int  b = a;   // 正确
a = 8;        // 错误，不能改变

a 被编译器认为是一个常量，其值不允许修改。

二. const 修饰指针变量

A: const 修饰指针指向的内容，则内容为不可变量。
B: const 修饰指针，则指针为不可变量。
C: const 修饰指针和指针指向的内容，则指针和指针指向的内容都为不可变量。

A: 指针指向的内容 8 不可改变。简称左定值，因为 const 位于 * 号的左边。
const int *p = 8; 

B: const 指针 p 其指向的内存地址不能够被改变，但其内容可以改变。
int a = 8;
int* const p = &a;
*p = 9; // 正确
int  b = 7;
p = &b; // 错误

C: 则是 A 和 B 的合并

三. const参数传递

对于 const 修饰函数参数可以分为三种情况
A：值传递的 const 修饰传递，一般这种情况不需要 const 修饰，因为函数会自动产生临时变量复制实参值。

#include<iostream>
 
using namespace std;
 
void Cpf(const int a)
{
    cout<<a;
    // ++a;  是错误的，a 不能被改变
}
 
int main(void)
 
{
    Cpf(8);
    system("pause");
    return 0;
}

B：当 const 参数为指针时，可以防止指针被意外篡改。

#include<iostream>
 
using namespace std;
 
void Cpf(int *const a)
{
    cout<<*a<<" ";
    *a = 9;
}
 
int main(void)
{
    int a = 8;
    Cpf(&a);
    cout<<a; // a 为 9
    system("pause");
    return 0;
}

此时输出结果是8 9，如果void Cpf(int *const a)改为void Cpf(const int * a)则会报错，因为此时a指向的内容应该是不变的

C：自定义类型的参数传递，需要临时对象复制参数，对于临时对象的构造，需要调用构造函数，比较浪费时间，因此我们采取const外加引用传递的方法。
并且对于一般的int ，double等内置类型，我们不采用引用的传递方式。
（注：这个没懂）

四. const函数返回值

例子

const int  a = 7;  #正确
a = 8; #错误

const int i, j = 0; #错误，i没有初始化

#在一个类里建立一个const时，不能给他初值
#类中的const成员变量必须通过初始化列表进行初始化

class foo
{
public:
      foo():i(100){}
private:
      const int i=100; #错误
};
#或者通过这样的方式来进行初始化
foo::foo():i(100)
{}

类里的static成员初始化：

静态数据成员是类的成员而不是对象的成员

class foo
{
public:
      foo();
private:
      static int i;
};

int foo::i=20;
这表明：
1、初始化在类体外进行，而前面不加static，以免与一般静态变量或对象相混淆
2、初始化时不加该成员的访问权限控制符private、public等
3、初始化时使用作用域运算符来表明它所属的类，因此，静态数据成员是类的成员而不是对象的成员。

完整的例子

https://www.cnblogs.com/gamesky/archive/2013/03/22/2975448.html

#ifdef A_H_
#define A_H_
#include <iostream>
using namespace std;
class A
{
public:
      A(int a);
      static void print();//静态成员函数
private:
      static int aa;//静态数据成员的声明
      static const int count;//常量静态数据成员（可以在构造函数中初始化）
      const int bb;//常量数据成员
};
int A::aa=0;//静态成员的定义+初始化
const int A::count=25;//静态常量成员定义+初始化
A::A(int a):bb(a)//常量成员的初始化
{
      aa+=1;
}
void A::print()
{
      cout<<"count="<<count<<endl;
      cout<<"aa="<<aa<<endl;
}
#endif
void main()
{
      A a(10);
      A::print();//通过类访问静态成员函数
      a.print();//通过对象访问静态成员函数
}

参考

https://www.runoob.com/w3cnote/cpp-const-keyword.html
https://www.cnblogs.com/Forever-Kenlen-Ja/p/3776991.html
https://www.cnblogs.com/jiabei521/p/3335676.html 看看这篇，里面很多例子

const作用