【C++高阶】C++继承学习手册：全面解析继承的各个方面

📝个人主页🌹：Eternity._

⏩收录专栏⏪：C++ “ 登神长阶 ”

🤡往期回顾🤡：模板进阶

🌹🌹期待您的关注 🌹🌹

继承

• 📖1. 继承的概念及定义
• • ⛰️继承的概念
  • 🌄继承定义
  • 📙2. 基类和派生类对象赋值转换
  • 📕3. 继承中的作用域
  • • 🎩成员变量隐藏
    • 🎈成员函数隐藏
    • 📚4. 派生类的默认成员函数
    • • 🧩默认成员函数
      • 🧩派生类默认函数特征
      • 📒5. 友元与静态成员变量
      • • 🍂友元
        • 🍁静态成员
        • 📜6. 多继承
        • • 🌞菱形继承
          • 🌙虚拟继承
          • ⭐虚拟继承解决数据冗余和二义性的原理
          • 🔥7. 总结

            ---

            前言： 当我们踏上C++编程的旅程时，继承无疑是一个无法回避且至关重要的概念。作为面向对象编程的三大特性之一，继承不仅让我们能够创建出层次清晰、结构合理的代码，还极大地提高了代码的可重用性和可维护性。在本文中，我们将一起深入探讨C++继承的奥秘，从基础概念到高级应用，逐步揭开它的神秘面纱

            C++继承允许我们定义一个基类（或称为父类），并从这个基类中派生出新的类（称为派生类、子类）。派生类会继承基类的成员和成员函数，同时还可以添加自己的成员和成员函数。这种能力使得我们能够构建出复杂的类层次结构，实现代码的模块化和复用

            在本文的学习中我们不仅仅要了解继承的基本概念。在实际编程中，我们还需要掌握如何正确使用继承、如何避免常见的继承陷阱、以及如何利用继承来优化我们的代码结构。因此，本文将带领大家从多个角度全面学习C++继承，包括继承的语法规则、访问控制、构造函数与析构函数的调用、多重继承与菱形继承等问题

            让我们一起踏上学习C++继承的旅程吧！

            ---

            📖1. 继承的概念及定义

            ⛰️继承的概念

            继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用

            继承代码示例

            class A 
            {
            public:
            	void func()
            	{
            		cout 
            public:
            	// ......
            protected:
            	int _b = 100;
            };
            int main()
            {
            	A a ;
            	B b;
            	a.func();
            	b.func(); // b可以调用A中的成员函数
            	return 0;
            }
            

            hr / h3🌄继承定义/h3 p我们从刚刚的代码示例可以看到A是基类(父类)，B是派生类(子类)/p p定义格式/ppimg src="https://img-blog.csdnimg.cn/direct/95f0ef77c2914e51ab82ff208e553a87.png" //pp注意：在定义继承的时候继承方式可以省略不写，如果不写则是根据基类的定义来决定默认继承方式，但是建议定义时带上继承方式/p pre class="brush:python;toolbar:false"class定义的类默认private继承，struct定义的类默认public继承 /pre hr / p继承关系和访问限定符/ppimg src="https://img-blog.csdnimg.cn/direct/e3f905afe1e74b66aa0af0ef4037b55f.png" //ppimg src="https://img-blog.csdnimg.cn/direct/cdfb1b002c234139a2e5441ac20e03b9.png" //p hr / p继承基类成员访问方式的变化/pp继承方式和访问限定符都有三种，虽然它们组合一共有9中能使用的方法，但是我们最常用的只有红色框里面的两种用法/ppimg src="https://img-blog.csdnimg.cn/direct/46d8bcb8fd4f43f8bc17d98ffb696454.png" //p blockquote p这里我们有以下几点需要注意：/p ulli基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它/lili基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的/lili实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public protected> private
          • 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式
          • 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强

            ---

            📙2. 基类和派生类对象赋值转换

            关于赋值规则这里我们先提两点：

            • 派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去
            • 基类对象不能赋值给派生类对象

              

              ---

              我们在讲C++入门知识的时候讲过，引用类型不同的变量时，会产生一个临时变量，临时变量具有常性，需要const修饰，但是在继承中就不需要const修饰

              代码示例

              int main()
              {
              	int c = 1;
              	double d = 1.1;
              	const int& r = d; // 中间产生了一个临时变量，临时变量具有常性，需要const修饰
              	
              	B b;
              	A a = b; // 子类可以赋值给基类
              	// b = a; // false, 基类不可以赋值给子类
              	
              	A& ra = b; // is-a 的关系中间不会产生临时对象，父子类的赋值兼容规则（切割/切片）
              	return 0;
              }
              

              继承中的对象是is-a 的关系，它们中间并不会产生临时对象，这就是父子类的赋值兼容规则（切割/切片）

              ---

              📕3. 继承中的作用域

              关于作用域的注意事项：

              • 在继承体系中基类和派生类都有独立的作用域。
              • 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）
              • 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏
              • 注意在实际中在继承体系里面最好不要定义同名的成员

                ---

                🎩成员变量隐藏

                当继承的基类与子类有同名的成员变量时，不指定的话，会调用子类的成员变量

                代码示例

                class A 
                {
                protected:
                	int _a = 10;
                };
                class B : public A
                {
                public:
                	void Print()
                	{
                		cout 
                	B b;
                	// 成员变量同名
                	// A 和 B中的 _a 构成隐藏
                	b.Print(); // // _a = 99 , _b = 100; 就近原则
                	return 0;
                }
                
                public:
                	void func()
                	{
                		cout 
                public:
                	// 
                	void func(int b)
                	{
                		cout 
                	B b;
                	// 成员函数同名
                	// A 和 B中的 func() 构成隐藏
                	b.func(); // 打印“func(int b)”
                }
                
                public:
                	A()
                	{}
                	A(int a)
                		:_a(a)
                	{
                		cout 
                		cout 
                		cout 
                			_a = a._a;
                		}
                		return *this;
                	}
                	~A()
                	{
                		cout 
                public:
                	B()
                	{}
                	B(int a, int b)
                		// :_a(a) // _a不是基类成员不能这样初始化
                		:A(a)
                		,_b(b)
                	{
                		cout 
                		cout 
                		cout 
                			// 需要调用A类的 operator=
                			A::operator=(b);
                			_b = b._b;
                		}
                		return *this;
                	}
                	// 析构函数会先析构父类，而有时候先析构父类，子类会出事
                	// 不需要显式调用父类析构
                	~B()
                	{
                		cout 
                	B b1(1, 100);
                	B b2(b1);
                	B b3(2, 200);
                	b1 = b3;
                	return 0;
                }
                
                public:
                	friend void Print(const A& a, const B& b);
                protected:
                	int _a = 10;
                };
                class B : public A
                {
                public:
                	// 
                protected:
                	int _b = 100;
                };
                void Print(const A& a, const B& b)
                {
                	cout 
                	A a;
                	B b;
                	Print(a, b);
                }
                
                public:
                	A()
                	{
                		++_count;
                	}
                	static int _count;
                protected:
                	int _a = 10;
                };
                int A::_count = 0;
                class B : public A
                {
                public:
                	// 
                protected:
                	int _b = 100;
                };
                int main()
                {
                	A a;
                	B b;
                	cout ......};
                class C : public A
                {......};
                class D : public B , public C
                
                protected:
                	int _a = 1;
                };
                class B :public A
                {
                protected:
                	int _b = 2;
                };
                class C :public A
                {
                protected:
                	int _c = 3;
                };
                class D :public B, public A
                {
                protected:
                	int _d = 4;
                };
                
                protected:
                	int _a = 1;
                };
                class B : virtual public A
                {
                protected:
                	int _b = 2;
                };
                class C : virtual public A
                {
                protected:
                	int _c = 3;
                };
                class D : public B, public A
                {
                protected:
                	int _d = 4;
                };