继承

/**
*封装：提高代码维护性；（遇到问题能够准确定位）
*继承：提高代码复用性；（不是ctrl+c ctrl+v,不做任何修改或者操作源码就能实现代码的复用）
*代码复用的方法：组合(has-a)、继承(is-a)
*多态：提高代码扩展性
**/

#include <iostream>

using namespace std;

class A 
{
public:

	void print()
	{
		cout << "hello world" << endl;
	}

	int m_num = 12;
protected:
	int m_index = 13;
private:
	int m_count = 15;
};

//A是B的父类；B是A的子类
//A是B的基类；B是A的派生类
//覆盖：派生类拥有与基类相同的属性或者方法时，派生类会覆盖
/**
*继承方式：
*public公有继承：基类的公有成员和属性成为派生类的公有；基类的被保护的属性和方法成为派生类的被保护；基类私有成员不能被继承；
*!private私有继承：基类的公有成员和属性会成为派生类的私有；基类的保护属性和方法会成为派生类的私有；基类的私有成员不能被继承；
*!protect被保护继承：基类的公有成员和属性会成为派生类的被保护的；基类里被保护的属性和方法会成为派生类的被保护的；私有成员不能继承；
**/
class B : private A  //private protected public
{
public:

	//A a;//组合：优点？
	//C c D d;
	//int m_num;
	//int count;

	void func()
	{
		//a.func();
		//cout << m_index << endl;
		//cout << m_count << endl;
		print();
	}

	/*void print()
	{
		cout << "hi world" << endl;
	}*/

};

int main()
{
	A a;
	B b;

	//b.m_num = 12;
	//b.print();

	//b.m_num = 12;
	b.print();
	//cout << b.m_index << endl;
	//cout << b.m_count << endl;
#if 0
	b.func();

	//b.m_num = 10;
	b.print();

	//cout << b.m_num << endl;
	//cout << a.m_num << endl;
	cout << sizeof(b) << endl;

	//b.m_num = 12;
	//cout << b.m_num << endl;
	cout << a.m_num << endl;
	cout << b.m_num << endl;
#endif
	return 0;
}

组合的缺点：会占用更多的内存
优点：安全
继承有独立的空间
派生类的实例化对象的大小：父类的对象大小+派生类的新成员；
继承的过程：拷贝

#include <iostream>

using namespace std;

class Test
{
public:
	/*Test()
	{
		cout << "Test" << endl;
	}*/

	Test(int index) : m_index(index)
	{
		cout << "Test int" << endl;
	}

	~Test()
	{
		cout << "~Test" << endl;
	}

	int m_index;
};


class Test1
{
public:
	/*Test()
	{
		cout << "Test" << endl;
	}*/

	Test1(int index) : m_index(index)
	{
		cout << "Test1 int" << endl;
	}

	~Test1()
	{
		cout << "~Test1" << endl;
	}

	int m_index;
};



class A
{
public:

	A()
	{
		cout << "A" << endl;
	}

	explicit A(int num) : m_num(num)
	{
		cout << "A int" << endl;
	}

	void print()//函数遮蔽
	{
		cout << "hello world" << endl;
	}

	~A()
	{
		cout << "~A" << endl;
	}
	
	int m_num;
};

class C
{
public:

	C()
	{
		cout << "C" << endl;
	}

	explicit C(int num) : m_num(num)
	{
		cout << "C int" << endl;
	}

	~C()
	{
		cout << "~C" << endl;
	}

	int m_num2;
};

class B : public C, public A
{
public:
	B() : C(0),A(0),t1(0),t(0)
	{
		cout << "B" << endl;
	}

	B(int count) : m_count(count)，A(count),t1(count),t(count),C(count)
	{
		cout << "B int" << endl;
	}

	void print()//函数遮蔽/覆盖
	{
		cout << "hi world" << endl;
	}

	void print(int num)
	{
		cout << "num = " << endl;
	}

	~B()
	{
		cout << "~B" << endl;
	

	int m_count;

	Test t1;
	Test t;
};

/**
*发生继承之后：
* 构造函数/析构函数的问题：
*1\派生类调用基类的构造函数：派生类继承的属性需要基类的构造函数进行初始化；如果基类没有无参构造函数，那么派生类里所有构造函数都要显式  调用基类的构造函数
*2\构造函数调用顺序：基类(继承声明的顺序决定)、子对象(定义的顺序决定)、派生类    析构函数相反
* 
**/

int main()
{
	B b;
	//B b1(5);

	cout << b.m_num << endl;

	b.A::print();
	b, print(6);

	return 0;
}

子对象一定要在初始化列表初始化

#include <iostream>

using namespace std;

class A
{
public:

	A(int a) : m_a(a)
	{
		cout << "A" << endl;
	}

	int m_a;

};

class B : public A
{
public:

	B(int b) : m_b(b), A(1)
	{
		cout << "B" << endl;
	}

	int m_b;

};

class C : public A
{
public:

	C(int c) : m_c(c), A(2)
	{
		cout << "C" << endl;
	}

	int m_c;

};

class D : public B, public C
{
public:

	D(int d) : m_d(d), B(2), C(3)
	{
		cout << "D" << endl;
	}

	int m_d;

};

int main()

{

	D d(4);

	cout << d.B::m_a << endl;

	return 0;

}

虚继承：virtual
作用：解决多重继承产生的二义性问题