Question

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

谢谢！

Answer 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为零或一。

Answer 2

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

int (*hashFunc)[2];

并将其分配为一次

hashFunc = new int[var][2];

Answer 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;
}

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

3 个答案: