Question

我想创建类似于指向二维指针数组的指针（宽度和高度为x）。
这段代码会做我期望的吗？（创建数组元素，写出一些有关它们的信息，然后释放所有分配的内存。）

int main(int argc, char** argv) {
    int x = 3;
    Node ***array = new Node**[x];
    for (int i = 0; i < 3; i++) {
        array[i] = new Node*[x];
        for (int j = 0; j < x; j++) {
            array[i][j] = new Node(i, j); /* Node::Node(int row, int col) */
        }
    }
    /* ....... */
    for (int i = 0; i < x; i++) {
        for (int j = 0; j < x; j++) {
            cout << array[i][j]->row << ", " << array[i][j]->col << endl;
        }
    }
    /* ....... */
    for (int i = 0; i < x; i++) {
        for (int j = 0; j < x; j++) {
            delete array[i][j];
            //array[i][j] = NULL;
        }
        delete[] array[i];
        //array[i] = NULL;
    }
    delete[] array;
    //array = NULL;
    return 0;
}

或者我应该为vector个对象创建vector Node个指针？
或者我应该在堆栈上分配我的对象？

（我正在使用指针，因为在Java或C＃中，在创建对象时必须始终使用new关键字（但是，我不认为所有对象都在堆内存中），我读到堆上有更多可用空间。）

我使用带有new关键字的指针的另一个原因是，我想创建指向同一对象的多个指针。我应该在堆栈上创建一个对象，只创建指向该对象的指针吗？

Answer 1

我建议您使用vector< vector<Node> >，boost::multi_array，或者您可以汇总自己的动态2D数组类（并不是那么难），它是一个平面1D的包装{{1} }。

以上所有解决方案都会将您的Node对象存储在堆中，并将负责清理内存。

这是一个简单的Matrix类的示例，它是std::vector：

的包装器

std::vector<T>

它使用#include <iostream> #include <vector> template <class T> class Matrix { public: Matrix() : width_(0), height_(0), vec_(0) {} Matrix(size_t width, size_t height) : width_(width), height_(height), vec_(width*height) {} size_t size() const {return vec_.size();} size_t width() const {return width_;} size_t height() const {return height_;} // Clears all preexisting data void resize(size_t width, size_t height) {width_ = 0; height_ = 0; vec_.clear(); vec_.resize(width*height);} void clear() {width_ = 0; height_ = 0; vec_.clear();} T& operator()(size_t col, size_t row) {return vec_[row*width_ + col];} const T& operator()(size_t col, size_t row) const {return vec_[row*width_ + col];} private: size_t width_; size_t height_; std::vector<T> vec_; }; int main() { Matrix<double> a(3, 4); a(1, 2) = 3.1415; std::cout << a(1,2) << "\n"; }来模仿c风格多维数组的operator()语法。您不必担心浅层副本，释放内存等，因为array[2][4]已经解决了这个问题。

Answer 2

您是否考虑过使用Boost.Multidimensional.Array？

它可以充分解决您要解决的问题。如果您的问题可以接受，则可以将其与Node*或实际Node类型一起使用。

Answer 3

您的代码看起来是正确的，但我建议您创建Node个对象的向量向量 vector类管理自己的内存，因此您永远不必担心忘记delete任何事情。

你甚至不必将它作为Node指针向量的向量。如果你说my_vector.push_back(my_node)，它会将my_node复制到向量的堆分配内存中。如果从函数返回向量，则节点随之处理（它不会在函数末尾丢失，就像堆栈分配的对象一样）。例如：

// declare a vector of nodes on the stack
vector<node> nodes;

// declare a Node object on the stack
Node my_node(/*arguments*/);

// copy my_node (on the stack) into the vector's memory (on the heap)
nodes.push_back(my_node);

// (return 'nodes' from this function and store it somewhere)

请注意nodes中的节点与my_node不同。如果您使用new创建my_node，push_back()将复制指针（而不是对象本身），并且向量中的对象将与您使用new创建的对象相同。如果你这样做，你就拥有了这个对象，你必须记得在完成后删除它。如果你让向量拥有对象（如我的代码示例中所示），它将为您处理。

c ++二维数组问题

3 个答案: