18

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

例如，假设我有一个数组对于它的实际有用大小来说太大了，但我知道有用数据的长度。

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;

假设对于这个算法，我知道二维数组的 xlength 和 ylength 将是：

int xlength = 3;
int ylength = 3;

对于本次迭代，因为amountOfData = 9. 但是，下一次迭代的长度可能会有所不同。IE。他们可以xlength = 4被ylength = 4给予amountOfData = 16。

我想做某种类型的转换，允许我使用 2D 数组索引转换 1D 数组。我知道我的初始 1D 长度有多长，它告诉我我的 2Dxlength和有多长ylength，所以这应该很容易做到而不使用new或malloc只要初始 100 字节足够长以容纳对我有用的数据集。

我意识到：

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

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

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

4

4 回答 4

6

一旦你在运行时只知道数组的长度，我想最好不要使用二维数组来解决这个问题，而是使用函数来模拟它。例如，在 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];
}
于 2013-07-02T03:37:18.720 回答
2

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

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

#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;
    }
}
于 2013-07-02T02:52:53.757 回答
1

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

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

...用于将一维数组视为二维。

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';
于 2013-07-02T02:51:29.010 回答
1

如果您使用的是 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，您可以使用过程或宏执行类似的操作。重要的是，不要忘记控制预分配内存（一维数组）

于 2013-07-02T02:52:06.383 回答