常数据成员
引言：类存在的目的之一就是为了实现封装性，但是实际上经常使用公有函数接口去修改其数据成员，为了保证类中可以有一些数据成员绝对不会被修改，所以创造了常数据成员
特点：

1.在定义时要在头部加const关键字

2.初始化操作只能在构造函数的初始化列表中进行

3.无论是普通成员函数还是常成员函数都无法修改其值
常成员函数
引言：为了实现这样一种函数：对于其调用的数据成员只能读取，而不能修改。所以创造了常成员函数
特点：

1.在声明和定义时都要在尾部加const关键字

2.其只能读取数据成员，而不能修改




是否可以修改
一般成员函数
常成员函数




一般数据成员
是
否


常数据成员
否
否


3。常对象只能调用常成员函数
#include<iostream>
using namespace std;
class Point
{int x,y;
public:
Point(int a,int b):x(a),y(b){}
fun(){return x+y}
fun()const{return x-y}
}

void main
{const Point p1(1,1);
Point p2(1,1);
cout<<p1.fun<<endl;
cout<<p2.fun<<endl;

}


注：上面的例子一方面说明了常对象只能调用常成员函数

另一方面说明了const可以用于区分重载函数
4.常成员函数只能调用常成员函数，防止误改数据成员

在类中，如果你不希望某些数据被修改，可以使用const关键字加以限定。const 可以用来修饰成员变量和成员函数。

const成员变量

const 成员变量的用法和普通 const 变量的用法相似，只需要在声明时加上 const 关键字。初始化 const 成员变量只有一种方法，就是通过构造函数的初始化列表，这点在前面已经讲到了，请猛击《C++初始化列表》回顾。

const成员函数（常成员函数）

const 成员函数可以使用类中的所有成员变量，但是不能修改它们的值，这种措施主要还是为了保护数据而设置的。const 成员函数也称为常成员函数。
我们通常将 get 函数设置为常成员函数。读取成员变量的函数的名字通常以get开头，后跟成员变量的名字，所以通常将它们称为 get 函数。
常成员函数需要在声明和定义的时候在函数头部的结尾加上 const 关键字，请看下面的例子：
class Student{
public:
    Student(char *name, int age, float score);
    void show();
    //声明常成员函数
    char *getname() const;
    int getage() const;
    float getscore() const;
private:
    char *m_name;
    int m_age;
    float m_score;
};

Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ }
void Student::show(){
    cout<<m_name<<"的年龄是"<<m_age<<"，成绩是"<<m_score<<endl;
}
//定义常成员函数
char * Student::getname() const{
    return m_name;
}
int Student::getage() const{
    return m_age;
}
float Student::getscore() const{
    return m_score;
}

先明确几个概念：
1. 常对象只能调用常成员函数。
2. 普通对象可以调用全部成员函数。
3. 当对一个对象调用成员函数时，编译程序先将对象的地址赋给this指针，然后调用成员函数，每次成员函数存取数据成员时，由隐含使用this指针。
4. 当一个成员函数被调用时，自动向它传递一个隐含的参数，该参数是一个指向这个成员函数所在的对象的指针。 
5. 在C++中，this指针被隐含地声明为: X *const this,这意味着不能给this 指针赋值；
   在X类的const成员函数中，this指针的类型为：const X* const, 这说明this指针所指向的这种对象是不可修改的（即不能对这种对象的数据成员进行赋值操作）; 
6. 由于this并不是一个常规变量，所以，不能取得this的地址。
如：
  
#include <iostream>

class A
{
public:
	A():mValue(0)
	{

	}
	void print() 
	{
		std::cout<<"hello";
	}
	int GetValue()
	{
		return mValue;
	}
	int GetValue()const
	{
		return mValue;
	}

private:
	int mValue;
};

void test(A & const a)
{

}

int main()
{
	
	const A a;//const A* const this ;	
	a.print(); //错误，将会提示 error C2662: “A::print”: 不能将“this”指针从“const A”转换为“A &”

	test(a); //error C2664: “test”: 不能将参数 1 从“const A”转换为“A &”
}


由于a是const对象，所以a只能调用类A中的常成员函数。

那么为什么会提示：“不能将this指针.......”的语句呢？
因为对于c++的成员函数（当然不是静态成员函数),都会含有一个隐藏的参数，对于上例A中的int GetValue()函数，在编译后会变成：
int GetValue(A * const this);  //不能修改this变量，但可以修改this指向的内容，即：this是常量指针。
而对于int GetValue()const ，编译后是：
int GetValue(const A* const this); 
只所以this指针是const类型，因为在某次调用整个过程this指向都不允许改变（原因很简单，如果改变的话就不是这个对象调用的了）
从编译后的结果看就很清楚了， 因为a是const，所以其this指针就对应： const A* const this ;
而print函数被编译出来后对应的是void print(A* const this); 在进行参数匹配时， 所以就会提示 “不能将“this”指针从“const A ....."

this指针的出现就解释了，所有类A的对象都是公用一套代码模版，为什么各个对象在调用成员函数的时候不会乱套。

原来C++为成员函数提供了一个名字为this的指针，这个指针称为自引用指针。每当创建一个对象时，系统就把this指针初始化为指向该对象。每当调用一个成员函数时，系统就自动把this指针作为一个隐含的参数传给该函数。不同的对象调用同一个成员函数时，C++编译器将根据成员函数this指针所指向的对象来确定应该引用哪一个对象的数据成员。通常情况下，this指针是隐含存在的，也可以将其显示的表示出来（即如上例中的 this->mValue。不过this指针只能在类中使用）


还有就是  this指针是一个const指针，不能再程序中修改它或给它赋值；

常对象
常对象是指该对象在其生命周期内，其所有的数据成员的值都不能被改变；定义对象时加上关键字const，该对象就是常对象，其一般形式如下：
类名 const 对象名[(实参类别)]；

或者
const 类名 对象名[(实参类别)]；

形如：const CComplex num;
需要特别说明的是：

常对象只能调用常成员函数，不能调用普通成员函数 (除了隐式调用析构函数和构造函数)，常成员函数是常对象的唯一对外接口；
现在编译系统只检查函数的声明，只要发现调用了常对象的成员函数，而且该函数未被声明为const，编译阶段就报错；
常对象在被定义时需要被初始化；

常数据成员
如果我们希望在创建对象后，该对象的某个数据成员就保持不变，我们可以将这个数据成员设置为常数据成员；常数据成员只能通过构造函数初始化列表进行初始化，其他形式的函数均不能进行数据的赋值；
常成员函数
若将成员函数设置为常成员函数，则只能引用本类中的数据成员，而不能修改它；常成员函数可以引用const数据成员，也可以引用非const的数据成员；常成员函数的一般形式为：
类型名 函数名(形参列表) const {函数体}

这里的const关键字是函数类型的一部分，在函数声明和函数定义时都要带const关键字，否则被编译器认为是不同的两个函数，但是在函数调用的时候不必带const；