作用：
1.修饰变量，说明变量内容不可以被改变；
2.修饰指针，分为指向常量的指针，指针常量；
3.常量引用，经常用于形参类型，即避免了拷贝，又避免了对值的修改；
4.修饰成员函数，说明该成员函数不能修改成员变量。
#include<iostream>
using namespace std;
class Student
{
public:
Student(int id = 1, int a = 2) :a(a)
{
id = id;
}
Student(int x) :a(x)
{
id = 0;
//a = 0;
}
void Test()//普通成员函数
{
id = 0;
printf("非 常成员函数\n");
}
void Test() const//常成员函数，不能修改类中的成员变量
{
//a = 1;
//id = 0;//报错
printf("不能修改成员变量\n");
}
protected:
private:
const int a;//只能在初始化列表赋值
int id;
};
void fun()
{
/*****************************
//对象
Student stu1;//普通对象，可以调用全部成员函数
const Student stu2;//常对象，调用const版本
const Student *p = &stu2;//常指针，调用const版本
const Student& q = stu1;//常引用，调用const版本
p->Test();
q.Test();
stu1.Test();//当const和非const都存在时，调用非const，只有其中一个时，就调用那一个
stu2.Test();//调用常成员函数
*******************************/
/*****************************
//指针
char name[]= "xian";
char name1[] = "aha";
char* p1 = name;//指针变量，指向字符数组变量
p1[1] = 'a';
cout << p1 << endl;
const char *p2 = name;//指针变量，指向字符数组常量
//p2 = 'a';报错，指针指向的内容不能改变，但指针本身可以再赋值
p2 = name1;
cout << p2 << endl;
char* const p3 = name;//常指针，指向字符数组变量
//p3 = name1;报错，不能改变指针
p3[0] = 's';
cout << p3<<endl;
const char* const p4 = name;
//p4 = name1;
//p4[0] = 's';都报错，指针和指针指向的内容都不能改变
cout << p4 << endl;
*******************************/
}
//函数参数
void fun1(const int val)//传递过来的参数在函数内不可变
{
//val = 1;报错
}
void fun2(const char* val)//参数指针所指内容为常量
{
char* name = "xian";
val = name;
//val[1] = 'c';报错，指针所指内容不可变
}
void fun3(char* const val)//参数指针为常指针
{
char* name = "xian";
//val = name;报错，指针不可变
val[1] = 's';
}
void fun4(const int& val)//引用参数在函数内为常量
{
int b = 0;
//val = b;报错，不可变
}
//函数返回值
const int fun5()//返回一个常数
{
}
const int* fun6()//返回一个指向常量的指针变量，const int* p=fun6();
{
}
int* const fun7()//返回一个指向变量的常指针，int* const p=fun7();
{
}
int main()
{
fun();
char* p = "hello";//指向常量区，常量区的值不可以改变
p = "123";
char a[] = "hello";//数组为常指针,char[]等价于char const*，数组名是一个常量，不可以给 数组名赋值，但是当数组用作函数参数时会退化为指针
//a = "23";报错
return 0;
}
