常数据成员

 ◆ 常数据成员必须进行初始化，并且不能被更新。

 ◆ 常数据成员不能在声明时赋初始值（普通数据成员也是），常数据成员必须在构造函数初始化列表进行初始化；普通数据成员在初始化列表和函数体中初始化均可。

 ◆ PS：类的成员对象若要传入参数初始化，则必须在构造函数初始化列表进行；（成员对象：当一个类的成员是另一个类的对象时，这个对象就叫成员对象。）

常对象

 ◆ ⭐常对象可以调用常成员函数，不能调用非const成员函数；非const对象，可以调用普通成员函数和常成员函数。

 ◆ 常对象的成员函数不一定都是常成员函数；同样的常对象的数据成员不一定都是常数据成员。

 ◆ 常对象一旦初始化，常对象的数据成员便不允许修改，而不是说常对象的数据成员都是常数据成员。

 ◆ PS：定义常对象有两种方法，1. Point const a; 2. const Point a;（同样的，定义变量或指针时，const放前放后意义一样，如：1. const double a; double const a; 2. const int *p; int const *p; 但是定义指针常量时，只能用 int * const p;）

常成员函数

 ◆ 常成员函数不更新对象的数据成员。

 ◆ 常成员函数的const关键字可以被用于参与对重载函数的区分。

 ◆ ⭐通常非const成员函数需要定义一个const版本的重载函数，以方便定义常对象后调用常成员函数。
  ◈ 如果常对象调用的常成员函数返回的是指向当前对象的指针（或返回的是当前对象），那么此常成员函数的声明的返回类型要加const，例如：

    ◊ 成员函数返回指向当前对象的指针
      const *Point fun1();    //非const成员函数的类内声明；
      const *Point fun1() const; //习惯上要再声明一个常成员函数作重载函数，注意到此函数声明有两个const；

    ◊ 成员函数返回指向当前对象
      const Point fun1();    //非const成员函数的类内声明；
      const Point fun1() const; //习惯上要再声明一个常成员函数作重载函数，注意到此函数声明有两个const；

    ◊ ⭐注意，如果一个类中声明以下4个重载函数：
      ① Point fun1();
      ② const Point fun1();
      ③ Point fun1() const;
      ④ const Point fun1() const;
     【解析】①和②是冲突的，因为无法区分仅按返回类型区分的重载函数；③和④是冲突的，也是因为无法区分仅按返回类型区分的重载函数。
     所以正确的重载函数搭配有3种：

      ◊ ①和③搭配：
        Point fun1();             //函数返回非const对象
        Point fun1() const;          //函数返回非const对象
       [解析]适用于定义常对象后调用常成员函数，常成员函数返回类型是非const的Point类对象。

      ◊ ①和④搭配（这里把返回类型改为指针，因为常用）：
        Point *fun1() {return this; };      //函数返回指向本对象的指针
        const Point *fun1() const { return this; };//函数返回指向本常对象的指针，第一个const说明返回的是指向常对象的指针，第二个const说明此函数是常函数

       [解析]适用于定义常对象后调用常成员函数，常成员函数返回类型是常Point类对象（如return *this;）。

      ◊ ②和④搭配：
        const Point fun1();          //函数返回常对象
        const Point fun1() const;       //函数返回常对象
       [解析]适用于定义常对象后调用常成员函数，常成员函数返回类型是常Point类对象。

      ◊ ②和③搭配：
        const Point fun1();
        Point fun1() const;
       [解析]虽然搭配合法，但是似乎不存在这种搭配。

刚开始学习C++的类和对象的部分，对类中的常数据成员和静态数据成员的概念和用法经常混淆，所以今天整理一下，顺便说一下，今天是我的生日，祝我生日快乐，呵呵。

常数据成员

常数据成员是指在类中定义的不能修改其值的一些数据成员，类似于我们以前学过的常变量，虽然是变量，也有自己的地址，但是一经赋初值，便不能再被修改。

适用于类中定义一些初始化之后不希望被修改的变量。

定义方法：

const 类型名 变量名;

（1）类中的常数据成员只能通过构造函数的参数初始化表进行初始化。

（2）常数据成员是实例化对象的一部分，可以用this指针访问。

#include<iostream>
using namespace std;
class Happy_birthday
{
	public:
 		Happy_birthday(char * na):name(na){}
		 void Print()
		 {
 			cout<<name<<" Happy Birthday!"<<endl;
 		}
	private:
		const char * name;
};
int main()
{
	Happy_birthday qianshou("赵哲");
	qianshou.Print();
	return 0;
}

运行结果：

静态数据成员

其实常数据成员和静态数据成员完全是两码事，只不过一开始学习的时候容易混淆罢了。通过上面的解释，我们知道常数据成员类似常变量，是一种一经赋值就不可以改变的变量。

它们最大的区别就是静态数据成员是可以被修改的，而且可以被任何一个对象修改，修改后的值，可以被所有的对象共享。

静态数据成员是属于一个类的而不是某一个对象，它是为该类所定义的所有的对象所共有。该类所定义的对象都可以引用该静态成员，并且值都是一样的。

静态数据成员的存储空间不同于普通的数据成员，它不属于类的任何一个对象，是独立于对象存储的，因此也不可以通过对象的this指针来访问。

并且，静态数据成员不可以用参数初始化表进行初始化操作，原因很简单，因为初始化表是在定义对象的时候进行的利用了this指针进行操作，所以不可以。

静态数据成员的定义的方式：

static int num;

访问方式：

可以通过类名直接访问：

Test::s_num;

one.s_num；

#include<iostream>
using namespace std;
class Test
{
	public:
		Test(int n):c_num(n){};//只能用初始化表对常数据成员赋初值 
		void show()
		{
			cout<<"c_num:"<<this->c_num<<endl;
			cout<<"s_num:"<<s_num<<endl;
		}
		void change(int n)
		{
			s_num=n;	
		} 
		static int s_num;
	private:
		const  int c_num;
};
int Test::s_num=100;//在类体为对静态数据成员赋初值 
int main()
{
	Test one(10);
	one.show();
	one.change(10000);//改变静态数据成员的值 
	cout<<"one changeed:"<<one.s_num<<endl;	//使用对象名one间接访问静态数据成员 
	cout<<"Test changeed:"<<Test::s_num<<endl;//使用类名直接访问静态数据成员
	Test two(20);
	cout<<"two changeed:"<<two.s_num<<endl; //使用对象名two间接访问静态数据成员 
	two.change(99); 
	cout<<"Test changeed:"<<Test::s_num<<endl;//使用类名直接访问静态数据成员 
	return 0;
}

分析：

我们在程序中可以使用类名直接访问静态数据成员变量，就直接说明了它不属于任何一个对象的这个特点。

我们在定义对象two的时候只对c_num进行了赋值，但是我们使用two.s_num进行输出的时候也是可以输出的，这也说明了这个数据成员确实可以被所有的对象进行引用，并且值都是相同的，因为它本身就不属于任何一个对象。

好啦，大家晚安！

（1）static数据成员在类的内部声明，但只能在类的外部定义，在类的外部不能指定static，在类的定义时候进行初始化;

（2）static数据成员只能在类的外部进行初始化（特例：当整型const static数据成员被常量表达式初始化时，就可以在类的内部进行初始化，但还需要在外部进行定义）。

（3） static数据成员可以是该成员所属的类类型，而非static数据成员只能自身类的引用或者指针。

（4）static数据成员可以用作类成员函数的默认实参。

（5）static数据成员的值可以改变。

二、静态成员和非静态成员的区别：

（1） 静态变量使用 static 修饰符进行声明，在类被实例化时创建，通过类和对象都可以进行访问；

（2）不带有 static 修饰符声明的变量称做非静态变量，在对象被实例化时创建，通过对象访问；

（3） 一个类的所有实例的同一静态变量都是同一个值，同一个类的不同实例的同一非静态变量可以是不同的值。

（4） 静态函数的实现里不能使用非静态成员，如非静态变量、非静态函数等。

三、静态成员函数的特点：

（1） static 成员函数没有 this 形参，它可以访问所属类的 static 成员，但不能访问非 static 成员。

（2）static成员函数既可以在类的内部定义，也可以在类的外部定义，在外部定义时，不能重复指定static保留字。

（3）static成员函数不能声明为虚函数，不能实现动态绑定

（4）static 成员函数不能声明为const，因为const是针对this是不是const而言的

（5）构造函数、析构函数不能为静态函数。

公有继承的私有成员不能被继承，无法访问

公有继承的保护成员，只能在派生类中访问，不能用派生类对象访问

私有继承的公有成员，成员被私有化，无法访问

(int&)b  是将b地址中对应的数据按照规定的int格式方式显示出来 

• pA2=static_cast<ClassA*>(pB);  类型转换无效
• 正确
• pA2=pB; 类型转换无效
• pA2=static_cast<ClassA*>(static_cast<ClassC*>(pB)); 转换有效

static_cast 的用法

static_cast < type-id > ( expression )

该运算符把expression转换为type-id类型，但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法：

①用于类层次结构中基类（父类）和派生类（子类）之间指针或引用的转换。

进行上行转换（把派生类的指针或引用转换成基类表示）是安全的；

进行下行转换（把基类指针或引用转换成派生类表示）时，由于没有动态类型检查，所以是不安全的。

②用于基本数据类型之间的转换，如把int转换成char，把int转换成enum。这种转换的安全性也要开发人员来保证。

③把空指针转换成目标类型的空指针。

④把任何类型的表达式转换成void类型。

注意：static_cast不能转换掉expression的const、volatile、或者__unaligned属性。

C++中的static_cast执行非多态的转换，用于代替C中通常的转换操作。因此，被做为显式类型转换使用。

C++中的reinterpret_cast主要是将数据从一种类型的转换为另一种类型。所谓“通常为操作数的位模式提供较低层的重新解释”也就是说将数据以二进制存在形式的重新解释。