class - 智能指针和析构函数

Question

我想知道当我不再使用原始指针时是否需要在类中编写析构函数？只是提高智能指针。

Answer 1

提升智能指针本身与对析构函数的需求没有任何关系。他们所做的只是消除您对他们有效管理的已分配内存调用 delete 的需要。话虽如此，如果在您开始使用智能指针之前，您在析构函数中的所有操作都是调用 delete 和 delete[] 以释放动态分配的类成员的内存，并且您现在已将所有这些常规指针切换为智能指针，您可以可能只是切换到一个空的析构函数，因为它们现在会在超出范围时自行清理。

但是，如果出于某种原因，您有一个需要进行清理的类（文件清理、套接字、其他资源等），您仍然需要提供一个析构函数来执行此操作。

让我知道这是否有帮助。

Answer 2

每个资源类型都应该有一个 RAII 类来管理该资源。如果您还有一个具有深拷贝语义的智能指针（很容易做到），那么您在 99.9% 的时间里都需要管理资源。我不知道为什么unique_ptr不做深拷贝，也不做任何boost智能指针，但是如果你有这两个东西，你就不需要写拷贝构造函数、移动构造函数、赋值运算符、移动赋值运算符，也不需要析构函数。您可能需要也可能不需要提供其他构造函数（包括默认构造函数），但这少了五个出错的地方。

#include <memory>

template<class Type, class Del = std::default_delete<Type> >
class deep_ptr : public std::unique_ptr<Type, Del> {
public: 
     typedef std::unique_ptr<Type, Del> base;
     typedef typename base::element_type element_type;
     typedef typename base::deleter_type deleter_type;
     typedef typename base::pointer pointer;

     deep_ptr() : base() {}
     //deep_ptr(std::nullptr_t p) : base(p) {}  //GCC no has nullptr_t?
     explicit deep_ptr(pointer p) : base() {}
     deep_ptr(pointer p, const typename std::remove_reference<Del>::type &d) : base(p, d) {} //I faked this, it isn't quite right
    deep_ptr(pointer p, typename std::remove_reference<Del>::type&& d): base(p, d) {}
    deep_ptr(const deep_ptr& rhs) : base(new Type(*rhs)) {}
    template<class Type2, class Del2>
    deep_ptr(const deep_ptr<Type2, Del2>& rhs) : base(new Type(*rhs)) {}
    deep_ptr(deep_ptr&& rhs) : base(std::move(rhs)) {}
    template<class Type2, class Del2>
    deep_ptr(deep_ptr<Type2, Del2>&& rhs) : base(std::move(rhs)) {}

    deep_ptr& operator=(const deep_ptr& rhs) {base::reset(new Type(*rhs)); return *this;}
    template<class Type2, class Del2>
    deep_ptr& operator=(const deep_ptr<Type2, Del2>& rhs) {base::reset(new Type(*rhs)); return *this;}
    deep_ptr& operator=(deep_ptr&& rhs) {base::reset(rhs.release()); return *this;}
    template<class Type2, class Del2>
    deep_ptr& operator=(deep_ptr<Type2, Del2>&& rhs) {base::reset(rhs.release()); return *this;}
    void swap(deep_ptr& rhs) {base::swap(rhs.ptr);}
    friend void swap(deep_ptr& lhs, deep_ptr& rhs) {lhs.swap(rhs.ptr);}
};

有了这个类（或类似的），你根本不需要太多！

struct dog {
   deep_ptr<std::string> name;
};

int main() {
    dog first; //default construct a dog
    first.name.reset(new std::string("Fred"));
    dog second(first); //copy construct a dog
    std::cout << *first.name << ' ' << *second.name << '\n';
    second.name->at(3) = 'o';
    std::cout << *first.name << ' ' << *second.name << '\n';
    second = first; //assign a dog
    std::cout << *first.name << ' ' << *second.name << '\n';
}

如http://ideone.com/Kdhj8所示

Answer 3

您应该始终考虑提供析构函数。您将使用它来释放您的班级持有的任何资源。我的 smart_ptr 类析构函数通常是空的，但并非总是如此。文件流、数据库连接等都需要适当的清理。