类的常成员与类的静态成员相似。类的常成员包括常数据成员和常成员函数。
       常数据成员
       在类的成员定义中，使用修饰符const说明的数据成员称为常数据成员。常数据成员必须初始化，并且它的数值不能被更新。常数据成员是通过构造函数的成员初始化列表进行初始化的。
       还是举例说明常数据成员：
<span style="font-size:18px;">#include <iostream.h>
class A 
{
public:
	A(int i);//定义的构造函数
	void Print();//函数体在类外的一般成员函数
	const int &r;//整型常数据成员的引用
private:
	const int a;//一般的常数据成员
	static const int b;//静态的常数据成员
};
const int A::b=15;//给静态的常数据成员赋值
A::A(int i):a(i),r(a)//通过构造函数的初始化列表进行初始化
{
}
void A::Print()//一般成员函数的函数体
{
	cout<<a<<","<<b<<","<<r<<endl;
}
void main()
{
	A a1(50),a2(30);//定义有参数的两个对象
	a1.Print();//通过对象来引用成员函数
	a2.Print();
}</span>
分析：(1)该程序中定义了三个常数据成员，分别为const  int  &r;    const   int   a;   static   const  int   b;
           (2)一般的常数据成员的初始化需要构造函数初始化列表进行初始化。
           (3)通过使用构造函数对两个对象进行初始化，把i赋值给a，再把a赋值给r。在这个过程中，一旦赋值就不再更新，b的数值也是被赋值后一直保持不变。因此结果为：50，15，50和30，15，30.


 

       常成员函数
       在类的成员函数中，使用const修饰符说明的成员函数称为常成员函数。在程序中，只有常成员函数才被常对象引用。常成员函数的定义格式为：<类型说明符>  <函数名>  ( <参数表>)  const 其中，在该函数的实现部分也要加const。
       举例来说明常成员函数：
<span style="font-size:18px;">#include <iostream.h>
class B 
{
public:
	B(int i,int j)//定义的带两个参数的构造函数
	{ b1=i;b2=j;}
	void Print();//函数体在类外的一般成员函数
	void Print() const;//函数体在类外的常成员函数
private:
	int b1,b2;
};
void B::Print()//一般成员函数的函数体
{
	cout<<b1<<";"<<b2<<endl;
}
void B::Print() const//常成员函数的函数体
{
    cout<<b1<<":"<<b2<<endl;
}
void main()
{
	B bb1(12,5);//定义的一般对象
	bb1.Print();//通过对象来引用成员函数
	const B bb2(10,9);//定义的类的常对象，只能引用常成员函数
	bb2.Print();
}</span>
分析(1)程序中出现了两个重载函数，void Print()和void Print() const。一个是一般的成员函数，后者是常成员函数。
       (2)通过调用构造函数进行对象的初始化，结果为12；5和10：9

 



 



 
       
     

知识点1.常对象中的任何类型的数据成员（无论私有还是公有）的值都不能被改变。

知识点2.常对象能调用的：

1.公有的常成员函数

2.构造函数

3.公有的静态函数

知识点3.常对象与常成员函数只有同时存在才都有意义

知识点4.普通对象既可以调用常成员函数，也可以调用非常成员函数

知识点5.常成员函数不能更改数据成员（包括常数据成员和非常数据成员）的值

知识点6.常成员函数的用处：因为常成员函数不能改变数据成员的值，所以能够防止数据被误改，可以保护数据的安全

知识点7.函数之间调用的话，常成员函数只能调用常成员函数

一、const
1、常对象只能调用常成员函数
2、普通对象可以调用全部的成员函数包括常成员函数
3、常方法不能调用普通方法 可以调用常方法、静态成员方法
4、普通方法可以调用常方法
解释：
当一个成员函数被调用时，自动向它传递一个隐含的参数，该参数是一个指向这个成员函数所在的对象的指针。 
在C++中，this指针被隐含地声明为: X *const this,这意味着不能给this 指针赋值；
在X类的const成员函数中，this指针的类型为：const X* const, 这说明this指针所指向的这种对象是不可修改
（即不能对这种对象的数据成员进行赋值操作）; 
由于this并不是一个常规变量，所以，不能取得this的地址

二、static 
1、静态成员函数只能访问静态成员变量
2、静态成员变量不属于对象，而是属于整个类
3、静态成员变量不能通过初始化列表进行初始化，必须类外初始化
int Test::ma = 12;
4、static修饰的成员函数没有this指针，不依赖对象,是c标准调用约定

三、构造函数和析构函数不能声明为const
因为：（1）对象的初始化必须经过构造函数进行初始化
 （2）析构函数要释放对象所占的资源

一丶静态成员

静态成员包括静态数据成员和静态函数

1.静态数据成员

类中的非静态数据成员，每一个类对象都拥有一个副本，即每一个对象的同名数据成员可以存储不同的数值，这是保证了每个对象拥有区别于其他对象的特征。 
而静态成员是不管创建了多少个对象，他们之间只有一个副本，也就是所有对象都共享这个静态数据成员。

静态成员的声明要是用static关键字

class Myclass
{
    private:
        int a,b,c;
        static int sum; //私有静态成员
}
Myclass p1,p2;
//则对象p1和p2都共享静态数据成员sum

静态数据成员初始化格式：



<数据类型><类名>::<静态数据成员名>=<初始值>
int Myclass::sum=32

初始化时注意： 

1）必须在文件作用域内对静态成员进行初始化（即应在类体外对静态数据成员进行初始化） 

2）静态数据成员进行初始化时不加static关键字 

3）静态数据成员是类的成员，因此在初始化时必须使用作用域运算符（：：）限定他所属的类

2.静态成员函数

私有的受保护的静态数据成员必须通过公有的接口进行访问，一般将这个接口定义为静态成员函数。 

静态成员函数也是属于整个类而不是属于某一个类的对象，用static关键字声明，可以在类体内定义，也可以在类体外定义，在类体外定义时，不需要加static关键字做前缀

访问对象成员时受限制： 

静态成员函数可以直接访问类中的静态成员，但是不能直接访问类中的非静态成员，若要访问非静态成员，必须通过参数传递的方式得到相应的对象，在进行访问

class Point
{
    public:
         static void Display(Point& p);//声明静态成员函数，参数为类对象
    private:
         int X,Y,Z;
         static int count;//声明静态数据成员
}
int Point::count=0;//对静态成员进行初始化
void Display(Point& p)//类体外定义成员函数
    {
    cout<<"该点为："<<p.X<<","<<p.Y<<","<<p.Z<<endl;//利用类对象调用类的非静态数据成员
    cout<<"我是类体外定义的静态成员函数"
    }   
int main()
{
Point p1;
Point::Display(p1);//访问静态成员
return 0;
}

静态函数可以直接访问静态成员，通过以下方式访问非静态成员：



<类名>::<静态成员函数名>（<参数表>）



二丶常成员

数据共享可能会破坏数据的安全性，因此对于即需要共享有需要放防止改变数据的应该定义为常量进行保护，以保证程序运行期间是不可改变的。使用const修饰符进行定义，常成员包括常对象，常成员函数和常数据成员。

1.常对象 

使用const关键字修饰的对象成为常对象，定义格式如下

<类名>const<对象名>
或者
const<类名><对象名>

常对象定义时不能被更新



class Point
{
public:
    Point(int a,int b):x(a),y(b){}//构造函数
private:
    int x,y;
}
const Point p1(1,2);//p1为常对象，不能被更新


2.常成员函数 

使用const关键字说明的成员函数成为常成员函数，格式如下：

<返回类型><函数名>(<参数表>)const

注意： 
常对象和一般对象可以调用常成员函数 
常对象不能调用一般成员函数 
一般对象可以调用一般函数

例子如下：



class Point//定义Point类
{
public:
    Point(int a,int b):x(a),y(b){};
    void Display()const;//定义常成员函数
    void Move();
private:
    int x,y;
}
void Display()const//常成员函数
{
    cout<<"Point:"<<x<<","<<y<<endl;
}
void Move()
{
    cout<<"Point:"<<x+1<<","<<y+1<<endl;
}
int main(){
    Point p1(1,2);//定义一个一般对象，并进行初始化
    const Point p2(5,6);//定义一个常对象
    p1.Move();//一般对象访问一般函数
    p1.Display();//一般对象访问常函数
    p2.Display();//常对象只能访问常函数
    return 0;
}

3.常数据成员 

const修饰的数据成员为常数据成员，常数据成员也必须进行初始化，并且不能被更新，但是常数据成员的初始化只能用过构造函数的成员初始化列表进行初始化

class Point
{
public:
    Point(int a,int b):x(a),y(b){};//构造函数
    void Print()const{cout<<x<<","<<y<<endl;}
private:
    const int x;
    int y;
}
Point::Point(int a,int b):x(a),y(b){}
int main()
{
    Point p1(3,4);//利用构造函数的成员初始化列表对const数据成员进行初始化
    p1.Print();//一般对象调用常函数
    return 0;
}