Question

这让我困扰了一段时间。很多时候，我发现自己制作了一个大缓冲区来保存“最大”的数据量。这有助于避免每次下一个数据集的大小发生变化时动态分配和释放缓冲区。

例如，假设我的数组太大而无法实际使用，但我知道有用数据的长度。

int amountOfData = 9;
char data1D[100] = some data that is only 9 bytes long stored in a 100 byte array

假设我有一个算法，我想在这个使用二维数组索引的数据集上运行。所以我希望能够按如下方式访问数据：

cout << "I am accessing this data as a 2D array: " << data1D[0][1] << endl;

让我们说这个算法我知道2D数组的xlength和ylength将是：

int xlength = 3;
int ylength = 3;

这次迭代，因为amountOfData = 9。但是，下一次迭代的长度可能不同。 IE浏览器。它们可以是xlength = 4和ylength = 4 amountOfData = 16。

我想做某种类型的转换，允许我使用2D数组索引来转换1D数组。我知道我的初始1D长度有多长，这告诉我我的2D xlength和ylength有多长，所以如果不使用new或malloc这应该很容易做到只要最初的100个字节足够长，可以保存任何有用的数据集。

我意识到：

char** data2d = (char**) data1D;

将无法工作，因为编译器不知道第二个维度的大小。但我会在运行时知道它是什么！

这种情况的根本原因是什么？有没有解决方法？我错过了什么吗？

Answer 1

一旦你在运行时只知道数组的长度，我想最好不要使用2D数组来解决这个问题，而是通过使用函数来模拟它。例如，在C：

中

char data1D[1000] = {0};

unsigned int getElement(unsigned int x, unsigned int y, 
            unsigned int xMax, unsigned int yMax)
{
  // Do some error tests
  return ((unsigned int *) data1D)[x*xMax + y];
}

Answer 2

强制转换不起作用的原因是你实际上是在试图将2维数组转换为指向指针数组的指针，每个指针都指向一个字符数组。

On选项是创建一些适配器类，允许您像访问实际的二维数组一样访问数据。这将简化对数组的两个范围的访问，并且可以扩展以用于标准库。

#include <iostream>
#include <sstream>
#include <utility>

template <typename Type, size_t DataSize>
class MDArray
{
public:

    struct SDArray
    {
        SDArray(Type* data, size_t size) : data_(data), size_(size) {}
        SDArray(const SDArray& o) : data_(o.data), size_(o.size_) {}

        size_t size() const { return size_; };

        Type& operator[](size_t index)
        {
            if(index >= size_)
                throw std::out_of_range("Index out of range");

            return data_[index];
        }

        Type operator[](size_t index) const
        {
            if(index >= size_)
                throw std::out_of_range("Index out of range");

            return data_[index];
        }

    private:

        SDArray& operator=(const SDArray&);
        Type* const     data_;
        const size_t    size_;
    };

    MDArray(const Type *data, size_t size, size_t dimX, size_t dimY)
        : dimX_(dimX), dimY_(dimY)
    {
        if(dimX * dimY > DataSize)
            throw std::invalid_argument("array dimensions greater than data size");

        if(dimX * dimY != size)
            throw std::invalid_argument("data size mismatch");

        initdata(data, size);
    }

    size_t size() const { return dimX_; };
    size_t sizeX() const { return dimX_; };
    size_t sizeY() const { return dimY_; };

    SDArray operator[](const size_t &index)
    {
        if(index >= dimY_)
            throw std::out_of_range("Index out of range");

        return SDArray(data_ + (dimY_ * index), dimX_);
    }

    const SDArray operator[](const size_t &index) const
    {
        if(index >= dimY_)
            throw std::out_of_range("Index out of range");

        return SDArray(data_ + (dimY_ * index), dimX_);
    }

private:

    void initdata(const Type* data, size_t size)
    {
        std::copy(data, data + size, data_);
    }
    MDArray(const MDArray&);
    MDArray operator=(const MDArray&);

    Type            data_[DataSize];
    const size_t    dimX_;
    const size_t    dimY_;
};


int main()
{
    char data[] = "123456789";
    MDArray<char, 100> md(data, 9, 3, 3);


    for(size_t y = 0; y < md.sizeY(); y++)
    {
        for(size_t x = 0; x < md.sizeX(); x++)
        {
            std::cout << " " << md[y][x];
        }
        std::cout << std::endl;
    }

    std::cout << "-------" << std::endl;

    for(size_t y = 0; y < md.size(); y++)
    {
        const auto& sd = md[y];
        for(size_t x = 0; x < sd.size(); x++)
        {
            std::cout << " " << sd[x];
        }
        std::cout << std::endl;
    }

    std::cout << "-------" << std::endl;

    for(size_t y = 0; y < md.size(); y++)
    {
        auto sd = md[y];
        for(size_t x = 0; x < sd.size(); x++)
        {
            std::cout << " " << sd[x];
        }
        std::cout << std::endl;
    }
}

Answer 3

如果你知道你的行/列长度（取决于行或列主要，什么不是）......我相信它就像......

char get_value(char *arr, int row_len, int x, int y) {
    return arr[x * row_len + y];
}

...用于将1D数组视为2D。

2D动态C阵列的另一件事。

char **arr = (char **)malloc(row_size * sizeof(char *));
int x;
for (x = 0; x < row_size; ++x) {
    arr[x] = (char *)malloc(col_size * sizeof(char));
}

我可以将我的列和行混合在一起......

与其他人一样，矢量很好，因为你使用的是C ++：

auto matrix_like_thing = std::vector<std::vector<char> >(rows, std::vector<char>(cols, '\0'));
matrix_like_thing[0][4] = 't';

Answer 4

如果您使用的是C ++，则可以构建一个简单的包装器来简化访问，例如：

template <typename T>
class A2D {
    T *m_buf;
    size_t m_n;
    size_t m_m;
public:
    A2D(T *buf, const size_t &n, const size_t &m)
        : m_buf(buf), m_n(n), m_m(m) { }
    ~A2D() { }

    T& operator()(const size_t &i, const size_t &j)
    {
        return *(this->m_buf + i * this->m_m + j);
    }
};

用法：

int main()
{
    int *a = new int[16];
    for ( int i = 0; i < 16; ++i ) {
        a[i] = i;
    }
    A2D<int> b(a, 4, 4);

    for ( int i = 0; i < 4; ++i ) {
        for ( int j = 0; j < 4; ++j ) {
            std::cout << b(i, j) << ' ';
        }
        std::cout << '\n';
    }
}

使用C，您可以使用过程或宏执行类似的操作。重要的是，不要忘记控制预分配的内存（1D阵列）

在C ++中将1D数组作为2D数组访问

4 个答案: