类和对象————继承

类与类之间，下级别的成员除了拥有上一级的共性，还有属于自己的特性。

.1继承的基本语法`

class 子类 : 继承方式  父类

子类–派生类
父类–基类

class BasePage {
public:
	void title() {
		cout << "搜索栏:" << endl;
	}
};

class cpp :public BasePage {			//继承basepage类的特性
public:
	void content() {
		cout << "cpp" << endl;
	}
};

void test() {
	cpp p;
	p.title();							//可直接调用
	p.content();
}

使用继承语法，可以省略公共特性，减少重复代码

.2继承方式

• 公共继承：父类的不同权限成员到子类中不变

class Father {
public:
	int a;
protected:
	int b;
private:
	int c;
};

class Son :public Father {
public:
	void func() {
		a = 1;
		b = 2;				//保护权限类内可以访问	
		//c = 3;			私有权限子类无法访问
	}
};

void test() {
	Son  p;
	p.a = 10;
	//p.b = 2;				保护权限类外无法访问
}

• 保护继承：父类内的public，protected权限均在子类中变为保护权限
• 私有继承：父类的成员均在子类中变为私有权限，即其他子类再次继承时无法访问

.3继承中的对像模型

父类中所有非静态成员属性都会被子类继承下去，私有属性是被编译器隐藏了

class Father {
public:
	int a;
protected:
	int b;
private:
	int c;
};

class Son :private Father {
public:
	
	int d;

};

void test() {
	Son p;
	cout << sizeof(p) << endl;			//16Byte
}

类对象观察方法

1. 打开 Developer PowerShell
2. cd 加cpp文件路径跳转
3. dir 查看目录
4. cl /d1 reportSingleClassLayout类名 文件名（按tab)
   

.4继承中构造和析构顺序

先构造父类，再构造子类，先析构子类，再析构父类

class Father {
public:
	Father() {
		cout << "父类的构造函数调用" << endl;
	}
	Father(int a) {
		cout << "父类的有参构造函数调用" << endl;
	}
	~Father() {
		cout << "父类的析构函数调用" << endl;
	}
};

class Son :private Father {
public:
	Son() {
		cout << "子类的构造函数调用" << endl;
	}
	Son(int a) {
		cout << "子类的有参构造函数调用" << endl;
	}
	~Son() {
		cout << "子类的析构函数调用" << endl;
	}
};

void test() {
	Son p;
	//Son p2(10);
}

.5继承中同名成员处理方式

子类对象可以直接访问到子类中的同名成员，通过加作用域可以访问父类的同名成员
子类会隐藏父类中的同名成员函数。

class Father {
public:
	int a;
	void pri() {
		cout << "father pri" << endl;
	}
	void pri(int a) {
		cout << "father pri(int a)" << endl;
	}
};

class Son :public Father {
public:
	int a;
	void pri() {
		cout << "son pri" << endl;
	}
};

void test() {
	Son p;
	p.pri();
	p.Father::pri();
}

.6继承中同名静态成员处理方式

与非静态相同
唯一区别是可按类名直接访问

Son::a;
Son::Father::a;

.7多继承语法

允许一个类继承多个类 class 子类：继承方式 父类1，继承方式 父类2 ...
父类中有同名成员时，需要加作用域。实际开发中尽量减少多继承语法使用

.8菱形继承

使用同一份数据时会产生二义性，继承两份相同数据造成资源浪费。
通过在继承前加virtual关键字，变为虚继承，公共的父类变为虚基类

class Animal {
public:
	int m_age;
};
class Horse :virtual public Animal{};

class Donkey :virtual public Animal {};

class Luozi :public Horse, public Donkey {};