如何正确分配动态一维数组作为类的成员？

Question

到目前为止，这是我的课程：

template <typename T>
class myClass
{
private:
    size_t capacity_;
    size_t size_;
    T* the_array;
public:
    myClass(size_t cap) {
        capacity_ = cap;
        size_ = 0;
        the_array = new T[capacity_];
    }
    ~myClass() { clear(); }

    virtual size_t capacity() const {
        return capacity_;
    }

    virtual size_t size() const {
        return size_;
    }

    virtual bool clear() {
        delete[] the_array;
        return true;
    }   
};

我试图在构造函数中分配数组，但是当我创建一个 myClass 对象时，它的 the_array 不是具有我请求的容量的数组。调试时，the_array 只是一个指向 T 的指针。我不确定问题出在构造函数中还是在我为指向 the_array 的指针的私有变量的声明中。

Answer 1

当我创建一个 myClass 对象时，它的 the_array 不是具有我要求的容量的数组。

是的，是的。好吧，无论如何，指向这样一个数组的指针。

调试时，the_array 只是一个指向 T 的指针。

它是指向动态分配数组的指针（第一个元素），该数组包含T 类型的元素。

我不确定问题出在构造函数中还是在我为指向 the_array 的指针的私有变量的声明中。

两者都没有。问题在于你对现实的理解。

new[] 分配一个数组来保存指定类型的指定数量的元素，然后返回一个指向该内存的指针。另一方面，调试器无法知道指针指向的内存类型。它所知道的只是指针指向取消引用类型的实例，因此默认情况下它只能显示该单个实例的数据。但是你知道指针实际上指向的是一个数组，所以你需要明确地告诉调试器这个事实，以便它可以显示数组中的其他元素。大多数调试器都提供一个命令，让您指定在所指向的内存地址中存在多少数组元素。

您显示的代码正确地创建了数组。该代码只是在之后管理数组的方式不完整，因为它不遵循Rule of 3/5/0。它需要实现（或禁用）复制构造函数和复制赋值运算符。对于 C++11 及更高版本，它还应实现移动构造函数和移动赋值运算符。例如：

#include <utility>
#include <algorithm>

template <typename T>
class myClass
{
private:
    size_t capacity_;
    size_t size_;
    T* array_;

public:
    myClass(size_t cap = 0) {
        capacity_ = cap;
        size_ = 0;
        array_ = new T[capacity_];
    }

    myClass(const myClass& src) {
        capacity_ = src.capacity_;
        size_ = src.size_;
        array_ = new T[capacity_];
        std::copy_n(src.array_, size_, array_);
    }

    myClass(myClass&& src) {
        capacity_ = std::exchange(src.capacity_, 0);
        size_ = std::exchange(src.size_, 0);
        array_ = std::exchange(src.array_, nullptr);
    }

    ~myClass() { clear(); }

    myClass& operator=(myClass rhs) {
        capacity_ = std::exchange(rhs.capacity_, 0);
        size_ = std::exchange(rhs.size_, 0);
        array_ = std::exchange(rhs.array_, nullptr);
        return *this;
    }

    size_t capacity() const {
        return capacity_;
    }

    size_t size() const {
        return size_;
    }

    void clear() {
        delete[] array_;
        array_ = nullptr;
        capacity_ = size_ = 0;
    }   
};

话虽如此，您应该使用std::vector 而不是new[]，然后所有这些细节都会自动为您处理，因为std::vector 遵循3/5/0 规则，并且编译器-在您的类中生成的构造函数和赋值运算符足以正确管理向量，例如：

#include <vector>

template <typename T>
class myClass
{
private:
    std::vector<T> vec_;

public:
    myClass(size_t cap = 0) {
        vec_.reserve(cap);
    }

    size_t capacity() const {
        return vec_.capacity();
    }

    size_t size() const {
        return vec_.size();
    }

    void clear() {
        vec_.clear();
    }   
};