20-24（静态成员变量、函数、成员对象、封闭类、this指针、常量对象、常量成员函数、常量引用）

一、静态成员变量与静态成员函数

设置静态成员目的是将和某些类紧密相关的全局变量和函数写到类里面，看上去像一个整体。

//访问静态成员
//静态成员并不只属于某个对象，本质上全局变量
//1、类名：：成员名
rectangle::printtotal();
//2、对象名.成员名
rectangle r;
r.printtotal();
//3、指针->成员名
rectangle *p = &r;
p->printtotal();
//4、引用.成员名
rectangle &ref = r;
int n=ref.ntotalnumber

考虑一个需要随时知道矩形总数和总面积的图形处理程序

用全局变量记录总数和总面积

用静态成员将这两个变量封装进矩形类中，别的类就没法访问，容易理解和维护。

class rectangle
{
private:
	int w, h;
	static int totalarea;//静态成员变量
	static int totalnumber;
public:
	rectangle(int w_, int h_);
	~rectangle;
	static void printtotal();//静态成员函数
};

rectangle::rectangle(int w_, int h_)//构造函数
{
	w = w_;
	h = h_;
	totalnumber++;//静态成员变量
	totalarea += w*h;
}
rectangle::rectangle()//析构函数
{
	totalnumber--;
	totalarea -= w*h;
}

void rectangle::printtotal()
{
	cout << totalnumber << "," << totaoarea << endl;
}

int main()
{
	rectangle r1(3, 3), r2(2, 2);
	cout << rectangle::totalnumber//错误，私有
	rectangle::printtotal();//正确
	r1.printtotal();//正确
	return 0;
}

静态成员函数不能访问非静态成员函数和变量。
缺陷：不一定所有rectangle对象都用这个构造函数，但是会使用默认的复制构造函数，并使用析构函数减掉了总数。

解决办法：为rectangle 类写一个复制构造函数，不用默认的

 

rectangle::rectangle(rectangle &r)
{
	w = r.w, h = r.h;
	totalnumber++;
	totalarea += w*h;
}

二、成员对象和封闭类

成员对象：一个类的成员变量是另一个类的对象

封闭类：包含成员对象的类 

class tyre//轮胎类
{
private:
	int radius;
	int width;
public:
	tyre(int r, int w) :radius(r), width(w){}//列表初始化，把r初始化给radius,w初始化给width
};
class engine//引擎类
{};

class car//汽车类，封闭类
{
private:
	int price;
	tyre tyre;//tyre类的对象,成员对象
	engine engine;//engine类的对象
public:
	car(int p, int tr, int tw);//声明构造函数，名字相同
}
car::car(int p, int tr, int w) :price(p), tyre(tr, w){}//初始化列表，p初始化给price,tr和w 初始化给tyre

int main()
{
	car car(20000, 17, 225);
	return 0;
}

如果car类不定义构造函数，报错，编译器不知道car.tyre如何初始化
初始化列表

类名：构造函数（参数表）：成员变量1（参数表），成员变量2（参数表）

对象生成：

先执行成员对象的构造函数，再执行封闭类的构造函数

对象消亡：

先封闭类的析构函数，再成员对象的析构函数

三、this指针

作用：指向成员函数所作用的对象。

 

class complex
{
public:
	double real, imag;
	void printf(){ cout << real << "," << imag; }
	complex(double r, double i) :real(r), imag(i){}//初始化列表
	complex addone()
	{
		this->real++;
		this->printf();
		return *this;//返回指针
	}
};

int main()
{
	complex c1(1, 1), c2(0, 0);
	c2 = c1.addone();
	return 0;
}

静态成员函数中不能使用this指针，因为静态成员函数不具体作用到某个对象，this指针有作用的对象

 

四、常量对象、常量成员函数和常量引用

class demo
{

};
const demo obj;//obj是常量对象

class sample
{
public:
	int value;
	void getvalue() const;
};
void sample::getvalue() const
{
	value = 0;//wrong
	func（）；//常量成员函数不能调用其他非常量成员函数
}

常量对象上面可以执行常量成员函数

const sample A

A.getvalue() //正确