【C++】继承最全解析（什么是继承？继承有什么用？）

news2024/12/28 21:59:58

目录

一、前言

二、什么是继承 ? 

💢继承的概念💢 

💢继承的定义💢  

🥝定义格式 

🍇继承权限 

三、基类与派生类对象的赋值转换 

四、继承的作用域 

五、派生类中的默认成员函数 

💢默认成员函数的调用 💢

🔥构造函数与析构函数🔥

🔥拷贝构造🔥 

🔥赋值运算符重载 🔥

💢显示成员函数的调用 💢 

🔥构造函数 🔥

🔥拷贝构造 🔥

🔥赋值运算符重载 🔥

🔥析构函数🔥 

六、继承与友元 

七、继承与静态成员

八、菱形继承 

💧 单继承💧

💧 多继承💧

💧 菱形继承💧 

🍍概念 

🍉现象 

九、继承和组合 

十、继承的总结和反思 

十一、共勉 

一、前言

   继承 是 面向对象三大特性之一（封装、继承、多态），所有的面向对象（OO）语言都具备这三个基本特征，封装相关概念已经在《类和对象》系列中介绍过了，今天主要学习的是 继承，即如何在父类的基础之上，构建出各种功能更加丰富的子

二、什么是继承 ? 

什么是继承？是继承 -- 遗产 还是继承 -- 花呗？答案都不是，先来看看官方解释：

继承（inheritance）机制是 ----面向对象程序设计使代码可以复用的重要的手段，它允许程序员在保持原有基类（父类）特性的基础上进行扩展，增加功能，这样产生新的类，称为派生类（子类） 

💢继承的概念💢 

继承相关概念： 

  • 被继承对象：父类 / 基类 （base）
  • 继承方：子类 / 派生类 （derived）

继承的本质 就是 ------------ 复用代码 

举个例子 : 假设我现在要设计一个校园管理系统，那么肯定会设计很多角色类，比如学生、老师、保安、保洁等等之类的。 

设计好以后，我们发现，有些数据和方法是每个角色都有的，而有些则是每个角色独有的。 

为了复用代码、提高开发效率，可以从各种角色中选出共同点，组成 基类，比如每个 人 都有姓名、年龄、联系方式等基本信息，而 教职工 与 学生 的区别就在于 管理与被管理，因此可以在 基类 的基础上加一些特殊信息如教职工号 表示 教职工，加上 学号 表示学生，其他细分角色设计也是如此

这样就可以通过 继承 的方式，复用 基类 的代码，划分出各种 子类 

 像上面共同拥有的数据和方法我们可以重新设计一个类Person ，然后让 Student 和 Teacher 去继承它，如下:

// 大众类  --- 基础属性
class Person
{
public:
	Person(string name = string(), string tell = string(), int age = int())
		:_name(name)
		,_tell(tell)
		,_age(age)
	{}
	void Print()
	{
		cout << "我的名字是 :" << _name << endl;
		cout << "我的电话是 :" << _tell << endl;
		cout << "我的年龄是 :" << _age << endl;
	}
protected:
	string _name; // 姓名
	string _tell; // 电话
	int _age; // 年龄
};


// 学生类  --- 派生/子属性
class Student : public Person
{
public:
	Student(int stuId = 1578)
		:Person("XAS","123456789",26)
		,_stuId(stuId)
	{
		cout << "我是一个学生" << endl;
		cout << "以下是我的个人信息 ：" << endl;
		cout << endl;
		cout << "我的学号为 :" << _stuId << endl;
	}
protected:
	int _stuId; // 学号
};


// 老师类  --- 派生/子属性
class Teacher : public Person
{
public:
	Teacher(int workId = 2024916)
		:Person("xas","987654321",26)
		,_workId(workId)
	{
		cout << "我是一个老师" << endl;
		cout << "以下是我的个人信息 ：" << endl;
		cout << endl;
		cout << "我的工号为 :" << _workId << endl;
	}
protected:
	int _workId; // 工号
};

int main()
{
	Student s;
	s.Print();
	cout << "---------------------" << endl;
	cout << "---------------------" << endl;
	Teacher t;
	t.Print();
	return 0;
}

继承后，父类的 Person 的成员(成员函数+成员变量)都会变成子类的一部分。这里体现出了Student 和 Teacher 复用了 Person 

💢继承的定义💢  

了解完 继承相关概念 后，就可以开始学习 使用继承 了 

🥝定义格式 

格式如下: Person 是 父类，也称作基类; Student 是 子类，也称作派生类。 

格式为 ：子类 : 继承方式 父类，比如 class a : public b 就表示 a 继承了 b，并且还是 公有继承 

注：Java 中的继承符号为 extern，而 C++ 中为 : 

🍇继承权限 

继承有权限的概念，分别为：公有继承（public）、保护继承（protected）、私有继承（private） 

没错，与 类 中的访问 限定修饰符 一样，不过这些符号在这里表示 继承权限 

简单回顾下各种限定符的用途

  • 公有 public：公开的，任何人都可以访问
  • 保护 protected：保护的，只有当前类和子类可以访问
  • 私有 private：私有的，只允许当前类进行访问

权限大小：公有 > 保护 > 私有
保护 protected 比较特殊，只有在 继承 中才能体现它的价值，否则与 私有 作用一样

此时我们发现  ---- 访问权限：三种     继承权限：三种

根据排列组合，可以列出以下多种搭配方案 

父类成员 / 继承权限publicprotectedprivate
父类的 public 成员外部可见，子类中可见外部不可见，子类中可见外部不可见，子类中可见
父类的 protected 成员外部不可见，子类中可见外部不可见，子类中可见外部不可见，子类中可见
父类的 private 成员都不可见都不可见都不可见

注：所谓的--外部--其实就是 子类对象

总结：

  • 无论是哪种继承方式，父类中的 private 成员始终不可被 [子类 / 外部] 访问；当外部试图访问父类成员时，依据 min(父类成员权限, 子类继承权限)，只有最终权限为 public 时，外部才能访问
  • 在实际运用中一般使用都是 public 继承，几乎很少使用 protetced/private 继承，也不提倡使用 protetced/private继承，因为 protetced/private 继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

如何证明呢？ 通过一下的代码，我们来验证上面的结论！！

// 父类
class A
{
public:
	int _a;
protected:
	int _b;
private:
	int _c;
};

// 子类
class B : public A
{
public:
	B()
	{
		cout << _a << endl;
		cout << _b << endl;
		cout << _c << endl;
	}
};

int main()
{
	// 外部（子类对象）
	B b;      
	b._a;
}
  • public 继承 

  •  protected 继承 

  •   private 继承 

之所以说 C++ 的继承机制设计复杂了，是因为 protected 和 private 继承时的效果一样

其实 C++ 中搞这么多种情况（9种）完全没必要，实际使用中，最常见到的组合为 public : public 和 protected : public 

如何优雅的使用好  ---- 继承权限 ？ 

对于只想自己类中查看的成员，设为 private，对于想共享给子类使用的成员，设为 protected，其他成员都可以设为 public

比如在张三家中，张三家的房子面积允许公开，家庭存款只限家庭成员共享，而个人隐私数据则可以设为私有

class Home
{
public:
	int area = 500;	//500 平米的大房子
};

class Father : public Home
{
protected:
	int money = 50000;	//存款五万
private:
	int privateMoney = 100;	//私房钱，怎能公开？
};

class Zhangsan : public Father
{
public:
	Zhangsan()
	{
		cout << "我是张三" << endl;
		cout << "我知道我家房子有 " << area << " 平方米" << endl;
		cout << "我也知道我家存款有 " << money << endl;
		cout << "但我不知道我爸爸的私房钱有多少" << endl;
	}
};

class Xiaoming
{
public:
	Xiaoming()
	{
		cout << "我是小明" << endl;
		cout << "我只知道张三家房子有 " << Home().area << " 平方米" << endl;
		cout << "其他情况我一概不知" << endl;
	}
};

int main()
{
	Zhangsan z;
	cout << "================" << endl;
	Xiaoming x;
	return 0;
}

三、基类与派生类对象的赋值转换 

在继承中，允许将 子类 对象直接赋值给 父类，但不允许 父类 对象赋值给 子类 

  • 这其实很好理解，儿子以后可以当父亲，父亲还可以当儿子吗？

并且这种 赋值 是非常自然的，编译器直接处理，不需要调用 赋值重载 等函数 

派生类对象   可以赋值给      基类的对象 / 基类的指针 / 基类的引用。 

(1) 子类对象可以赋值给父类对象 

//基类
class Person
{
public:
	string _name; // 姓名
	string _sex; // 性别
	int _age; // 年龄
};

//派生类
class Student : public Person
{
public:
	int _id;
};

int main()
{
	Person p;
	Student s;

	s._name = "张三";
	s._sex = "男";
	s._age = 20;
	s._id = 8888;
	
	p = s; // 子类对象赋值给父类对象

	return 0;
}

 通过调式可以看到，为什么没有把 id 赋值过去呢?

这里有个形象的说法叫切片或者切割，相当于把派生类中父类那部分切来赋值过去，如图所示: 

(2) 子类对象可以赋值给父类指针  

//基类
class Person
{
public:
	string _name; // 姓名
	string _sex; // 性别
	int _age; // 年龄
};

//派生类
class Student : public Person
{
public:
	int _id;
};


int main()
{
	Student s;

	s._name = "张三";
	s._sex = "男";
	s._age = 20;
	s._id = 8888;

	Person* p = &s;

	return 0;
}

可以看到，当父类对象是一个指针的时候，照样可以赋值过去：

子类对象赋值给父类指针切片图： 

(3) 子类对象可以赋值给父类引用 

//基类
class Person
{
public:
	string _name; // 姓名
	string _sex; // 性别
	int _age; // 年龄
};

//派生类
class Student : public Person
{
public:
	int _id;
};

int main()
{
	Student s;

	s._name = "张三";
	s._sex = "男";
	s._age = 20;
	s._id = 8888;

	Person& rp = s;

	return 0;
}

 可以看到，当父类对象是一个引用的时候，也可以赋值过去：

 子类对象赋值给父类引用切换图片：

(4) 父类对象不能赋值给子类对象

//基类
class Person
{
public:
	string _name; // 姓名
	string _sex; // 性别
	int _age; // 年龄
};

//派生类
class Student : public Person
{
public:
	int _id;
};

int main()
{
	Student s;
	Person p;

	s = p;

	return 0;
}

编译会报错： 

四、继承的作用域 

在继承体系中 基类 和 派生类 都有独立的作用域，如果子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫 隐藏，也叫重定义。

代码示例: Student 的 _num 和 Person的 _num 构成隐藏关系，可以看出这样代码虽然能跑，但是非常容易混淆。

// 基类
class Person
{
protected:
	string _name = "Edison"; // 姓名
	int _num = 555; // 身份证号
};

// 派生类
class Student : public Person
{
public:
	void Print()
	{
		cout << "姓名:" << _name << endl;
		cout << "学号:" << _num << endl;
	}
protected:
	int _num = 888; // 学号
};

int main()
{
	Student s1;
	s1.Print();

	return 0;
}

 运行可以看到，访问的是子类中的_num (类似于局部优先的原则)

那么如果我想访问父类中的_num 呢 ? 可以使用基类 :: 基类成员显示的去访问 : 

// 基类
class Person
{
protected:
	string _name = "Edison"; // 姓名
	int _num = 555; // 身份证号
};

// 派生类
class Student : public Person
{
public:
	void Print()
	{
		cout << "姓名:" << _name << endl;
		cout << " 身份证号:" << Person::_num << endl;
	}
protected:
	int _num = 888; // 学号
};

int main()
{
	Student s1;
	s1.Print();

	return 0;
}

 可以看到，此时就是访问的父类中的 _num 

还有一点需要注意的是 : 如果是成员函数的隐藏，只需要函数名相同就构成隐藏。 

// 基类
class A
{
public:
	void fun()
	{
		cout << "A::func()" << endl;
	}
};

// 派生类
class B : public A
{
public:
	void fun(int i)
	{
		cout << "B::func()" << endl;
		cout << "func(int i)->" << i << endl;
	}
};

int main()
{
	B b;
	b.fun(10);

	return 0;
}

 可以看到，默认是去调用子类的 fun() 函数，因为成员函数满足函数名相同就构成隐藏。

如果想调用父类的 fun() 还是需要指定作用域 

// 基类
class A
{
public:
	void fun()
	{
		cout << "A::func()" << endl;
	}
};

// 派生类
class B : public A
{
public:
	void fun(int i)
	{
		cout << "B::func()" << endl;
		cout << "func(int i)->" << i << endl;
	}
};

int main()
{
	B b;
	b.A::fun();

	return 0;
}

 运行可以看到，此时就是调用父类中的 fun()

注意 ：B 中的 fun 和 A 中的 fun 不是构成函数重载，而是隐藏 ！函数重载的要求是在同一作用域里面！！

另外，在实际中在继承体系里面最好不要定义同名的成员。

五、派生类中的默认成员函数 

派生类（子类）也是 类，同样会生成 六个默认成员函数（用户未定义的情况下）

不同于单一的 类，子类 是在 父类 的基础之上创建的，因此它在进行相关操作时，需要为 父类 进行考虑

这里我们只以下面的两个类为基础，讨论四类默认成员函数：构造函数、拷贝构造、赋值运算符重载、析构函数 

class Person
{
public:
	Person(const std::string name = std::string(), const int age = 18, const int sex = 1)
		: _name(name)
		, _age(age)
		, _sex(sex)
	{
		std::cout << "Person()" << std::endl;
	}

	Person(const Person& p)
		: _name(p._name)
		, _age(p._age)
		, _sex(p._sex)
	{
		std::cout << "Person(const Person& p)" << std::endl;
	}

	Person& operator= (const Person& p)
	{
		std::cout << "operator= (const Person& p)" << std::endl;
		if (this != &p)
		{
			_name = p._name;
		}

		return *this;
	}

	~Person()
	{
		std::cout << "~Person()" << std::endl;
	}
protected:
	std::string _name;
	int _age = 18;
	int _sex = 1;
};

class Student : public Person
{
public:
protected:
	long long _st_id;
};

💢默认成员函数的调用 💢

🔥构造函数与析构函数🔥

int main()
{
	Student st;
	return 0;
}

output： 

Person()     // s1 的构造
~Person()    // s1 的析构

说明了，派生类的默认构造函数和默认析构函数都会 -----自动调用基类的构造和析构 

🔥拷贝构造🔥 

int main()
{
	Student st1;
	Student st2(st1);

	return 0;
}

 output:

Person()                 // s1 的构造函数
Person(const Person& p)  // s2 拷贝构造
~Person()                // s2 的析构函数
~Person()                // s1 的析构函数

说明了，派生类的默认拷贝构造会自动调用基类的拷贝构造 

🔥赋值运算符重载 🔥

int main()
{
	Student st1, st2;
	st1 = st2;

	return 0;
}

output：

Person()    // s1 的拷贝构造
Person()    // s2 的拷贝构造
operator= (const Person& p)    // 赋值重载
~Person()   // s2 的析构函数
~Person()   // s1 的析构函数

说明了，派生类的默认赋值运算符重载会自动调用基类的赋值运算符重载 

实际上，我们可以将派生类的成员分成三部分：基类成员、内置类型成员、自定义类型成员 

  • 继承相较于我们以前学的类和对象，可以说就是多了基类那一部分

  • 当调用派生类的默认成员函数时，对于基类成员都会调用对应基类的默认成员函数来处理

💢显示成员函数的调用 💢 

🔥构造函数 🔥

当实现派生类的构造函数时，就算不显示调用基类的构造，系统也会自动调用基类的构造： 

class Student : public Person
{
public:
	Student(long long st_id = 111)
		: _st_id(st_id)
	{
		std::cout << "Student()" << std::endl;
	}
protected:
	long long _st_id;
};
int main()
{
	Student st;
	return 0;
}

 output:

Person()
Student()
~Person()

如果需要显示的调用基类的构造函数，应该这样写： 

Student(long long st_id = 111)
	: _st_id(st_id)
	, Person("xas", 18)
{
	std::cout << "Student()" << std::endl;
}

 特别注意：

Person("xas", 18)如果放在初始化列表，那就使显式调用基类的构造函数；如果放在函数体内，那就使创建一个基类的匿名对象 

🔥拷贝构造 🔥

 当实现派生类的拷贝构造时，如果没有显式调用基类的拷贝构造，那么系统就会自动调用基类的构造

class Student : public Person
{
public:
	Student(long long st_id = 111)
		: _st_id(st_id)
		, Person("xas", 18)
	{
		std::cout << "Student()" << std::endl;
	}

	Student(const Student& s)
		: _st_id(s._st_id)
	{
		std::cout << "Student(const Student& s)" << std::endl;
	}
protected:
	long long _st_id;
};
int main()
{
	Student st1;
	Student st2(st1);

	return 0;
}

output： 

Person()
Student()
Person()	//系统自动调用了基类的构造
Student(const Student& s)
~Person()
~Person()

 也可以像显示调用构造函数一样显式调用基类的拷贝构造：

Student(const Student& s)
	: Person(s)
	, _st_id(s._st_id)
{
    std::cout << "Student(const Student& s)" << std::endl;
}

🔥赋值运算符重载 🔥

 在实现派生类的赋值运算符重载时，如果没有显式调用基类的赋值运算符重载，系统也不会自动调用基类的赋值运算符重载

class Student : public Person
{
public:
	Student(long long st_id = 111)
		: _st_id(st_id)
		, Person("xas", 18)
	{
		std::cout << "Student()" << std::endl;
	}

	Student& operator= (const Student& s)
	{
		std::cout << "operator= (const Student& s)" << std::endl;
		if (this != &s)
		{
			_st_id = s._st_id;
		}

		return *this;
	}
protected:
	long long _st_id;
};
int main()
{
	Student st1, st2;
	st1 = st2;

	return 0;
}

output: 

Person()
Student()
Person()
Student()
operator= (const Student& s)
~Person()
~Person()

因此，在实现派生类的赋值运算符重载时，必须显示调用基类的赋值运算符重载： 

Student& operator= (const Student& s)
{
	std::cout << "operator= (const Student& s)" << std::endl;
	if (this != &s)
	{
		Person::operator=(s);	//由于基类和派生类的赋值运算符重载构成隐藏，因此要用 :: 指定类域
		_st_id = s._st_id;
	}
	return *this;
}

🔥析构函数🔥 

 在实现派生类的析构函数时，不要显式调用基类的析构函数，系统会在派生类的析构完成后自动调用基类的析构

class Student : public Person
{
public:
	Student(long long st_id = 111)
		: _st_id(st_id)
		, Person("xas", 18)
	{
		std::cout << "Student()" << std::endl;
	}
	~Student()
	{
		std::cout << "~Student()" << std::endl;
	}
protected:
	long long _st_id;
};

int main()
{
	Student st1;

	return 0;
}

output: 

Person()
Student()
~Student()
~Person()
  • 和前面的默认成员函数不同，在实现派生类的析构时，基类的析构不能显式调用
  • 这是因为，如果显示调用了基类的析构，就会导致基类成员的资源先被清理，如果此时派生类成员还访问了基类成员指向的资源就，就会导致野指针问题
  • 因此，必须保证析构顺序为先子后父，保证数据访问的安全

六、继承与友元 

友元关系不能继承，也就是说 基类友元不能访问子类私有和保护成员，只能访问自己的私有和保护成员。 

下面代码中，Display 函数是基类 Person 的友元，但是 Display 函数不是派生类 Student 的友元，也就是说 Display 函数无法访

class Student;

class Person
{
public:
	friend void Display(const Person& p, const Student& s);
protected:
	string _name; // 姓名
};

class Student : public Person
{
protected:
	int _stuNum; // 学号
};

void Display(const Person& p, const Student& s)
{
	cout << p._name << endl; // 可以访问
	cout << s._stuNum << endl; // 无法访问
}

int main()
{
	Person p;
	Student s;
	Display(p, s);

	return 0;
}

可以看到运行会报错：

如果想让 Display 函数也能够访问派生类Student 的私有和保护成员，只需要在派生类Student 当中进行友元声明。 

class Student;

class Person
{
public:
	friend void Display(const Person& p, const Student& s); // 声明Display是Person的友元
protected:
	string _name; // 姓名
};

class Student : public Person
{
public:
	friend void Display(const Person& p, const Student& s); // 声明Display是Student的友元
protected:
	int _stuNum; // 学号
};

void Display(const Person& p, const Student& s)
{
	cout << p._name << endl; // 可以访问
	cout << s._stuNum << endl; // 可以访问
}

int main()
{
	Person p;
	Student s;
	Display(p, s);

	return 0;
}

七、继承与静态成员

 如果基类中定义了static 静态成员,则整个继承体系里面只有一个这样的成员。 无论派生出多少个子类,都只有一个 static 成员实例。

下面代码中，在基类 Person 当中定义了静态成员变量 _ count, 派生类 Student 和 Graduate 继承了Person, 但是，在整个继承体 

// 基类
class Person
{
public:
	Person() { ++_count; }
protected:
	string _name; // 姓名
public:
	static int _count; // 统计人的个数。
};

// 静态成员在类外面定义
int Person::_count = 0; 

// 派生类
class Student : public Person
{
protected:
	int _stuNum; // 学号
};

// 派生类
class Graduate : public Student
{
protected:
	string _seminarCourse; // 研究科目
};

int main()
{
	Student s1;
	Student s2;
	Student s3;
	Graduate s4;
	Person s;

	cout << " 人数 :" << Person::_count << endl;
	cout << " 人数 :" << Student::_count << endl;
	cout << " 人数 :" << s4._count << endl;

	return 0;
}

 我们定义了5个对象，那么每定义一个对象都会去调用一次++ _count ，打印以后可以看到，这几个对象里面的 _count 都是一样的:

同时，我们还可以打印一下地址，可以看到也是同-个: 

 总结: 关于父类中的静态成员，子类继续下来以后都是同一个，类似于“传家宝"。

八、菱形继承 

💧 单继承💧

一个子类只有一个直接父类时称这个继承关系为单继承   

💧 多继承💧

 一个子类有两个或以上直接父类时称这个继承关系为多继承

💧 菱形继承💧 

 C++ 支持多继承，即支持一个子类继承多个父类，使其基础信息更为丰富，但凡事都有双面性，多继承 在带来巨大便捷性的同时，也带来了个巨大的坑：菱形继承问题

🍍概念 

首先 C++ 允许出现多继承的情况，如下图所示 

这样看很正常是吧，但如果出现以下这种 重复继承 的情况，就比较麻烦了 

此时 普通人X 会纠结于使用哪一个 不用吃饭 的属性！这对于编译器来说，是一件无法处理的事 

🍉现象 

将上述概念转化为代码，观察实际现象

注：多继承时，只需要在 父类 之后，添加 , 号，继续增加想要继承的父类

class Person
{
public:
	string _name;	//姓名
};

//本科生
class Undergraduate : public Person
{};

//研究生
class Postgraduate : public Person
{};

//毕业生
class Graduate : public Undergraduate, public Postgraduate
{};

int main()
{
	Graduate g1;
	g1._name = "zhangsan";

	return 0;
}

无法编译！ 

原因分析： 

 Undergraduate 中继承了 Person 的 _name，Postgraduate 也继承了 Person 的 _name

Graduate 多继承 Undergraduate 、Postgraduate 后，同时拥有了两个 _name，使用时，无法区分！

通过监视窗口查看信息： 

解决方法： 

想要解决二义性很简单，通过 :: 限制访问域即可 

Graduate g1;
g1.Undergraduate::_name = "zhangsan";
cout << g1.Undergraduate::_name << endl;

但这没有从本质上解决问题！而且还没有解决数据冗余问题 

 真正的解决方法：虚继承

 注：虚继承是专门用来解决 菱形继承 问题的，与多态中的虚函数没有直接关系

虚继承：在菱形继承的腰部继承父类时，加上 virtual 关键字修饰被继承的父类 

class Person
{
public:
	string _name;	//姓名
};

//本科生
class Undergraduate : virtual public Person
{};

//研究生
class Postgraduate : virtual public Person
{};

//毕业生
class Graduate : public Undergraduate, public Postgraduate
{};

int main()
{
	Graduate g1;
	g1._name = "zhangsan";
	cout << g1._name << endl;

	return 0;
}

此时可以解决 菱形继承 的 数据冗余 和 二义性 问题 

 虚继承是如何解决菱形继承问题的？

  • 利用 虚基表 将冗余的数据存储起来，此时冗余的数据合并为一份
  • 原来存储 冗余数据 的位置，现在用来存储 虚基表指针

此时无论这个 冗余 的数据存储在何处，都能通过 基地址 + 偏移量 的方式进行访问 

九、继承和组合 

public 继承是一种 is-a 的关系。也就是说每个派生类对象都是一个基类对象。 
而 组合 是一种 has-a 的关系。假设 B 组合了 A,每个 B对象中都有一个 A对象。

举个例子: 轿车和奔驰就构成 is-a 的关系，所以可以使用继承。 

// 车类
class Car
{
protected:
	string _colour = "黑色"; // 颜色
	string _num = "川A66688"; // 车牌号
};

// 奔驰
class Benz : public Car
{
public:
	void Drive()
	{
		cout << "好开-操控" << endl;
	}
};

再举个例子:汽车和轮胎之间就是 has-a 的关系，它们之间则适合使用组合。 

// 轮胎
class Tire {
protected:
	string _brand = "Michelin"; // 品牌
	size_t _size = 17; // 尺寸

};

// 汽车
class Car {
protected:
	string _colour = "黑色"; // 颜色
	string _num = "川A66688"; // 车牌号
	Tire _t; // 轮胎
};

 实际项目中，更推荐使用 组合 的方式，这样可以做到 解耦，避免因父类的改动而直接影响到子类

  • 公有继承：is-a —> 高耦合，可以直接使用父类成员
  • 组合：has-a —> 低耦合，可以间接使用父类成员

十、继承的总结和反思 

 1. 很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题。


2. 多继承可以认为是C++的缺陷之一，很多后来的面向对象语言都没有多继承，如Java。

十一、共勉 

 以下就是我对 【C++】继承 的理解，如果有不懂和发现问题的小伙伴，请在评论区说出来哦，同时我还会继续更新对 【C++】多态 的理解，请持续关注我哦！！！    

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1922149.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

[leetcode]minimum-cost-to-reach-destination-in-time 规定时间内到达终点的最小费用

[leetcode]minimum-cost-to-reach-destination-in-time 规定时间内到达终点的最小费用

. - 力扣&#xff08;LeetCode&#xff09; class Solution { private:// 极大值static constexpr int INFTY INT_MAX / 2;public:int minCost(int maxTime, vector<vector<int>>& edges, vector<int>& passingFees) {int n passingFees.size();ve…
阅读更多...
windows节点加入一个Linux集群组成的kubernetes集群

windows节点加入一个Linux集群组成的kubernetes集群

windows节点加入一个Linux集群组成的kubernetes集群 背景描述一.准备环境搭建二.Windows上docker安装三.配置Windows server2019方法一&#xff1a;自动配置安装方法二&#xff1a;手动配置安装失败处理过程 四.Windows的node加入Linux的kubernetes集群五.配置Linux的master 背…
阅读更多...
在linux中查找 / 目录下的以.jar结尾的文件（find / -name *.jar）

在linux中查找 / 目录下的以.jar结尾的文件（find / -name *.jar）

文章目录 1、查找 / 目录下的以.jar结尾的文件 1、查找 / 目录下的以.jar结尾的文件 [rootiZuf6332h890vozldoxcprZ ~]# find / -name *.jar /etc/java/java-1.8.0-openjdk/java-1.8.0-openjdk-1.8.0.342.b07-1.el9_0.x86_64/lib/security/policy/limited/US_export_policy.ja…
阅读更多...
初学SpringMVC之过滤器解决乱码

初学SpringMVC之过滤器解决乱码

写个 login.jsp 页面 提交的 method 一般为 post&#xff08;写 get 不安全&#xff0c;地址栏上会显示&#xff09; action 表示提交后跳转的地址 &#xff08;不直接写控制器里的路径是因为配置 Tomcat 时设置了前缀路径&#xff0c;默认走 http://localhost:8080&#xf…
阅读更多...
Linux ---gcc

Linux ---gcc

c语言的链接类型&#xff1a; 动态链接&#xff1a; ll /lib64/libc-2.17.so 静态链接&#xff1a; ll /lib64/libc.a glibc-static安装-CSDN博客https://blog.csdn.net/itas109/article/details/104226783在Linux中下载c语言的静态库。 gcc test.c -o test.s -static 以…
阅读更多...
代码随想录二刷7.22|977.有序数组的平方

代码随想录二刷7.22|977.有序数组的平方

暴力解法&#xff1a; ——如果想暴力解决这个问题的话&#xff0c;可以像题目那样&#xff0c;先将每一个元素平方&#xff0c;然后再排序 双指针&#xff1a; ——从题目中找到的信息&#xff1a;这是一个非递减顺序的整数数组&#xff0c;从例子中&#xff0c;可以容易看…
阅读更多...
搭建NEMU与QEMU的DiffTest环境（Socket方式）

搭建NEMU与QEMU的DiffTest环境（Socket方式）

搭建NEMU与QEMU的DiffTest环境&#xff08;Socket方式&#xff09; 1 简述2 编译NEMU2.1 配置2.2 修改NEMU/scripts/build.mk2.3 修改isa_difftest_checkregs函数2.4 修改isa_pmp_check_permission函数2.5 编译 3 编译qemu-socket-difftest3.1 修改NEMU/scripts/isa.mk3.2 修改…
阅读更多...
数据结构之单链表在不带标准头的情况下C，C#，C++分别怎么实现？

数据结构之单链表在不带标准头的情况下C，C#，C++分别怎么实现？

文章目录 单链表的概念单链表的操作单链表不带标准头结点示例C语言实现C#实现C实现 数据结构是计算机科学中非常重要的一部分&#xff0c;它帮助我们理解和操作数据。单链表是数据结构中的一种基本类型&#xff0c;它由一系列节点组成&#xff0c;每个节点包含数据域和指向列表…
阅读更多...
强化学习编程实践-4-基于蒙特卡洛的方法

强化学习编程实践-4-基于蒙特卡洛的方法

第3章给出了学习算法的基本思路&#xff1a;策略评估和策略改善。其中策略评估用到了以下的公式&#xff08;4.1&#xff09;&#xff1a; 策略改善则用了最简单的贪婪策略&#xff08;4.2&#xff09;&#xff1a; 为什么要用蒙特卡洛算法&#xff1f;先看公式4.1和4.2&#x…
阅读更多...
图鸟UI框架在uni-app多端应用开发中的实践与应用

图鸟UI框架在uni-app多端应用开发中的实践与应用

摘要&#xff1a; 随着移动互联网的蓬勃发展&#xff0c;跨平台应用开发已成为行业趋势。本文将探讨图鸟UI框架如何在uni-app开发环境下助力开发者高效构建多端应用&#xff0c;并通过具体案例展示其在实际项目中的应用效果。 一、引言 在移动应用开发领域&#xff0c;跨平台…
阅读更多...
【错题集-编程题】栈和排序（栈 + 贪心）

【错题集-编程题】栈和排序（栈 + 贪心）

牛客对于题目连接&#xff1a;栈和排序_牛客题霸_牛客网 (nowcoder.com) 一、分析题目 每次尽可能的先让当前需要的最大值弹出去。 二、代码 // 修改后的代码 class Solution { public:/*** 代码中的类名、方法名、参数名已经指定&#xff0c;请勿修改&#xff0c;直接返回方…
阅读更多...
百度文心4.0 Turbo开放，领跑国内AI大模型赛道！

百度文心4.0 Turbo开放，领跑国内AI大模型赛道！

百度文心4.0 Turbo开放&#xff0c;领跑国内AI大模型赛道&#xff01; 前言 文心一言大模型 就在7月5日&#xff0c;在2024世界人工智能大会 (WAIC) 上&#xff0c;百度副总裁谢广军宣布文心大模型4.0 Turbo正式向企业客户全面开放&#xff01;这一举动直接引发了业界的关注。那…
阅读更多...
uniapp微信小程序 TypeError: $refs[ref].push is not a function

uniapp微信小程序 TypeError: $refs[ref].push is not a function

我的写法 this.$refs.addPopup.open();报错 打印出来是这样的 解决 参考未整理 原因 在当前页面使用的v-for循环 并且循环体内也有组件使用了ref&#xff08;而我没有把每个ref做区别命名&#xff09; 这样就导致了我有很多同名的ref&#xff0c;然后就报错了 解决办法&a…
阅读更多...
上海-三轮摩托车—D证科目四 错题记录

上海-三轮摩托车—D证科目四 错题记录

目录 1.安全驾驶题 2.道路图标题 3.天气类情景题 4.事故处理类题 上海-三轮摩托车—D证科目一 错题记录： 1.安全驾驶题
阅读更多...
阐述 C 语言中的浮点数精度问题？

阐述 C 语言中的浮点数精度问题？

&#x1f345;关注博主&#x1f397;️ 带你畅游技术世界&#xff0c;不错过每一次成长机会&#xff01; &#x1f4d9;C 语言百万年薪修炼课程 【https://dwz.mosong.cc/cyyjc】通俗易懂&#xff0c;深入浅出&#xff0c;匠心打磨&#xff0c;死磕细节&#xff0c;6年迭代&…
阅读更多...
tableau回归分析与时间序列分析 - 17

tableau回归分析与时间序列分析 - 17

回归分析与时间序列分析 1. 回归分析1.1 线性回归绘制1.1.1 导入数据1.1.2 基本绘制1.1.3 趋势线显示-方法一1.1.4 趋势线显示-方法二1.1.5 趋势线显示-方法三1.1.6 添加区域注释 1.2 指数回归绘制1.2.1 创建字段1.2.2 异常区分1.2.3 创建参数1.2.4 异常区分字段修改1.2.5 显示…
阅读更多...
MySQL学习笔记 下

MySQL学习笔记 下

MySQL学习笔记&#xff08;需接上篇&#xff09; 1. 通配符 用于替换字符串中的一个或多个字符&#xff1b;通配符常与LIKE关键字一起使用&#xff0c;用于搜索字段中的指定模式&#xff1b; 2. 别名 用于为表或表中的列提供临时名称&#xff1b; 别名用于为表或表中的字段…
阅读更多...
【安卓学习】状态开关按钮

【安卓学习】状态开关按钮

Switch 状态开关按钮&#xff08;Switch&#xff09;也是由 Button 派生出来的&#xff0c;所以在本质上它也算是一个比较高级的按钮&#xff0c;用户可以来回拖动“拇指”控制该按钮的开启与关闭或者只需轻按&#xff0c;就像选择复选框一样来开启该组件。 基本语法 <Sw…
阅读更多...
外贸淡季如何应对？九大技巧告诉你！

外贸淡季如何应对？九大技巧告诉你！

许多外贸人都知道&#xff0c;7-9月是外贸的淡季&#xff0c;主要是因为西方国家很多公司会放假&#xff0c;或者轮流放。欧美人扎堆度假去了&#xff0c;欧洲城市街头的人数会减少很多。导致很多订单暂缓。所以这三个月经常被称为是外贸“淡季”。 大体上讲&#xff0c;外贸的…
阅读更多...
警钟！电池储能安全事故频发！物联网技术如何加强储能安全排查？

警钟！电池储能安全事故频发！物联网技术如何加强储能安全排查？

在新能源时代背景下&#xff0c;储能系统作为能源转型的关键支撑技术&#xff0c;其安全问题日益凸显&#xff0c;尤其是近期海外电池项目连续发生的事故&#xff0c;为全球储能行业敲响了警钟。面对这一挑战&#xff0c;物联网技术以其强大的数据采集、智能分析与远程监控能力…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023