基本应用

  1. #include <iostream>
  2. #include <string>
  3. using namespace std;
  5. class People{
  7.     private:int age;
  8.     private:string name;
  10.     public:People(string name,int age){
  11.             this->name = name;
  12.             this->age = age; //this是一个指针，指向当前的对象
  13.     }
  15.     public: void println(){
  16.         cout << "姓名为" << name << ",年纪为：" << age << endl;
  17.     }
  18. };
  20. class Student:public People{//设置继承方式为public
  21.     public:Student(string name,int age):People(name,age){
  22.         //继承父类的构造函数
  23.     }
  24. };
  26. int main()
  27. {
  28.     Student stu("小明",12);
  29.     stu.println();
  31.     return 0;
  32. }

继承方式

  • 公共继承
  • 保护继承

  • 私有继承

  • 公共继承 ```cpp class People{ };

class Student:public People{ //保留父类所有成员的访问权限 };

  2. - 保护继承
  3. ```cpp
  4. class People{
  5. };
  7. class Student:protected People{
  8.     //保留父类protected及private的成员的访问权限
  9.     //将父类所有public的成员修改为protected
  10. };
  • 私有继承 ```cpp class People{ };

class Student:private People{ //所有父类的成员都修改为private };

  1. <a name="q53GX"></a>
  2. ### 
  3. <a name="eVEOa"></a>
  4. ### 访问与父类同名的变量及方法
  5. ```java
  6. #include <iostream>
  7. #include <string>
  8. using namespace std;
  10. class People{
  11.     public:void say(){
  12.         cout << "People say" << endl;
  13.     }
  15.     public:static void go(){
  16.         cout << "People go" << endl;
  17.     }
  18. };
  20. class Student:public People{
  21.     public:void say(){
  22.         cout << "Student say" << endl;
  23.     }
  25.     public:static void go(){
  26.         cout << "Student go" << endl;
  27.     }
  28. };
  30. int main()
  31. {
  32.     Student stu;
  33.     stu.say();//调用Student中的成员函数say
  34.     stu.People::say();//访问父类中的成员函数say
  36.     Student::go();//调用Student中的静态函数go
  37.     Student::People::go();//访问父类中的静态函数go
  39.     return 0;
  40. }

Student say People say Student go People go

一个类继承多个类

  1. class People{
  2. };
  4. class Animal{
  5. };
  7. class Student:public People,public Animal{
  8. };

注：C++开发中不建议用多继承

多态及虚函数

多态的概念和Java是一样的，即允许父类和子类进行类型转换

  1. #include <iostream>
  2. #include <string>
  3. using namespace std;
  5. class Animal{
  6.     public:
  7.         //virtual为声明speak为虚函数
  8.         virtual void speak(){
  9.             cout << "动物在说话" << endl;
  10.         };
  11. };
  13. class Dog:public Animal{
  14.     public:
  15.         void speak(){
  16.             cout << "狗在说话" << endl;
  17.         };
  18. };
  20. class Cat:public Animal{
  21.     public:
  22.         void speak(){
  23.             cout << "猫在说话" << endl;
  24.         };
  25. };
  27. void doSpeak(Animal& animal){
  28.     animal.speak();
  29. }
  31. int main()
  32. {
  33.     Cat cat;
  34.     Dog dog;
  36.     doSpeak(cat);
  37.     doSpeak(dog);
  39.     return 0;
  40. }

注：

  • 如果不声明speak是虚函数（virtual），则执行doSpeak时，无论传参是Cat还是Dog，输出结果都会是Animal中的“动物在说话”
  • 但在声明speak是虚函数以后，就会发现，在这种场景下，实际上父类的speak函数的实现是没有意义，那么这种场景下，可以把父类的speak修改为纯虚函数，即抽象函数。

纯虚函数及抽象类

如果一个类中有个纯虚函数，这个类就叫抽象类，其概念和特点其实和Java是一样的

  • 无法实例化抽象类
  • 子类必须重写抽象类中的纯虚函数，否则也属于抽象类 ```c

    include

    include

    using namespace std;

class Animal{ public: virtual void speak();//也可以写成 virtual void speak() = 0; };

class Dog:public Animal{ public: void speak(){ cout << “狗在说话” << endl; }; };

class Cat:public Animal{ public: void speak(){ cout << “猫在说话” << endl; }; };

void speak(Animal& animal){ animal.speak(); }

int main() { Cat cat; Dog dog;

  1. speak(cat);
  2. speak(dog);
  4. return 0;

}

  1. <a name="iiAiK"></a>
  2. ### 虚析构函数和纯虚析构函数
  3. **场景：**在多态使用时，如果子类有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构函数，如果子类没有堆区数据，是可以无写虚析函数的
  5. **解决方案：**将父类的析构函数改为虚析构或纯虚析构。<br />虚析构和纯虚析构的共性：
  7. - 可以解决父类指针释放子类对象
  8. - 都需要有具体的函数实现
  10. 虚析构或纯虚析构的区别
  12. - 纯虚析构由于是抽象类，无法实例化。
  14. <a name="SO1sD"></a>
  15. #### 虚析构函数
  16. ```c
  17. #include <iostream>
  18. #include <string>
  19. using namespace std;
  21. class Animal{
  22.     public:
  23.         virtual void speak();
  24.         virtual ~Animal(){};//虚析构函数
  25. };
  27. class Dog:public Animal{
  29.     string* name;
  31.     public:
  32.         Dog(string name):Animal()
  33.         {
  34.             this->name = new string(name);
  35.         }
  37.         void speak(){
  38.             cout << "狗在说话" << endl;
  39.         };
  41.         ~Dog(){
  42.             if (name != NULL)
  43.             {
  44.                 delete name;
  45.             }
  46.         }
  47. };
  49. void speak(Animal& animal){
  50.     animal.speak();
  51. }
  53. int main()
  54. {
  55.     Dog dog("哈密瓜");
  56.     speak(dog);
  58.     return 0;
  59. }

纯虚析构函数

  1. #include <iostream>
  2. #include <string>
  3. using namespace std;
  5. class Animal{
  6.     public:
  7.         virtual void speak();
  8.         virtual ~Animal() = 0;//纯虚析构函数
  9. };
  11. Animal::~Animal(){}; //如果是纯虚析构函数，则这一行不能少，否则编译无法通过，因为如果少了这一行，编译器会认为基类没有了析构函数
  13. class Dog:public Animal{
  15.     string* name;
  17.     public:
  18.         Dog(string name):Animal()
  19.         {
  20.             this->name = new string(name);
  21.         }
  23.         void speak(){
  24.             cout << "狗在说话" << endl;
  25.         };
  27.         ~Dog(){
  28.             if (name != NULL)
  29.             {
  30.                 delete name;
  31.             }
  32.         }
  33. };
  35. void speak(Animal& animal){
  36.     animal.speak();
  37. }
  39. int main()
  40. {
  41.     Dog dog("哈密瓜");
  42.     speak(dog);
  43.     return 0;
  44. }