C++(六)——继承

继承中的对象模型

#include<iostream>
using namespace std;
//继承中的对象模型
class Base {
public:
	int m_a;
protected:
	int m_b;
private:
	int m_c;


};
class Son :public Base {
public:
	int m_d;
};
void test01() {
	
	//结果16
	//父类中所有非静态成员属性都会被子类继承下去
	//私有属性虽然无法访问，但仍然继承了
	cout << "size of Son = " << sizeof(Son) << endl;
}



int main() {
	test01();
	return 0;
}

构造和析构顺序

#include<iostream>
using namespace std;
//继承中的构造与析构函数
class Base {
public:
	Base() {
		cout << "这是Base构造函数" << endl;
	}

	~Base() {
		cout << "这是Base析构函数" << endl;
	}
};

class Son :public Base {
public:
	Son() {
		cout << "这是Son构造函数" << endl;
	}

	~Son() {
		cout << "这是Son析构函数" << endl;
	}

};
void test01() {
	//Base b;
	//继承中的构造顺序，先构造父类，再构造子类。析构时顺序相反
	Son s;

}

int main() {
	test01();

	return 0;
}

同名成员处理

#include<iostream>
using namespace std;
class Base {
public:
	Base() {
		m_a = 100;
	}
	void func() {

		cout << "this is Base func" << endl;
	}
	void func(int a) {

		cout << "this is Base func（int）" << endl;
	};
	int m_a;
};

class Son :public Base {
public:
	int m_a;
	Son() {
		m_a = 200;
	}
	void func() {
		cout << "this is Son func" << endl;
	}
};

void test01() {
	Son s;
	cout << "Son的m_a = " << s.m_a << endl;
	//如果通过子类对象访问父类中的同名成员需要加一个作用域
	cout << "Base的m_a = " << s.Base::m_a << endl;
}

void test02() {
	Son s;
	//若要访问父类的同名成员函数也能加作用域
	s.Base::func(100);
	//如果子类中存在同名成员函数，则父类同名全被隐藏，只能通过作用域访问
}


int main() {
	test01();
	test02();
	return 0;
}

同名静态成员处理

#include <iostream>
using namespace std;
//继承中的同名静态成员处理方式
class Base {
public:
	static int m_a;
	static void func() {
		cout << "base ——func" << endl;
	}
	static void func(int a) {
		cout << "base ——func(int)" << endl;
	}

};
//类内声明，类外初始化
int Base::m_a = 100;

class Son :public Base {
public:
	static int m_a;
	static void func() {
		cout << "son ——func" << endl;
	}
};
int Son::m_a = 1000;
//同名静态成员属性
void test01() {
	//通过对象访问数据
	Son s;
	cout << "Son 下m_a = " << s.m_a << endl;
	cout << "Base 下m_a = " << s.Base::m_a << endl;
	//同过类名访问
	cout << "通过类名访问：" << endl;
	cout << "Son 下m_a = " << Son::m_a << endl;
	//第一个::代表通过类名方式访问 第二个::代表访问父类作用域下
	cout << "Base 下m_a = " << Son::Base::m_a << endl;
}
//同名静态成员函数
void test02() {
	//1.通过对象访问
	Son s;
	s.func();
	s.Base::func();
	//2.通过类名访问
	Son::func();
	Son::Base::func(1000);

}

int main() {
	//test01();
	test02();
	return 0;
}

继承语法

#include<iostream>
using namespace std;
//class Java {
//public:
//	void header() {
//		cout << "公开课，登录注册" << endl;
//	}
//	void footer() {
//		cout << "帮助中心、交流合作、站内地图" << endl;
//
//	}
//	void left() {
//		cout << "java, python, c++" << endl;
//
//
//	}
//	void content() {
//		cout << "this is java" << endl;
//	}
//
//};
//
//class Python {
//public:
//	void header() {
//		cout << "公开课，登录注册" << endl;
//	}
//	void footer() {
//		cout << "帮助中心、交流合作、站内地图" << endl;
//
//	}
//	void left() {
//		cout << "java, python, c++" << endl;
//
//
//	}
//	void content() {
//		cout << "this is Python" << endl;
//	}
//
//};
代码重复性太高
class BasePage {
public:
	void header() {
		cout << "公开课，登录注册" << endl;
	}
	void footer() {
		cout << "帮助中心、交流合作、站内地图" << endl;

	}
	void left() {
		cout << "java, python, c++" << endl;


	}
};

//继承的好处：减少重复的代码
//语法：class 子类:继承方式 父类
//子类也叫派生类 
//父类也叫基类
class Java :public BasePage {
public:
	void content() {
		cout << "this is Java" << endl;
	}
};

class Python :public BasePage {
public:
	void content() {
		cout << "this is Python" << endl;
	}
};


void test01() {
	Java ja;
	ja.header();
	ja.footer();
	ja.left();
	ja.content();
	cout << "--------------------------"<< endl;
	Python py;
	py.header();
	py.footer();
	py.header();
	py.content();
	cout << "--------------------------" << endl;
}





int main() {

	test01();
	return 0;
}

菱形继承

#include<iostream>
using namespace std;
class Animal {
public:
	int m_Age;
};
//继承时加上关键字virtual
class Sheep:virtual public Animal {

};

class Tuo :virtual public Animal {

};

class Yang :public Sheep, public Tuo {

};
void test01() {
	Yang s1;
	s1.Sheep::m_Age = 12;
	s1.Tuo::m_Age = 16;//虚继承后相同数据是共享的
	//当菱形继承时，父类有相同成员属性时，可以添加作用域区分
	cout << "sheep::m_age = " << s1.Sheep::m_Age << endl;
	cout << "Tuo::m_age = " << s1.Tuo::m_Age << endl;

	//菱形继承导致数据有两份导致资源浪费，利用虚继承可以解决问题
}
int main() {
	test01();
	return 0;
}