【C++】【学习笔记】【017】继承机制中的构造器和析构器

拼搏现实的明天。 2022-08-13 18:46 120阅读 0赞

1、基类必须在子类之前初始化。如：对于基类Animal和子类Pig，如果基类有个构造器Animal()，它将在创造Pig类型的对象时最先被调用，如果Pig类也有一个构造器Pig()，它将在第二个被调用。

2、如果构造器带着输入参数，情况就比较复杂了；如下所示：

// 动物基类
    class Animal
    {
    public:
        std::string name; 
        Animal(std::string theName); 
    }; 
    
    Animal::Animal(std::string theName)
    {
        name = theName;
    }
    
    // 猪子类
    class Pig : public Animal
    {
    public:
        Pig(std::string theName);
        void climb();
    };
    
    Pig::Pig(std::string theName) : Animal(theName)
    {
    }

a、当调用Pig()构造器时（以theName作为输入参数），Animal()构造器也将被调用（theName输入参数将传递给它）；

b、当我们调用Pig pig("Little pig");将把字符串"Little pig"传递给Pig()和Animal()，赋值动作将实际发生在Animal()方法里。

样例：

#include <iostream>
    #include <string>
    
    // 动物基类
    class Animal
    {
    public:
        // 基类属性
        std::string mouth;
        std::string name;
    
        // 构造函数
        Animal(std::string theName);
    
        // 基类方法
        void eat();
        void sleep();
        void drool(); // 流口水
    };
    
    Animal::Animal(std::string theName)
    {
        name = theName;
    }
    
    void Animal::eat()
    {
        std::cout << "Animal: I'm eating!" << std::endl;
    }
    
    void Animal::sleep()
    {
        std::cout << "Animal: I'm sleeping!" << std::endl;
    }
    
    void Animal::drool()
    {
        std::cout << "Animal: I'm drooling!" << std::endl;
    }
    
    // 猪子类
    class Pig : public Animal
    {
    public:
        Pig(std::string theName);
        void climb();
    };
    
    Pig::Pig(std::string theName) : Animal(theName)
    {
    
    }
    
    void Pig::climb()
    {
        std::cout << "Pig: I'm climbing!" << std::endl;
    }
    
    // 乌龟子类
    class Turtle : public Animal
    {
    public:
        Turtle(std::string theName);
        void swim();
    };
    
    Turtle::Turtle(std::string theName) : Animal(theName)
    {
    }
    
    void Turtle::swim()
    {
        std::cout << "Turtle: I'm swimming!" << std::endl;
    }
    
    
    int main()
    {
    
        Pig pig("Little pig");
        Turtle turtle("Little turtle");
    
        std::cout << pig.name << std::endl << turtle.name << std::endl;
    
        pig.eat();
        turtle.eat();
    
        pig.climb();
        turtle.swim();
    
        return 0;
    }

输出：
    Little pig
    Little turtle
    Animal: I'm eating!
    Animal: I'm eating!
    Pig: I'm climbing!
    Turtle: I'm swimming!

1、在销毁某个对象时，基类的析构器也将被自动调用，但这些事情编译器会自动处理；

2、因为析构器不需要输入参数，所以根本用不着使用SuperClassMethod(argument)语法；

3、与构造器的情况相反，基类的析构器将在子类的最后一条语句执行完毕后才被调用；

样例：

#include <iostream>
    #include <string>
    
    class BaseClass
    {
    public:
        BaseClass();
        ~BaseClass();
    
        void doSomething();
    };
    
    BaseClass::BaseClass()
    {
        std::cout << "Into BaseClass constructor.\n";
    }
    
    BaseClass::~BaseClass()
    {
        std::cout << "Into BaseClass destructor.\n";
    }
    
    void BaseClass::doSomething()
    {
        std::cout << "BaseClass::doSomething.\n";
    }
    
    class SubClass : public BaseClass
    {
    public:
        SubClass();
        ~SubClass();
    };
    
    SubClass::SubClass()
    {
        std::cout << "Into SubClass constructor.\n";
    }
    
    SubClass::~SubClass()
    {
        std::cout << "Into SubClass destructor.\n";
    }
    
    int main()
    {
        SubClass subclass;
        subclass.doSomething();
        std::cout << "Over!\n";
        return 0;
    }

输出：
    Into BaseClass constructor.
    Into SubClass constructor.
    BaseClass::doSomething.
    Over!
    Into SubClass destructor.
    Into BaseClass destructor.

样例：