c++ day12 继承

1.公共继承方式

语法：class 子类（派生类） : 继承方式 父类（基类）

减少了重复代码

class basepage  //公共页面
{
public:
	void header()
	{
		cout << "公共头部" << endl;
	}

	void footer()
	{
		cout << "公共底部" << endl;
	}
};

class java :public basepage  //继承了公共页面
{
public:
	void content()
	{
		cout << "java学科页面" << endl;
	}
};

class cpp:public basepage  //继承了公共页面
{
public:
	void content()
	{
		cout << "cpp学科页面" << endl;
	}
};

void test()
{
	java ja; cpp c;
	ja.content();
	ja.footer();
	ja.header();
}

int main()   
{
	test();
	system("pause");              
	return 0;   
}

2.继承方式

• 公共继承
• 保护继承
• 私有继承

父类的私有，子类无法继承

class basepage1  //公共页面
{
public:
	int m_a;
protected:
	int m_b;
private:
	int m_c;	
};

//公共继承
class java :public basepage1  //继承了公共页面
{
private:
	void func()
	{
		m_a = 10; //必须写在函数里
		m_b = 10; //公共继承，父类中的属性权限不变
		//m_c = 10;  //父类中的私有不能继承
	}
};

//保护继承
class cpp:protected basepage1 
{
public:   //也可以写protected,private,子类权限设置只设置的func这个函数的权限，父类属性权限只与继承方式相关
	void func()
	{
		m_a = 10;  //保护继承，父类中的公共属性权限变为保护，其他不变
		m_b = 10;
		//m_c = 10;  //父类中的私有不能继承
	}
};

class cpp2 :public cpp
{
public:
	void func()
	{
		m_a = 10;
		//m_c = 10;//cpp2是子类的子类继承，所以私有权限属性无论怎样都权限都是私有
	}
};

//私有继承略
void test()
{
	java ja; cpp c; cpp2 epic;	
}

int main()   
{
	test();
	system("pause");              
	return 0;   
}

3.继承中的构造和析构顺序

子类继承父类后，也会调用父类的构造函数

4.继承同名成员

如果子类的函数与父类同名，则子类的函数会隐藏父类所有同名函数，包括重载版本，只要叫func，都隐藏

class first
{
public:
	int m_a;
	first()
	{
		m_a = 10;
	}
	void func()
	{
		cout << "first调用 " << endl;
	}
	void func(int a)
	{
		cout << "first调用 " << a << endl;
	}
};

class second :public first
{
public:
	int m_a;
	second()
	{
		m_a = 20;
	}
	void func()
	{
		cout << "second调用 " << endl;
	}
};

void test()
{
	second s;
	cout << s.m_a << "    " << s.first::m_a << endl;  //通过子类访问父类对象需加作用域
	//如果子类的函数与父类同名，则子类的函数会隐藏父类所有同名函数，包括重载版本，只要叫func，都隐藏
	s.first::func(100);
}

int main()
{
	test();
	system("pause");
	return 0;
}

5.继承同名静态成员

静态成员变量（1.类内声明，类外初始化  2.所有共用一个内存）

2.通过类名访问（静态成员共用一个数据）,可不建立对象，直接访问
    //第一个::代表通过类名访问，第二个::表示父类作用域下
    cout << second::first::m_a << endl;  //通过子类这个类名访问父类作用域中的属性

class first
{
public:
	static int m_a;
	static void func()
	{
		cout << "first类函数" << endl;
	}
	static void func(int a)
	{
		cout << "first类函数" << a << endl;
	}
};

int first::m_a = 10; //静态成员变量类内声明类外初始化

class second :public first
{
public:
	static int m_a;
	static void func()
	{
		cout << "second类函数" << endl;
	}
};

int second::m_a = 20; 

void test()
{
	//1.通过对象访问
	second s;
	cout << s.first::m_a << endl;
	//2.通过类名访问（静态成员共用一个数据）,可不建立对象，直接访问
	//第一个::代表通过类名访问，第二个::表示父类作用域下
	cout << second::first::m_a << endl;  //通过子类这个类名访问父类作用域中的属性
}

void test2()
{
	//1.通过对象访问
	second s;
	s.func();
	s.first::func();
	//2.通过类名访问
	second::first::func(100);
}

int main()
{
	//test();
	test2();
	system("pause");
	return 0;
}

6.多继承语法（不建议使用）

c++允许一个类继承多个类

语法：class 子类:继承方式 父类1，继承方式 父类2

多继承可能会有同名成员，需要前加作用域区分

7.菱形继承

概念：两个派生类继承同一个基类，同时某个类同时继承两个派生类，这种被称为菱形继承

用虚继承解决

class base
{
public:
	 int m_a;
};

//利用虚继承解决菱形继承的问题
//继承之前加上关键字virtual变成虚继承
//虚继承的数据类似共享，以最后的数据为准
class second1 :virtual public base{};
class second2 :virtual public base {};

class bottom :public second1, public second2{};

void test()
{
	bottom b;
	//当菱形继承时，两个派生父类有相同变量，需加上作用域来区分
	b.second1::m_a = 100; b.second2::m_a = 23;
	cout << "最后数据  " << b.m_a << endl;  //虚继承后最后一次把是数据修改成23
}

int main()
{
	test();
	system("pause");
	return 0;
}