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

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.

样例：