const int  a = 7; //修饰变量，a不能该内容（更改为其他的值）
int* const p = &a;//修饰指针，a可变，但p只能指向a,不能指向其他变量名
const int *p = 8;//修饰指针指向的内容，不能改内容
const int * const  p = &a;//既修饰指针，又修饰指针指向的内容：p不能指向别的变量，a的值也不能改

void fun(const int a);//修饰传参，可要可不要const
void fun(int *const a)//修饰传参指针,
void fun(const int &a);//const+类型+引用传递（一般用于自定义类型），const 引用可以在保证参数不被修改的前提下，防止数据的值传递拷贝

const int fun(){ return 1;}//修饰函数返回值
const myType fun(){ return 1;}//修饰返回值，自定义类型，
const int &fun(){ return i;}//修饰返回值的引用，//返回值不能是局部变量
int *const fun(){ return &i;}//修饰返回值的指针,//返回值不能是局部变量


int get() const  { return 1;}//修饰类成员函数，不能修改对象的数据成员而且不能调用非const函数

　void func（const A& a, int b, const int* c, int* d）const;//显然，上述成员函数中，a为const引用传递，不可以改变原值；b为值传递；c为const指针传递，不可改变原值；d为输出参数，可以改变原值。而该函数为const成员函数，不可以修改成员变量值。

const int  a = 7; 

int  b = a; //it's right
 
a = 8;       // it's wrong,

    const int  a = 7;

    int  *p = (int*)&a;

    *p = 8;

const int *p = 8;

int a = 8; 
int* const p = &a;
*p = 9; //it’s right
int  b = 7;
p = &b; //it’s wrong

int a = 8;
const int * const  p = &a;

#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 is 9

    system("pause");
    return 0;
}

#include<iostream>
using namespace std;

class Test
{
public:
    Test(){}
    Test(int _m):_cm(_m){}

    int get_cm()
    {
       return _cm;
    }
private:
    int _cm;
}; 

void Cmf(const Test& _tt)//const+自定义类型+引用传递
{
    cout<<_tt.get_cm();
}

int main(void)
{
    Test t(8);
    Cmf(t);

    system("pause");
    return 0;
}

#include<iostream>
using namespace std;

const int Cmf()
{
    return 1;
}

int Cpf()
{
    return 0;
}

int main(void)
{

    int _m = Cmf();
    int _n = Cpf(); 

    cout<<_m<<" "<<_n;

    system("pause");
    return 0;
}

#include <iostream>  
using namespace std;  
  
class A {
private:
    int i;
public:
    A(){i=0;}
    int & get(){
        return i;
    }
};
 
void main(){
    A a;
    cout<<a.get()<<endl; //数据成员值为0
    a.get()=1; //尝试修改a对象的数据成员为1，而且是用函数调用表达式作为左值。
    cout<<a.get()<<endl; //数据成员真的被改为1了，返回指针的情况也可以修改成员i的值，所以为了安全起见最好在返回值加上const，使得函数调用表达式不能作为左值
}

// Disaster: Function returns a reference to a local object
const string &manip(const string& s)
{
string ret = s;
// transform ret in some way
return ret; // Wrong: Returning reference to a local object!//返回对局部对象的引用就会指向不确定的内存。
}

const string &shorterString(const string &s1, const string &s2)
{
return s1.size() < s2.size() ? s1 : s2;
}

#include <iostream>
using namespace std;
 
class A{
private:
    int i;
public:
    void set(int n){ //set函数需要设置i的值，所以不能声明为const
        i = n;
    }
 
    int get() const{ //get函数返回i的值，不需要对i进行修改，则可以用const修饰。防止在函数体内对i进行修改。
        return i;
    }
};