自动析构时是先析构后构造的.
//普通(非模板)类的成员模板
class DebugDelete{
public:
DebugDelete(ostream &s = cerr) :os(s){}
template <typename T>void operator()(T*p)const
{
os << "deleting unique_ptr " <<typeid(T).name() <<endl;
delete p;
}
private:
ostream &os;
};
void demo_general_class_tempalte_member()
{
double *p = new double;
DebugDelete d;
d(p);//d调用DebugDelet::operator()(double*),释放p
int* ip = new int;
//在一个临时DebugDelete 对象上调用operator()(int*)
DebugDelete()(ip);
//实例化DebugDelete::opeartor()<int>(int*)const
unique_ptr<int, DebugDelete>p2(new int, DebugDelete());
//实例化DebugDelete::opeartor()<string>(string*)const
unique_ptr<string, DebugDelete>sp(new string, DebugDelete());
}
这里输出
deleting unique_ptr double
deleting unique_ptr int
deleting unique_ptr class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >
deleting unique_ptr int
可以看到,主动析构的正常进行.
函数结束后自动析构的,先创建了int后创建了string,但是先析构了string
class B
{
public:
virtual ~B(){ cout << "delete B" << endl; }
};
class D :B
{
public:
virtual ~D() override{ cout << "delete D" << endl; }
};
void demo_delete()
{
D d;
}
输出
delete D
delete B
这里构造时是先构造基类,再构造派生类.但是在析构时是先析构了子类,再析构了基类。
知识点补充：C++ 构造与析构的执行顺序
1、代码如下：
class A
{
public:
int _Id;
A():_Id(0)
{
printf("A[%d]\n",_Id);
}
~A()
{
printf("~A[%d]\n",_Id);
}
};
class B
{
public:
A _A;
A* _PA;
B()
{
printf("B\n");
}
~B()
{
printf("~B\n");
delete _PA;
}
};
int main(int argc, char* argv[])
{
{
B b;
b._PA = new A();
b._PA->_Id = 17;
}
return 0;
}
2、执行顺序
A[0]
B
A[0]
~B
~A[17]
~A[0]
3、B是栈上对象，C++保证栈上对象离开作用域，会自动调用析构方法。
4、考虑b中的对象，_A是栈上对象，_PA是指针，堆上对象，对于_PA必须delete，否则资源泄露。而对于_A不需要处理，会自动调用析构方法。可以这样理解，对象b离开作用域，调用析构方法，而b中的_A当然也离开了作用域（皮之不存毛将存焉），调用析构方法。
5、碰到过这样的情况，vs自动生成的析构方法有问题，导致崩溃。手动添加一个析构方法，就可以了。
