IT评测·应用市场-qidao123.com

标题: C++ 面向对象（继承） [打印本页]
作者: 雁过留声    时间: 2025-1-20 09:03
标题: C++ 面向对象（继承）
三、继承

3.1 继承的概念

基于一个已有的类 去重新定义一个新的类，这种方式我们叫做继承

关于继承的称呼
一个类B 继承来自 类 A 我们一样平常称呼
A类：父类 基类
B类: 子类 派生类
B继承自A A 派生了B
示例图的语法
  1. class vehicle // 车类
  2. {
  3.        
  4. }
  6. class car:public vehicle
  7. {
  8.        
  9. }
复制代码
3.2 继承的意义

   1、可以实当代码复用，淘汰重复代码的劳动量
  2、继承是实现多态的须要条件
  3、继承本身就是为了实现多态的，顺便实现了代码复用
  3.3 继承的根本语法

3.3.1 使用方法

3.3.1.1 根本语法

  1. class 子类名称:继承方式 父类名称
  2. {
  3.         子类新增的成员;
  4. }
  6. class B:public A
  7. {
  8. }
复制代码
3.3.1.2 基类对象初始化

在子类的构造函数中，通常须要在初始化列表中显式调用基类的构造函数，以完成对基类成员的初始化。比方：
   在继承时，须要在子类的构造函数的初始化表中
  
  显性的调用父类的构造函数 来完成对父类成员的初始化格式
  
  构造函数名(int val_1 , int val_2): class_A(val_1 , val_2);
  3.3.1.3 派生类中调用基类

在派生类中可以通过以下方式调用基类的成员：
   类外访问:
    对象名.基类名::变量;
    对象名.基类名::函数名(函数的实参表);
  
类内访问:
    基类名::变量;
    基类名::函数名(函数的实参表);
  3.3.2 示例代码一（根本语法1）

  1. #include <iostream>
  2. #include <string>
  4. using namespace std;
  6. class person
  7. {
  8. private:
  10. public:
  11.     string name;
  12.     int id;
  13.     int height;
  15. public:
  16.     person(string name , int id , int height)
  17.         :name(name) , id(id) , height(height)
  18.     {
  19.         cout << "父亲构造函数" << endl;
  20.     }
  21. };
  23. class man : public person
  24. {
  25. private:
  26.     string name;
  27. public:
  28.     man(string name , int  id ,int height)
  29.         : person(name , id ,height)
  30.     {
  32.     }
  33.     void show_data()
  34.     {
  35.         cout << person::name << " " << person::id << " " << this->height << endl ;
  36.     }
  37. };
  41. int main(int argc, char const *argv[])
  42. {
  43.     man m("张三" , 1 , 131);
  44.     m.show_data();
  45.     return 0;
  46. }
复制代码
示例代码1 运行效果如下：

3.3.3 示例代码二（根本语法2）

  1. #include <iostream>
  2. #include <string>
  4. using namespace std;
  6. class person
  7. {
  8. private:
  10. public:
  11.     string name;
  12.     string sex;
  13.     int age;
  15. public :
  16.     person(string name ,int age ,string sex)
  17.         :name(name), age(age) ,sex(sex)
  18.     {
  19.         cout << "父类有参构造" << endl;
  20.     }
  21.     person()
  22.     {
  23.         name = "未设置姓名";
  24.         age = -1;
  25.         sex = "沃尔玛塑料袋";
  26.         cout << "父类无参构造" << endl;
  27.     }
  28.     ~person()
  29.     {
  30.         cout << "我是父类的析构" << endl ;
  31.     }
  33. };
  36. class student:public person
  37. {
  38. private:
  40. public:
  41.     int id;
  43. public:
  44.     student(string name , string sex ,int age ,int id)
  45.         :person(name , age , sex ) , id(id)
  46.     {
  47.         cout << "子类有参构造" << endl;
  48.     }
  50.     student()
  51.     {
  52.         name = "未设置姓名";
  53.         age  = -1;
  54.         sex  = "沃尔玛塑料袋";
  55.         id   = -1 ;
  56.         cout << "子类无参构造" << endl;
  57.     }
  58.     ~student()
  59.     {
  60.         cout <<"我是子类的析构" << endl ;
  61.     }
  62. public:
  63.     void show_data()
  64.     {
  65.         cout << "姓名 " << name << endl;
  66.         cout << "年龄 " << person::age << endl;
  67.         cout << "性别 " << this->sex << endl;
  68.         cout << "学号 " << this->id << endl;
  69.     }
  70. };
  74. int main(int argc, char const *argv[])
  75. {
  76.     student s1 ;
  78.     s1.name ="张三";
  79.     s1.person::age = 10;
  80.     s1.sex = "男";
  81.     s1.id = 10;
  82.     s1.show_data();
  83.    
  84.     return 0;
  85. }
复制代码
示例代码2 运行效果如下：
 

3.4 继承的方式

3.4.1 类中的访问控制权限

类内子类类外public√√√protected√√×private√×× 而在继承中 也有三种访问方式：public、protected、private

访问关系如下图：


3.4.2 示例代码三（继承方式

  1. #include <iostream>
  2. #include <string>
  4. using namespace std;
  6. class person
  7. {
  8. private:
  9.     string name;
  10. private:
  11.     int age;
  12. protected:
  13.     string sex;
  15. public:
  16.     person(string name ,int age ,string sex)
  17.         :name(name) , age(age) , sex(sex)
  18.     {
  19.         cout << "父类有参构造" << endl;
  20.     }
  21.     person()
  22.     {
  23.         name = "未设置姓名";
  24.         age = -1 ;
  25.         sex = "沃尔玛塑料袋";
  26.         cout << "父类无参构造" << endl;
  27.     }
  28.     ~person()
  29.     {
  30.             cout << "我是父类的析构" << endl;
  31.     }
  32. };
  34. class student : private person
  35. {
  36. private:
  38. public:
  39.     int id;
  40. public:
  41.     student(string name ,string sex ,int age ,int id)
  42.         :person(name ,age ,sex),id(id)
  43.     {
  44.         cout <<"子类有参构造" << endl;
  45.     }
  46.     student()
  47.     {
  48.         cout << "子类无参构造" << endl;
  49.     }
  50.     ~student()
  51.     {
  52.         cout<< "我是子类的析构" << endl;
  53.     }
  54. public:
  55.     void show_data()
  56.     {
  58.     }
  60. };
  62. class son : private student
  63. {
  64. private:
  65.   
  66. public:
  67.     son()
  68.     {
  69.         student::id = 10;
  70.     }
  71.     ~son()
  72.     {
  74.     }
  75. };
  78. int main(int argc, char const *argv[])
  79. {
  80.     son s;
  82.     while (1)
  83.     {
  84.         /* code */
  85.     }
  86.    
  87.     return 0;
  88. }
复制代码
示例代码3  运行效果如下：

3.5 继承的底层解释

实际开发中 一样平常继承都接纳 pubilc 继承方式
如果不写继承方式，默认使用的都是 private 方式继承
1、子类中会继承父类中所有成员 ，包括私有成员，只不过在子类中不能直接访问父类私有成员须要父类提供公有的函数来访问父类的私有成员
2、当父子类中出现了同名的函数时，访问来也不会冲突，纵然形参不同，也不构成重载关系 愿意是两个函数不在同一个空间内，如果想访问父类的成员 须要加 类名 :: 来修饰
   类外访问:
    对象名.基类名::变量;
    对象名.基类名::函数名(函数的实参表);
类内访问:
    基类名::变量;
    对象名.基类名::函数名(函数的实参表);
   3.5.1 示例代码四（继承模型）

  1. #include <iostream>
  2. #include <string>
  4. using namespace std;
  6. class person
  7. {
  8. private:
  9.     string name;    // 姓名
  10.     string sex;     // 性别
  11.     int age;        // 年龄
  13. public:
  14.     void set_name(string name)
  15.     {
  16.         this->name = name;
  17.         cout << name << endl;
  18.     }
  19. };
  21. class student:public person
  22. {
  23. private:   
  24. public:
  25.     //1、子类如何访问父类的私有成员
  26.     void set_data(string name , string sex , int age )
  27.     {
  28.         person::set_name(name);
  29.     }
  30.     //2、当父类 和 子类 函数名冲突时 咋办
  31.     void set_name(string name)
  32.     {
  33.         person::set_name(name);
  34.     }
  36.     ~student()
  37.     {
  38.         person();
  39.     }
  40. };
  43. int main(int argc, char const *argv[])
  44. {
  45.     student s1;
  46.     s1.set_name("张三");
  48.     student s2;
  49.     s2.set_data("王五","男",11);
  50.    
  51.     person p1;
  52.     p1.set_name("李四");
  53.     return 0;
  54. }
复制代码
示例代码4 运行效果如下：
 

##拓展 在继承中析构和构造的区别

 #构造

   1、父类的构造函数不会被子类继承
  
  2、须要在子类的构造函数的初始列表中，显性的调用父类函数的构造函数
    完成对父类中继承过来的成员初始化
    
3、如果没有在子类的构造函数初始化列表中调用父类中的构造函数 则使用无参构造
    如果父类没有无参构造 会报错
    
4、构造函数的调用次序是
    先调用父类函数的构造函数
    再调用子类函数的构造函数
  #析构

   1、父类的析构函数不会被子类继承
    
2、不管是否显性调用父类的析构函数，父类的析构函数都会被调用
    完成对父类中继承过来的成员的善后工作
    
3、子类的析构函数中 无需调用父类的析构函数
    
4、析构函数的调用次序是
    先调用子类函数的析构函数
    再调用父类函数的析构函数
  
前情回首： ​​​​​​​
   第一篇
  C++ 面向对象（封装）-CSDN博客
  第二篇
  C++ 面向对象（构造 & 析构函数）-CSDN博客

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 IT评测·应用市场-qidao123.com (https://dis.qidao123.com/) Powered by Discuz! X3.4