析构函数的调用

同样定义类型的析构函数，调用顺序和构造函数相反，先构造的后析构，下面是四种定义类型

1 在函数中定义对象
（1）自定义函数中定义对象，当函数调用结束时自动调用析构函数

#include<iostream>
using namespace std;

class Node
{
    public:
        Node(char);
        ~Node();

    private:
        char n;
};

Node::Node(char a)
{
    n = a;
    cout << "这是" << n << "的构造函数" << endl;
}

Node::~Node()
{
    cout << "这是" << n << "的析构函数" << endl;
}

void display()
{
    Node a('a');

    cout << "这里display函数结束" << endl;
}

int main()
{
    display();

    cout << "这里回到主函数" << endl;
    return 0;
}

结果

这是a的构造函数
这里display函数结束
这是a的析构函数
这里回到主函数

（2）{}中定义对象，出来后也会调用析构函数

#include<iostream>
using namespace std;

class Node
{
    public:
        Node(char);
        ~Node();

    private:
        char n;
};

Node::Node(char a)
{
    n = a;
    cout << "这是" << n << "的构造函数" << endl;
}

Node::~Node()
{
    cout << "这是" << n << "的析构函数" << endl;
}

int main()
{
    {
        Node a('a');
    }
    cout << "这里出{}" << endl;

    return 0;
}

结果

这是a的构造函数
这是a的析构函数
这里出{}

2 主函数中定义对象
主函数定义对象，遇到return 0调用析构函数，没return 0，主函数结束也会调用。

#include<iostream>
using namespace std;

class Node
{
    public:
        Node(char);
        ~Node();

    private:
        char n;
};

Node::Node(char a)
{
    n = a;
    cout << "这是" << n << "的构造函数" << endl;
}

Node::~Node()
{
    cout << "这是" << n << "的析构函数" << endl;
}

int main()
{
    Node a('a');

    return 0;
}

结果

这是a的构造函数
这是a的析构函数

3 定义了全局对象
主函数全部运行结束(包括析构函数)，才会调用全局对象的析构函数

#include<iostream>
using namespace std;

class Node
{
    public:
        Node(char);
        ~Node();

    private:
        char n;
};

Node::Node(char a)
{
    n = a;
    cout << "这是" << n << "的构造函数" << endl;
}

Node::~Node()
{
    cout << "这是" << n << "的析构函数" << endl;
}

Node a('a');  //全局对象

int main()
{
    return 0;
}

结果

这是a的构造函数
这是a的析构函数

4 用new定义对象
用new定义对象，碰到delete才会调用析构函数，没有delete不调用

#include<iostream>
using namespace std;

class Node
{
    public:
        Node(char);
        ~Node();

    private:
        char n;
};

Node::Node(char a)
{
    n = a;
    cout << "这是" << n << "的构造函数" << endl;
}

Node::~Node()
{
    cout << "这是" << n << "的析构函数" << endl;
}

int main()
{
    cout << "定义new p,q, 但不delete p" << endl;

    Node *p = new Node('p'), *q = new Node('q');

    delete q;
    return 0;
}

结果

定义new p,q, 但不delete p
这是p的构造函数
这是q的构造函数
这是q的析构函数

大混合，根据上面的分析下面的运行结果，就能大致明白析构函数的调用顺序

#include<iostream>
using namespace std;

class Node
{
    public:
        Node(char);
        ~Node();

    private:
        char n;
};

Node::Node(char a)
{
    n = a;
    cout << "这是" << n << "的构造函数" << endl;
}

Node::~Node()
{
    cout << "这是" << n << "的析构函数" << endl;
}

Node *e = new Node('e'), f('f');

int main()
{
    delete e;

    Node a('a'), b('b');
    Node *c = new Node('c'), *d = new Node('d');

    if (1)
    {
        Node g('g');
    }

    delete c;

    return 0;
}

结果

这是e的构造函数
这是f的构造函数
这是e的析构函数
这是a的构造函数
这是b的构造函数
这是c的构造函数
这是d的构造函数
这是g的构造函数
这是g的析构函数
这是c的析构函数
这是b的析构函数
这是a的析构函数
这是f的析构函数