如何实现析构函数

Question

我无法理解向量和堆。到目前为止，我想创建一个 int 向量。这个向量的元素应该存储在堆中。我实现了 class，但我认为我没有正确实现析构函数。移动构造函数也有问题。如果我想将向量 a 移动到向量 b，a 保持相同的值。

Class A {
private : 
vector<int> myV ;
int val; 
size_t Size; 
public: 
    A(){
    myV.resize(0);      
this->value = 0 ;
   }

A(size_t size){
    MyVector.resize(0);
    Size = size ;
    this->value = 0 ;
}

A(size_t size, int value){
    A.resize(0);
    Size = size;
    Val = value;
    MyVector.push_back(Val);
}
~A()
{
     myV.clear();
     delete &myV;
}
    A(A&&other)
{
    *this = std::move(other);
    this->myV = other.myV ;
}

我试图检查代码，但是

int main()
{
    Vector myVect(2,5);
    Vector m (std::move(myVect));
    std::cout<<m[0]<<std::endl;
}

myVect 的值没有移动，尽管它保持原样。

根据我的理解，vector 应该在堆上分配元素，我如何在没有内存泄漏的情况下释放它。

Answer 1

请在下面找到一个工作示例。

#include <vector>
#include <iostream> // Debug only

class Vector
{
    private:
        std::vector<int> _myVec;
        int _val;
        size_t _size;

    public:
        // "Regular" Construtors
        Vector() : _val(0), _size(0) {}
        Vector(size_t size) : _size(size), _val(0) {}

        Vector(size_t size, int value) : _val(value), _size(size)
        {
            _myVec.push_back(_val);
        }

        // Move Constructor
        Vector(Vector&& other)
        {
            std::cout << "Move Constructor called\n"; // Debug purpose

            _myVec = std::move(other._myVec);
            _val = std::move(other._val);
            _size = std::move(other._size);
        }

        // Destructor
        ~Vector()
        {
            _myVec.clear(); // useless being given the destructor will destroy the vector of int anyway
        }

        // Getter
        std::vector<int> getMyVec() const { return _myVec; }
};

int main()
{
    std::cout << "Hello world\n";

    Vector _myVecect(2, 5);
    Vector m(std::move(_myVecect));

    std::cout << m.getMyVec()[0] << std::endl;

    return 0;
}

创建移动构造函数时，必须移动 class 的每个成员，就像上面 ^ 所做的那样。对于您的 main 中的 cout 行，这不能正常工作，因为您的变量 'm' 是 class Vector 的一个实例。你不能通过 [] 运算符来操作它，除非你自己定义它来像处理数组一样使用它。

如果您不管理流或动态内存，则不需要这种析构函数。如果你有一个流，析构函数将是一个关闭的好地方，以确保没有人会在对象删除后尝试使用该流。在动态内存的情况下，你不必在这里使用 delete 因为我们现在有现代 C++ 智能指针（unique_ptr 和 smart_ptr 可以为你完成这项工作）。

Answer 2

你应该阅读 0 的规则（例如 here，它从 3/5 规则开始，一定要读到最后）。

std::vector 已经为您管理内存。当移动构造函数只做编译器生成的可以做的事情时，您也不应该实现它。此外，您应该使用成员初始值设定项列表来初始化成员。尽管默认构造的 std::vector 的大小已经为 0，但无需调整它的大小。而且你忘了在默认构造函数中初始化 Size ，它也没有在移动构造函数中移动。我想 Size 应该是矢量的大小，但矢量已经跟踪它的大小，所以我删除了那个成员。我进一步假设 val 是您要存储在向量中的某个值，因此无需将其复制为成员。

您的 class 可能如下所示：

class A {
    std::vector<int> myV ;
public: 
    A() = default;
    A(size_t size) : myV(size) {}    
    A(size_t size, int value) : myV(size,value) {}
    std::vector<int> get() { return myV; }
};

如何实现析构函数

How to implement a destructor

c++

c++17