学步园

//***** 构造函数 *****
class rectangel
{
public:
    rectangel ()  // 默认的构造函数，如果没有自定义默认构造函数，系统就会自动生成，如果自定义构造函数，则系统就不会再生成默认构造函数
    {
        std::cout << "默认的构造函数" << std::endl;
    }
    rectangel (int l, int w)  // 这是带参数的构造函数，构造函数都是没有返回值，并且和该类同名
    {
        length = l;
        width = w;
    }
    int area()  // 这是另一种形式的内联函数，把声明和定义写在一起的也是内联函数
    {
        return length * width;
    }
private:
    int length;
    int width;
};

//***** 析构函数 *****
class Human
{
public:
    Human();  // 构造函数
    ~Human();  // 析构函数

    /*
    析构函数刚好和构造函数相反，构造函数用来构造函对象，而析构函数用来释放对象
    注意：
    析构函数在类中，只能有一个，并且析构函数不能有参数，它不像构造函数那样不但可以拥有多个，而且可以有参数
    析构函数和构造函数一样，没有返回值
    析构函数由系统自动调用，绝对不能由程序员调用
    */
};

Human::Human()  //***** 类中声明，类外定义 *****
{
    std::cout << "构造函数..." << std::endl;
}

Human::~Human()  //***** 类中声明，类外定义 *****
{
    std::cout << "析构函数..." << std::endl;
}

基类的构造顺序和析构顺序：

// 基类的构造顺序和析构顺序
#include <iostream>

class A
{
public:
    A()
    {
        std::cout << "构造A" << std::endl;
    }
    ~A()
    {
        std::cout << "析构A" << std::endl;
    }
};

class B
{
public:
    B()
    {
        std::cout << "构造B" << std::endl;
    }
    ~B()
    {
        std::cout << "析构B" << std::endl;
    }
};

class C
{
public:
    C()
    {
        std::cout << "构造C" << std::endl;
    }
    ~C()
    {
        std::cout << "析构C" << std::endl;
    }
};

class D:public A,public B, public C
{
    // 基类的构造顺序会按照A->B->C来构造
    // 基类的析构顺序会按照C->B->A来析构
};


int main()
{
    D d;
    return 0;
}