c++继承_c++ 写一个猫狗继承-CSDN博客

本文链接：https://blog.csdn.net/m0_64837135/article/details/123679297

继承是面向对象三大特性之一。
有些类与类之间存在一些特殊的关系，例如：
有一个动物类，猫与狗都是属于动物，都有动物的共性，也有自己的个性。

我们发现，定义这些类时，下级的成员除了拥有上一级的共性之后，还有自己的特性。
这个时候我们就可以考虑利用继承的技术，减少重复的代码。

//继承的好处：减少重复的代码。
//语法：class 子类 : 继承方式父类
//子类也称为派生类
//父类也称为基类
//派生类的成员包括两部分：
//一类是从基类继承过来，一类是自己增加的成员。
//从基类继承过来的，体现其共性。
//自己增加的成员，体现其个性。

继承方法：公有继承，保护继承，私有继承

继承方式：public， protected， private

#include <iostream>
using namespace std;

//继承方式
//公共继承
class Base1{
public:
	int m_A;

protected:
	int m_B;

private:
	int m_C;
};

class Son1:public Base1{
public:
	void func(){
		m_A = 10;  //公共属性  --> 公共属性(在类内可以访问)
		m_B = 10;  //保护属性  --> 保护属性
		//m_C = 10;//私有属性  --> 不可访问
	}
};

//保护继承
class Base2{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};

class Son2:protected Base2{
public:
	void func(){
		m_A = 10;  //公共属性  --> 保护属性
		m_B = 10;  //保护属性  --> 保护属性
		//m_C = 10;//私有属性  --> 不可以访问
	}
};

class GrandSon2:public Son2{
public:
	void func(){
		m_A = 10;
		m_B = 10;
	}
};

//私有继承
class Base3{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;	
};

class Son3:private Base3{
public:
	void func(){
		m_A = 10;
		m_B = 10;
		//m_C = 10;
	}
};

class GrandSon:public Son3{
public:
	void func(){
		//m_A = 10;
		//m_B = 20;
	}

};

int main(int argc,char *argv[]){
	Son1 s1;
	s1.m_A = 20;   //公共属性在类外也可以访问。
	//s1.m_B = 20;   //保护属性在类外不可以访问。
	//s1.m_C = 20;   //m_C不可以访问
	
	Son2 s2;
	//s2.m_A = 20;
	//s2.m_B = 20;
	//s2.m_C = 20;
	
	Son3 s3;
	//s3.m_A = 20;
	//s3.m_B = 20;
	//s3.m_C = 20;

	return 0;
}

类外访问

子类访问

题

从父类中继承过来的成员，哪些属于子类对象上


#include <iostream>
using namespace std;

class Base{
public:
	int m_A;

protected:
	int m_B;

private:
	int m_C;
    static int m_D;
};

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

int main(int argc,char *argv[]){
	//1. 计算父类对象的大小。
	cout << "sizeof(Base):" << sizeof(Base) << endl;  //12

	//2. 计算子类对象的大小。
	//父类的所有非静态成员变量都会被子类继承
	//父类私有属性是被编译器隐藏器掉，因此访问不到的，但是确实是继承下去了。
	cout << "sizeof(Son):" << sizeof(Son) << endl;  //16

	return 0;
}
/************************
运行结果：
PS C:\Users\32781\Desktop\love_you\02> g++ .\demo1.cpp
PS C:\Users\32781\Desktop\love_you\02> .\a.exe        
sizeof(Base):12
sizeof(Son):16
PS C:\Users\32781\Desktop\love_you\02>
************************/

子类继承父类之后，当创建子类对象时，也会调用父类的构造函数。
问题：父类和子类的构造和析构的顺序


#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;
	}
};

int main(int argc,const char *argv[]){
	//Base b;
	Son s;

	return 0;
}
/***********************
运行结果：
PS C:\Users\32781\Desktop\love_you\02> g++ .\demo1.cpp
PS C:\Users\32781\Desktop\love_you\02> .\a.exe        
Base的构造函数的调用
Son的构造函数的调用
Son的析构函数的调用
Base的析构函数的调用
PS C:\Users\32781\Desktop\love_you\02>
***********************/

/*父类先构造子类先析构*/

继承中同名成员处理方式。
问题：当子类与父类出现同名时，如何通过子类对象，访问子类或者父类同名的数据

1）访问子类的同名成员，直接访问即可。
2）访问父类的同名成员，需要加作用域

#include <iostream>
using namespace std;

class Base{
public:
	Base(){
		m_A = 10;
	}

	void func(){
		cout << "Base - func()的调用" << endl;
	}

	int m_A;
};

class Son:public Base{
public:
	Son(){
		m_A = 20;
	}

	void func(){
		cout << "Son - func()的调用" << endl;
	}


	int m_A;
};

int main(int argc,const char *argv[]){
	//1. 同名成员属性处理
	//Son s;
	//cout << "Son下的m_A = " << s.m_A << endl;  //访问儿子中的成员属性，直接访问即可。

	//如果通过子类对象，访问父类的同名成员，需要加作用域
	//cout << "Base下的m_A = " << s.Base::m_A << endl;

	//2. 同名成员函数的调用。
	Son s;

	s.func();
	s.Base::func();

	return 0;
}
/*****************
PS C:\Users\32781\Desktop\love_you\02> g++ .\demo1.cpp
PS C:\Users\32781\Desktop\love_you\02> .\a.exe        
Son - func()的调用
Base - func()的调用
PS C:\Users\32781\Desktop\love_you\02>
*******************/

继承同名静态成员处理方式。
问题：继承中同名静态成员在子类如何访问？
静态成员与非静态成员出现同名情况，处理方式一致。
1）访问子类同名成员，直接访问即可。
2）访问父类同名成员，需要加作用域。

#include <iostream>
using namespace std;

class Base{
public:
	static int m_A;  //静态成员属性

	static void func(){
		cout << "Base - static void func()的调用" << endl;
	}

};

//静态成员属性需要类内声明，类外初始化。
int Base::m_A = 100;

class Son:public Base{
public:
	static int m_A;

	static void func(){
		cout << "Son - static void func()的调用" << endl;
	}
};

int Son::m_A = 200;

void test01(){
	//1. 通过对象进行访问。
	cout << "通过对象来访问:" << endl;
	Son s;
	cout << "Son m_A = " << s.m_A << endl; 
	cout << "Base m_A = " << s.Base::m_A << endl;

	//2. 通过类名访问。
	cout << "通过类名访问:" << endl;

	//Son::类名
	cout << "Son m_A = " << Son::m_A << endl;

	//Base::类名
	cout << "Base m_A = " << Base::m_A << endl;

	//Son:: 类名
	//Base:: 作用域
	cout << "Base m_A = " << Son::Base::m_A << endl;
}


void test02(){
	//1. 通过对象访问。
	cout << "通过对象来访问:" << endl;
	Son s;
	s.func();
	s.Base::func();

	//2. 通过类名来访问。
	cout << "通过类名访问:" << endl;
	Son::func();
	Base::func();
	Son::Base::func();

}

int main(int argc,const char *argv[]){
	//test01();

	test02();

	return 0;
}

多继承语法。
C++中允许一个类继承多个类。
语法：class 子类 : 继承方式父类1 ，继承方式父类2 ...
多继承可能会引起父类中同名成员出现，需要加作用域加以区分。

#include <iostream>
using namespace std;

//多继承语法
class Base1{
public:
	Base1(){
		m_A = 100;
	}

	int m_A;
};

class Base2{
public:
	Base2(){
		//m_B = 200;
		m_A = 200;
	}
	//int m_B;
	int m_A;
};

//子类：需要继承Base1与Base2
//class 子类 : 继承方式 父类1 ，继承方式 父类2 ...
class Son : public Base1 , public Base2{
public:
	Son(){
		m_C = 300;
		m_D = 400;
	}

	int m_C;
	int m_D;
};

int main(int argc,char *argv[])
{
	//1. 计算子类对象的大小。
	cout << "sizeof(Son):" << sizeof(Son) << endl;/*16*/

	//2. 当名字不一样的时侯： 直接访问即可。
	//Son s;
	//cout << "m_A = " << s.m_A << endl;
	//cout << "m_B = " << s.m_B << endl;

	//3. 当名字一样的时候，
	Son s;
	//cout << "m_A = " << s.m_A << endl;  //编译出错
	//cout << "Base1中的m_A = " << s.Base1::m_A << endl;
	//cout << "Base2中的m_A = " << s.Base2::m_A << endl;
	
	//不建议使用多继承语法。
	//因为如果两个父类分别是两个人写的，不保证不会出现同名的情况，这就很麻烦。

	return 0;
}