【c++】静态成员变量和静态成员函数｜成员对象和封闭类

静态成员变量和静态成员函数

在说明前面加了static关键字的成员。
普通成员变量每个对象有各自的一份，而静态成员变量一共就一份，为所有对象共享。
sizeof运算符不会计算静态成员变量。
普通成员函数必须具体作用于某个对象，而静态成员函数并不具体作用于某个对象。
静态成员不需要通过对象就能访问。
如何访问静态成员：
1）类名::成员名
CRectangle::PrintTotal();
2）对象名.成员名
CRectangle r; r.PrintTotal();
3）指针->成员名
CRectangle *p = &r;
p->PrintTotal();
4）引用.成员名
CRectangle & ref = r;
int n = ref.nTotalNumber;
静态成员变量本质上是全局变量，哪怕一个对象都不存在，类的静态成员变量也存在。
静态成员函数本质上是全局函数。
设置静态成员这种极致的目的是将和某些紧密相关的全局变量和函数写到类里面，看上去像一个整体，易于维护和理解。

class CRectangle {
private:
	int w, h;
	static int nTotalArea;
	static int nTotalNumber;
public:
	CRectangle(int w_,int h_);
	~CRectangle();
	static void PrintTotal();
};

CRectangle::CRectangle(int w_,int h_) {
	w = w_;
	h = h_;
	nTotalNumber ++;	
	nTotalArea += w * h; 
}
CRectangle::~CRectangle() {
	nTotalNumber --;
	nTotalArea-= w * h;
}
void CRectangle::PrintTotal() {
	cout << nTotalNumber << "," << nTotalArea << endl; 
}
 
int CRectangle::nTotalNumber = 0;
int CRectangle::nTotalArea = 0;
// 必须在定义类的文件中对静态成员变量进行一次说明
//或初始化。否则编译能通过，链接不能通过。
int main()
{
	CRectangle r1(3,3), r2(2,2);
//cout << CRectangle::nTotalNumber; // Wrong , 私有
	CRectangle::PrintTotal();
	r1.PrintTotal();
	return 0;
}

在静态成员函数中，不能访问非静态成员变量，也不能调用非静态成员函数。

void CRectangle::PrintTotal()
{
cout << w << "," << nTotalNumber << "," << nTotalArea << endl; //wrong
}
CRetangle::PrintTotal(); //解释不通，w 到底是属于那个对象的？

但是上面这样写有缺陷，在使用CRectangle类的时候，有时会调用复制构造函数生成临时的隐藏的CRectangle对象
调用一个以CRectangle类对象作为参数的函数时
调用一个以CRectangle类对象作为返回值的函数时
这个时候因为没有调用构造函数，所以数目不会++，但是隐藏的CRectangle对象消亡时还是会调用析构函数，这样数目就会–
解决办法：写一个复制构造函数

成员对象和封闭类

成员对象：一个类的成员变量是另一个类的对象
包含成员对象的类叫封闭类（enclosing）

class CTyre { //轮胎类
 	private:
 		int radius; //半径
 		int width; //宽度
 	public:
 		CTyre(int r, int w):radius(r), width(w) { }
 	//新的初始化方式
};
class CEngine { //引擎类
};
class CCar { //汽车类
	private:
		int price; //价格
		CTyre tyre;
		CEngine engine;
	public:
		 CCar(int p, int tr, int tw);
};
CCar::CCar(int p, int tr, int w):price(p), tyre(tr, w){
};
int main(){
	CCar car(20000,17,225);
	return 0;
}

如果 CCar 类不定义构造函数, 则
CCar car; // error  编译出错
• 编译器不知道 car.tyre 该如何初始化
• car.engine 的初始化没有问题: 用默认构造函数

定义封闭类的构造函数时, 添加初始化列表:
类名::构造函数(参数表):成员变量1(参数表), 成员变量2(参数表), …
{
}
成员对象初始化列表中的参数
• 任意复杂的表达式
• 函数 / 变量/ 表达式中的函数, 变量有定义

当封闭类对象生成时,
• S1: 执行所有成员对象的构造函数
• S2: 执行封闭类的构造函数
成员对象的构造函数调用顺序
• 和成员对象在类中的说明顺序一致
• 与在成员初始化列表中出现的顺序无关
当封闭类的对象消亡时
• S1: 先执行 封闭类 的析构函数
• S2: 执行 成员对象 的析构函数
析构函数顺序和构造函数的调用顺序相反
先构造的后析构

class CTyre {
 	public:
 		CTyre() { cout << "CTyre contructor" << endl; }
 		~CTyre() { cout << "CTyre destructor" << endl; }
};
class CEngine {
 	public:
 		CEngine() { cout << "CEngine contructor" << endl; }
 		~CEngine() { cout << "CEngine destructor" << endl; }
};
class CCar {
	//按照列表顺序构造
	private:
		CEngine engine;
		CTyre tyre;
	public:
		CCar( ) { cout << “CCar contructor” << endl; }
		~CCar() { cout << "CCar destructor" << endl; }
};
int main(){
	CCar car;
	return 0;
}

输出：
CEngine contructor
CTyre contructor
CCar contructor
CCar destructor
CTyre destructor
CEngine destructor