【C++深度探索】继承机制详解（一）

hello hello~ ，这里是大耳朵土土垚~💖💖 ，欢迎大家点赞🥳🥳关注💥💥收藏🌹🌹🌹

💥个人主页：大耳朵土土垚的博客

💥 所属专栏：C++入门至进阶

这里将会不定期更新有关C++的内容，希望大家多多点赞关注收藏💖💖

目录

• 1.继承的概念
• 2.继承定义
• • 2.1定义格式
  • 2.2访问限定符
  • 2.3继承方式
  • 3.基类和派生类对象赋值转换
  • 4.继承中的重定义(隐藏)
  • 5.派生类的默认成员函数
  • • ✨构造函数
    • ✨拷贝构造
    • ✨赋值运算符重载
    • ✨析构函数
    • 6.结语

      1.继承的概念

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

      2.继承定义

      2.1定义格式

      下面我们看到Person是父类，也称作基类。Student是子类，也称作派生类。

      //基类或父类
      class Person
      {
      public:
      	void Print()
      	{
      		cout 
      protected:
      	int _stuid; // 学号
      	int _major;	//专业
      };
      
      public:
          // 公有成员
      protected:
          // 保护成员
      private:
          // 私有成员
      };
      class Derived : public Base {
          // 公有继承
      };
      
      public:
          // 公有成员
      protected:
          // 保护成员
      private:
          // 私有成员
      };
      class Derived : protected Base {
          // 保护继承
      };
      
      public:
          // 公有成员
      protected:
          // 保护成员
      private:
          // 私有成员
      };
      class Derived : private Base {
          // 私有继承
      };
      
      public:
      	void Print()
      	{
      		cout 
      public:
      	void sPrint()
      	{
      		Person::Print();	//可以使用父类的公有成员
      	}
      protected:
      	int _stuid; // 学号
      	string _sname = _name;//可以访问父类的保护成员_name
      	string _stele = _tele; //不可以访问父类的私有成员_tele
      };
      
      protected:
      	string _name; // 姓名
      	string _sex;  //性别
      	int _age; // 年龄
      };
      //子类
      class Student : public Person
      {
      public:
      	int _No; // 学号
      };
      void Test()
      {
      	Student sobj;
      	// 1.子类对象可以赋值给父类对象/指针/引用
      	Person pobj = sobj;
      	Person* pp = &sobj;
      	Person& rp = sobj;
      	//2.基类对象不能赋值给派生类对象
      	sobj = pobj;//error
      }
      
      protected:
      	string _name = "胡土土"; // 姓名
      	int _num = 1234; // 身份证号
      };
      //子类
      class Student : public Person
      {
      public:
      	void Print()
      	{
      		cout 
      	Student s1;
      	s1.Print();
      };
      
      public:
      	void fun()
      	{
      		cout 
      public:
      	void fun(int i)
      	{
      		A::fun();
      		cout 
      	B b;
      	b.fun(10);
      }
      
      	B b;
      	b.fun();//这里没有给参数
      }
      
      	B b;
      	b.A::fun();//显示调用A中的fun函数
      }
      
      public:
      	Person(const char* name = "tutu")
      		: _name(name)
      	{
      		cout 
      		cout 
      		cout 
      		cout 
      protected:
      	int _num; //学号
      };
      int main()
      {
      	Student s;
      	return 0;
      }
      
      public:
      	Student(const char* name, int num)
      		:Person(name)	//显示调用父类构造函数
      		, _num(num)
      	{}	
      protected:
      	int _num; //学号
      };
      int main()
      {
      	Student s("tutu", 111);;
      	return 0;
      }
      
      public:
      	//构造函数
      	Student(const char* name, int num)
      		:Person(name)	//显示调用父类构造函数
      		, _num(num)
      	{}	
      	//拷贝构造
      	Student(const Student& st)
      		:Person(st)	//利用前面学习的基类与派生类的赋值转换
      		,_num(st._num)
      	{}
      protected:
      	int _num; //学号
      };
      
      	~Person();//这样写是错误的
      }
      
      	Person::~Person();
      	cout