#include <iostream>
#include <vector>
using namespace std;
class Obj
{
public:
 Obj(void){cout<<"Obj(void)"<<" "<<countOne<<endl;countOne++;}
 Obj(int x){cout<<"Obj(int x)"<<" "<<countThree++<<endl;}
 Obj(const Obj &b) {cout<<"复制构造函数："<<endl;}
 ~Obj(void){cout<<"Destroy"<<" "<<countTwo++<<endl;}
 void GetCount(int x){ countOne = x;}
private:
 static int countOne;
 static int countTwo;
 static int countThree;
 static int countFour;
};
int Obj::countOne(0);
int Obj::countTwo(0);
int Obj::countThree(0);
int main (void)
{
 vector<Obj> obj(10);
 vector<Obj> obj2(10,0);

 return 0;
}

结果如下：

//执行了构造函数2次，20次复制构造函数，析构函数22次

//我想提出的问题是上图中第1-3行

//在第一次使用vector和第二次使用vector之间为什么执行一次析构函数

//[补充]这是老师的回答

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

class Obj
{
public:
Obj(void){cout<<"Obj(void)"<<" "<<countOne<<endl;countOne++;}
Obj(int x){cout<<"Obj(int x)"<<" "<<countThree++<<endl;}
~Obj(void){cout<<"Destroy"<<" "<<countTwo++<<endl;}
void GetCount(int x){ countOne = x;}
private:
static int countOne;
static int countTwo;
static int countThree;
};

int Obj::countOne(0);
int Obj::countTwo(0);
int Obj::countThree(0);

int main (void)
{

//关于vector的说明以及其构造函数与析构函数
//以下调用是调用的vector<Obj>模板类的构造函数 vector(size_type n, const Obj& v = Obj()); 
//在vector的构造函数调用过程中使用了默认形参const Obj& v= Obj()，会自动调用一次Obj的默认构造函数，
//然后vector类的构造函数内部中会自己调用Obj的拷贝构造函数创建10个拷贝，离开vector的构造函数后会自动调用Obj的析构函数销毁默认形参v
vector<Obj> obj(10);
//以下调用也是调用了vector<Obj>模板类的构造函数 vector(size_type n, const Obj& v = Obj());
//不同的是第二个参数传递的本应是一个Obj类型的引用或不设置，而这里却使用了整型参数，但这不是错误，因为做使用参数传递时，系统会自动
//寻找是匹配的参数，如果没有匹配的参数，还会用参数去匹配类类型的形参的构造函数参数，这里就是这种情况，这里是使用了Obj类的构造函数Obj(int x)
//同样，在vector类的构造函数内部中会自己调用Obj的拷贝构造函数创建10个拷贝，离开vector的构造函数后会自动调用Obj的析构函数销毁自动构造的形参
vector<Obj> obj2(10,0);

return 0;
//在离开main函数时会调用vector的析构函数，它会自动调用其内嵌对象obj 2*10（两个vector对象，里面各有10个obj对象）次。
//所以其结果是两次构造函数（一次Obj(void)，一次Obj(int x)，另外20构造函数是调用Obj类的默认拷贝构造函数Obj(const Obj&)，所有没有输出），22次析构函数。
}