Question

我有一份功课要求我有一个狗库。我必须有一个动态数组，模板化。出于某种原因，我得到了很多内存泄漏，我不知道它们来自哪里。我尝试过使用Deleaker，但它说＆＃34; Unknown＆＃34;在源文件。

说实话，我实际上并不了解应该释放内存的位置，因为我无法使用delete。

这是我的动态数组定义和声明（不是全部，直到析构函数），如果有帮助的话。

template <typename T>
class DynamicVector
{
private:
    T* elems;
    int size;
    int capacity;

public:
    // default constructor for a DynamicVector
    DynamicVector(int capacity = 10);

    // copy constructor for a DynamicVector
    DynamicVector(const DynamicVector& v);
    ~DynamicVector();
    DynamicVector& operator=(const DynamicVector& v);
};
template <typename T>
DynamicVector<T>::DynamicVector(int capacity)
{
    this->size = 0;
    this->capacity = capacity;
    this->elems = new T[capacity];
}

template <typename T>
T& DynamicVector<T>::operator[](int index)
{
    return this->elems[index];
}

template <typename T>
DynamicVector<T>::DynamicVector(const DynamicVector<T>& v)
{
    this->size = v.size;
    this->capacity = v.capacity;
    this->elems = new T[this->capacity];
    for (int i = 0; i < this->size; i++)
        this->elems[i] = v.elems[i];
}

template <typename T>
DynamicVector<T>::~DynamicVector()
{
    delete[] this->elems;
}

template <typename T>
DynamicVector<T>& DynamicVector<T>::operator=(const DynamicVector<T>& v)
{
    if (this == &v)
        return *this;

    this->size = v.size;
    this->capacity = v.capacity;

    auto aux = new T[this->capacity];

    delete[] this->elems;

    this->elems = aux;
    for (int i = 0; i < this->size; i++)
        this->elems[i] = v.elems[i];

    return *this;
}

我是否应该在Dog.h和Dog.cpp中定义析构函数？或者在我的狗库中（使用动态矢量）？

使用dog class和repository编辑：

class Dog
{
private:
    std::string breed;
    std::string name;
    int age;
    std::string photograph;

public:
    // default constructor for a dog
    Dog();

    // constructor with parameters
    Dog(const std::string& breed, const std::string& name, const int& age, const std::string& photograph);
    // returns true if two dogs have the same name
    bool operator==(const Dog & d);
    //returns the breed
    std::string getBreed() const { return breed; }
    //returns the name
    std::string getName() const { return name; }
    //returns the age
    int getAge() const { return age; }
    //returns the photograph
    std::string getPhotograph() const { return photograph; }
    void setName(const std::string& n);
    void setAge(const int& a);
    void show();
};

class Repository
{
private:
    DynamicVector<Dog> dogs;
    int current;

public:
    /*
    Default constructor.
    Initializes an object of type repository.
    */
    Repository();

    /*
    Adds a dog to the repository.
    Input: d - Dog.
    Output: the dog is added to the repository.
    */
    void addDog(const Dog& d);

    //I have more methods here but they are irrelevant
}

你可以注意到，我在这些课程中只有构造函数，所以考虑到三个规则，这可能就是问题所在。

Answer 1

为什么不使用std::vector？动态分配真的很棘手;您必须遵循RAII的推荐但未记录的模式，具有以下几个要求：复制/移动构造函数，赋值运算符，交换函数，析构函数。你最好坚持std::vector，除非 - 当然 - 它被禁止了。

Answer 2

因此，请花费很长的路并定义所有特殊函数 - 以及在其中一些函数中使用的交换函数，以便重构代码。如果这些函数中的任何一个是默认的，迟早或者其他你将最终得到悬空指针，双删除，使用删除的指针，并希望早期崩溃来完成噩梦。所有特殊成员必须正确定义。 “五大”（以前的“大三”）是实施RAII的惯用方式。你必须定义析构函数拷贝构造函数和拷贝分配（加上移动对应物）。我希望你至少可以使用unique_ptr。

模拟动态数组上的内存泄漏

2 个答案: