避免指针成员重复释放

类中有指针成员时，如何避免重复释放

在下面的代码中，类A保存有1个指针，并且理所当然的在构造函数中分配内存，析构中释放内存，但会发生重复释放的问题。
原因：编译器自动生成如下的拷贝构造(析构函数不影响拷贝操作的自动生成，只会影响移动操作的自动生成)
解决方法1：显式的删除拷贝构造函数，然后使用时传引用

#include <iostream>
using namespace std;
struct A
{A(){cout<<"默认构造"<<endl;p = malloc(1);}//A(const A& that):p(that.p){//    cout<<"拷贝构造"<<endl;//}~A(){free(p);cout<<"析构"<<endl;}void *p;
};
int main(int argc, char *argv[])
{A a;//默认构造 a.p = malloc(1)A b(a);//拷贝构造 b.p = a.p//析构 free(b.p)//析构 free(a.p)return 0;
}

定义了移动构造，就记得析构函数里自己判空

A(A&& that){p = that.p;that.p = nullptr;cout<<"移动"<<endl;
}
~A(){if (p){free(p);cout<<"析构"<<endl;}
}

解决方法2：
拷贝构造和移动构造函数都删除掉，传参的时候用unique_pointer包装一下，因为独占指针是可以移动的。此时指针指向的资源不可移动，指针可以移动

#include <iostream>
#include <memory>using namespace std;struct A
{A(){p = malloc(1);}A(const A& that) = delete;A(A&& that) = delete;~A(){free(p);}void *p;
};void fun(std::unique_ptr<A> x){
}int main(int argc, char *argv[])
{auto a_p = make_unique<A>();fun(move(a_p));return 0;
}

区分

A a1;
A a2 = a1;//拷贝构造
a1 = a2;//拷贝赋值

解决方法3：
实际上只需要删除移动构造，就会默认不生成移动赋值、拷贝构造、拷贝赋值

因为：移动构造和移动赋值相互影响移动操作和拷贝操作相互影响
同理，只需要删除移动赋值，其余3个也就不会生成了
```
A(const A& that) = delete;//拷贝构造
A(A&& that) = delete;//移动构造
A &operator=(A && that) = delete;//移动赋值
A &operator=(const A& that) = delete;//拷贝赋值
```

解决方法4
把该类写在类中，使用智能指针来管理。当然也可以不写在类中

#include <iostream>
#include <memory>
using namespace std;
struct A
{
private:struct A_Imp{A_Imp(){p = malloc(1);cout<<"malloc"<<endl;}~A_Imp(){free(p);cout<<"free"<<endl;}void otherfun(){cout<<"xxxx"<<endl;}void* p; };shared_ptr<A_Imp> impl;
public:A(){impl = make_shared<A_Imp>();}A_Imp* operator->(){return impl.get();}
};int main(int argc, char *argv[])
{A a1;A a2(a1);a1->otherfun();return 0;
}