2021-11-23 继承基础知识点

一. 继承public 继承方式 父类

//继承实现新的页面
class BaseLine 
{
public:
	void header()
	{
		cout << "首页，公开课，登录，注册" << endl;
	}

	void foot()
	{
		cout << "帮助中心，合作交流，站内地图" << endl;
	}

	void left()
	{
		cout << "Java Pytnon c++" << endl;
	}


};

class Jave:public BaseLine
{
public:
	void content()
	{
		cout << "Java video" << endl;
	}
};

class Python :public BaseLine
{
public:
	void content()
	{
		cout << "Python video" << endl;
	}
};

class C :public BaseLine
{
public:
	void content()
	{
		cout << "C++ video" << endl;
	}
};


void test()
{
	Jave ja;
	ja.content();
	ja.foot();
	ja.header();
	ja.left();

	cout << "********************" << endl;

	Python py;
	py.content();
	py.foot();
	py.header();
	py.left();

	cout << "********************" << endl;

	C cc;
	cc.content();
	cc.foot();
	cc.header();
	cc.left();
}

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

二 三种继承方式的说明

class Base 
{
public:
	int m_a;
protected:
	int m_b;
private:
	int m_c;
};

class Son1 :public Base
{
public:
	void func()
	{
		m_a = 10;    //父类中的公共权限成员  公共继承后依然是公共权限
		m_b = 10;    //父类中的保护权限成员  公共继承后依然是保护权限
		//m_c = 10;  //父类中的私有权限，公共继承是访问不到的
	}
};

void test1()
{
	Son1 s1;
	s1.m_a = 30;
	//s1.m_b = 20;  //保护权限的属性在类外是访问不到的
}

class Son2 :protected Base
{
public:
	void func()
	{
		m_a = 100;    //父类中的公共权限成员  保护继承后保护权限
		m_b = 100;    //父类中的保护权限成员  保护继承后依然是保护权限
		//m_c = 100;  //父类中的私有权限，公共继承是访问不到的
	}
};

void test2()
{
	Son2 s2;
	//s2.m_a = 1000; //保护权限的属性在类外是访问不到的
	//s1.m_b = 20;  //保护权限的属性在类外是访问不到的
}


class Son3 :private Base
{
public:
	void func()
	{
		m_a = 1000;    //父类中的公共权限成员  私有继承后私有权限
		m_b = 1000;    //父类中的保护权限成员  私有继承后私有权限
		//m_c = 100;  //父类中的私有权限，公共继承是访问不到的
	}
};

void test3()
{
	Son3 s3;
	//s3.m_a = 1000; //私有权限的属性在类外是访问不到的
	//s3.m_b = 20;  //私有权限的属性在类外是访问不到的
}

int main()
{
	test1();
	test2();
	return 0;
}

三 继承的本质，是全部成员都被继承

class Base
{
public:
	int m_a;
protected:
	int m_b;
private:
	int m_c;
};

class Son :public Base
{
public:
	int m_d;
};

void test()
{
	//父类中的所有静态成员属性都会被继承，虽然私有成员是不能被访问，但是还是被继承了，被隐藏了
	cout << sizeof(Son) << endl;
}

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

四 继承中的构造和析构顺序，继承中先调用父类构造函数再调用子类构造函数，析构则是相反

//继承中的构造和析构顺序，是父类还是子类先进行相应的构造和析构
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 test()
{
	//Base b;
	Son s1;
}

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

五 继承中同名的成员和函数的处理方式

//继承中同名的成员处理方式
//访问子类同名成员  直接访问即可
//访问父类的同名成员 需要加作用域

class Base
{
public:
	Base()
	{
		m_a = 100;
	}

	void func()
	{
		cout << "base func" << endl;
	}

	void func(int)
	{
		cout << "int base func" << endl;
	}
	int m_a;
};


class Son : public Base
{
public:
	Son()
	{
		m_a = 200;
	}

	void func()
	{
		cout << "Son func" << endl;
	}
	int m_a;
};


//同名成员的处理方式
void test()
{
	Son s1;
	cout << "s1.m_a = " << s1.m_a << endl;

	//如果需要通过子类来访问父类里面的同名成员，需要加一个作用域
	cout << "b.m_a = " << s1.Base::m_a << endl;
}

//同名函数的处理方式
void test01()
{
	Son s2;
	s2.func( );        //调用的是子类的同名成员
	s2.Base::func();  //通过子函数调用父类的同名成员，也是加一个作用域
	s2.Base::func(100);
}

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

六 继承中同名的静态成员的处理方式

// 和正常的函数和成员的处理是一样的，也即同五

七 多继承语法，允许一个类继承多个类

//多继承语法，允许一个类继承多个类
//语法：class 子类：继承方式 父类1 ，继承方式 父类2
//多继承可能会引发父类中有同名成员的出现，一般不建议这么使用

class Base1
{
public:
	Base1()
	{
		m_a = 100;
	}

	int m_a;
};


class Base2
{
public:
	Base2()
	{
		m_a = 200;
	}

	int m_a;
};


//子类
class Son :public Base1, public Base2
{
public:
	Son()
	{
		m_c = 300;
		m_d = 400;
	}
	int m_c;
	int m_d;
};


void test()
{
	Son s;
	cout << "sizeof son " << sizeof(s) << endl;
	//当父类中出现同名成员，需要加作用域进区分
	cout << "Base1::m_a =" << s.Base1::m_a << endl;
	cout << "Base2::m_a =" << s.Base2::m_a << endl;
}

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

八 菱形继承案例

//菱形继承案例
//利用虚继承可以解决菱形继承的问题，在继承前加上关键字，virtual 变为虚继承

class Animal
{
public:
	int m_age;
};

class Sheep:virtual public Animal{};
class Tuo :virtual public Animal{};
class SheepTuo :public Sheep, public Tuo{};

void test()
{
	SheepTuo st;
	st.Sheep::m_age = 18;
	st.Tuo::m_age = 20;
	//当菱形继承，两个父类拥有相同的数据，需要加以区分
	cout << " st.Sheep::m_age =  " << st.Sheep::m_age << endl;
	cout << " st.Tuo::m_age =  " << st.Tuo::m_age << endl;

	//这个数据只需要一份就可以，这个动物只能有一个年龄，浪费资源，虚继承之后，都变成20，
	cout << " st.m_age =  " << st.m_age << endl;

}


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