c++ array[var][2] 作为类成员答案

【问题标题】：c++ array[var][2] as a class memberc++ array[var][2] 作为类成员
【发布时间】：2013-06-22 23:52:40
【问题描述】：

我想在一个类中有一个无符号整数数组，它的大小应该是 [var][2]，这样用户就可以在运行时选择 var。有没有比分配二维数组（已分配的指向已分配数组的指针的数组）更好的方法？

在我的课上：

unsigned int *(*hashFunc);

在初始化函数中：

hashFunc = new unsigned int*[var];
for(unsigned int i = 0; i<var; ++i)
    hashFunc[i] = new unsigned int[2];

我只想分配一次，我认为这应该是可能的，因为我只有一个未知维度（var 未知，但我从一开始就知道 2）。

谢谢！

【问题讨论】：

有什么问题？这是执行此操作的有效方法。无论如何，如果您对new/delete 不满意，您可能想尝试std::vector
只是AndreyT提供的更好，我认为应该有类似的东西

标签： c++ class multidimensional-array allocation

【解决方案1】：

如果在编译时知道大小，您应该使用std::array。如果其中一个维度直到运行时才知道，您应该使用std::vector。

您当然可以将它们组合起来：

std::vector<std::array<unsigned int, 2>> hashFunc;

上面声明hashFunc 是一个数组向量，数组大小为2，类型为unsigned int，就像问题中指定的一样。

然后添加一个新的内部数组只需使用向量的push_back：

hashFunc.push_back({{ 1, 2 }});

（是的，需要双括号。外部用于构造std::array 对象，内部用于实际数组数据。）

或者，如果您想立即设置外部向量的大小（例如，如果您（运行时）事先知道大小），您可以这样做，例如

hashFunc = std::vector<std::array<unsigned int, 2>>(var);

上面的var 是“第一维”的大小。现在您可以直接访问hashFunc[x][y]，其中x 在var 的范围内，y 为零或一。

【讨论】：

非常感谢！我有理由使用向量和数组而不是 AndreyT 提供的东西吗？（我确实一次设置了 var 的值并且从不更改它）

【解决方案2】：

（回答直接问题。）您可以将指针声明为

int (*hashFunc)[2];

并一次性将其分配为

hashFunc = new int[var][2];

【讨论】：

【解决方案3】：

有两种方法可以解决这个问题。要么有一个带有裸指针的类，要么用std::vector 和std::array 封装它。下面是两个可能的实现完全相同的示例。

#include <iostream>
#include <vector>
#include <array>
#include <stdexcept>

class TheClass {
public:
    typedef int TwoInts[2];
    TheClass(const std::size_t size) : m_size(size)
    {
        m_hashFunc = new TwoInts[m_size];
        if (m_hashFunc == NULL) throw std::runtime_error("Ran out of memory.");
    }
    virtual ~TheClass()
    {
        delete [] m_hashFunc;
    }

    inline       std::size_t size()                                               const { return m_size; }
    inline       int&        operator()(const std::size_t i, const std::size_t j)       { return m_hashFunc[i][j]; }
    inline const int&        operator()(const std::size_t i, const std::size_t j) const { return m_hashFunc[i][j]; }
private:
    std::size_t m_size;
    TwoInts* m_hashFunc;
};

class AnotherClass {
public:
    AnotherClass(const std::size_t size) : m_hashFunc(size)
    {
        // Nothing to do here.
    }

    // No destructor required.

    inline       std::size_t size()                                               const { return m_hashFunc.size(); }
    inline       int&        operator()(const std::size_t i, const std::size_t j)       { return m_hashFunc[i][j]; }
    inline const int&        operator()(const std::size_t i, const std::size_t j) const { return m_hashFunc[i][j]; }
private:
    std::vector<std::array<int, 2>> m_hashFunc;
};

int main(int argc, char *argv[]) {
    if (argc < 2) return -1;
    const std::size_t runtimesize = static_cast<std::size_t>(atoll(argv[1]));
    const std::size_t i1 = rand() % runtimesize;
    const std::size_t i2 = rand() % runtimesize;
    TheClass instance1(runtimesize);
    AnotherClass instance2(runtimesize);
    instance1(i1,0) = instance2(i1,0) = 4;
    instance1(i2,1) = instance2(i2,1) = 2;
    std::cout << instance1(i1,0) << ' ' << instance2(i1,0) << std::endl;
    std::cout << instance1(i2,1) << ' ' << instance2(i2,1) << std::endl;
    std::cout << instance1.size() << std::endl;
    std::cout << instance2.size() << std::endl;
    // ... etc
    return 0;
}

【讨论】：