构造函数和析构函数

构造函数和析构函数在类中的调用顺序：

1）构造函数：

定义一个对象时先调用基类的构造函数、然后调用派生类的构造函数。

1）析构函数：

析构与构造的过程恰好相反：先调用派生类的析构函数、然后调用基类的析构函数。

注意：由于vs2013无法显示输出析构函数的内容，所以采用输出到文本中的方式。

#include<iostream>
#include <fstream>
using namespace std;

fstream fout("D:\\Downloads\\destructor.txt", ios::app);
class Base {
public:
    Base(int c) { fout << "基类带参构造函数" << c << endl; }
    ~Base() { fout << "基类析构" << endl; }
};
class Derived :public Base {
public:
    Derived(int c) :Base(c) // 显式调用基类构造函数
    {
        fout << "派生类带参构造函数" << c << endl;
    }
    ~Derived() { fout << "派生类析构" << endl; }
};
int main()
{
    int i = 9;
    Derived d1(i);
    system("pause");
    return 0;
}

输出结果：

基类带参构造函数9
派生类带参构造函数9
派生类析构
基类析构

---

#include<iostream>
#include <fstream>
using namespace std;

fstream fout("D:\\Downloads\\destructor.txt", ios::app);
//创建一个汽车类
class Car
{
public:
    //构造函数
    Car(short, int);
    //析构函数
    ~Car();
    void move();
private:
    short speed;
    int num;
};

Car::Car(short s, int n)
{
    speed = s;
    num = n;
    fout << "创建第" << num << "辆车，速度是" << speed << " 米/秒" << endl;
}
Car::~Car()
{
    fout << "销毁掉第 " << num << "辆车" << endl;
}
void Car::move()
{
    fout << "第 " << num << "辆车速度是" << speed << endl;
}
//主函数
void main()
{
    //先创建第car1对象，再创建car2对象
    Car car1(10, 1), car2(20, 2);
    car1.move();
    car2.move();
}

输出结果：

创建第1辆车，速度是10 米/秒
创建第2辆车，速度是20 米/秒
第 1辆车速度是10
第 2辆车速度是20
销毁掉第 2辆车
销毁掉第 1辆车

解析：

在主函数中是首先创建了Car类的car1对象，后创建了car2对象，所以在执行构造函数的顺序上，是先执行car1对象的构造函数，后执行car2对象的构造函数。而在主函数执行结束，要调用析构函数的时候，根据开始说的法则，则会先执行car2类的析构函数，后执行car1类的析构函数。这就是“使用构造函数创建对象的顺序与使用析构函数释放对象的顺序相反”这条法则的一个很好的体现。

---

#include <iostream>
using namespace std;
class A{
public:
       A(){cout<<"Construct a"<<endl;p();}
       virtual void p(){cout<<"A"<<endl;}
       ~A(){cout<<"Destruct a"<<endl;p();}   
};
class B : public A{
public:
       B(){cout<<"Construct b"<<endl;p();}
       void p(){cout<<"B"<<endl;}
       ~B(){cout<<"Destruct b"<<endl;p();}    
};
int main()
{
    A *a=new B();
    delete a;
    getchar();
    return 0;
}

打印的结果是：
Construct a
A
Construct b
B
Destruct a
A

• 这是一段极易出错的程序，如果用的话 出现的就是先析构 B类 再析构A类 

 B *a=new B();

打印的结果是：
Construct a 
A 
Construct b 
B 
Destruct b 
B 
Destruct a 
A 

A *a = new B;
虽然指针a指向B类型，但指针a的类型是A。
delete a时将调用类型A的析构函数；
因为：如果A的析构函数是虚函数，则：
delete a时调用类型A的析构函数步骤如下:
1,到虚函数映射表中查找A的实际析构函数；
2,发现被实例化为B的析构函数；
3,调用B的析构函数；
4,调用A的析构函数---如果A的析构不是纯虚函数的话。