1

我想在一个类中有一个无符号整数数组，它的大小应该是 [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）。

谢谢！

4

3 回答 3

3

如果大小在编译时已知，则应使用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]where xis in range of varandy是零或一。

于 2013-06-22T23:58:03.627 回答
1

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

int (*hashFunc)[2];

并将其一次性分配为

hashFunc = new int[var][2];
于 2013-06-23T00:12:44.693 回答
0

有两种方法可以解决这个问题。要么有一个带有裸指针的类，要么用std::vectorand封装它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;
}
于 2013-06-23T01:15:48.707 回答