Это беспокоило меня некоторое время. Много раз я нахожу, что делаю большой буфер для хранения "максимального" количества данных. Это помогает мне избежать динамического выделения и освобождения буфера каждый раз, когда изменяется размер следующего набора данных.
Например, у меня есть массив, который слишком велик для его фактического полезного размера, но я знаю длину полезных данных.
int amountOfData = 9;
char data1D[100] = some data that is only 9 bytes long stored in a 100 byte array
Позволяет сказать, что у меня есть алгоритм, который я хочу запустить в этом наборе данных, который использует индексацию 2D-массива. Поэтому я хочу иметь доступ к данным следующим образом:
cout << "I am accessing this data as a 2D array: " << data1D[0][1] << endl;
Скажем, для этого алгоритма я знаю, что длина x и длина двумерного массива будут:
int xlength = 3;
int ylength = 3;
для этой итерации, потому что amountOfData = 9. Однако длины для другой итерации могут быть разными. То есть. они могут быть xlength = 4 и ylength = 4 заданы amountOfData = 16.
Я хочу сделать какое-то литье, которое позволяет мне использовать 1D-массив, используя двумерную индексацию. Я знаю, как долго моя начальная 1D-длина, что говорит мне, как долго мои 2D xlength и ylength, поэтому это должно быть легко обойтись без использования new или malloc, пока начальные 100 байтов достаточно долго, чтобы хранить полезные данные для меня.
Я понимаю, что:
char** data2d = (char**) data1D;
не будет работать, потому что компилятор не знает размер второго измерения. Но я буду знать, что это такое во время выполнения!
В чем причина этого, так оно и есть? Есть ли обходные пути? Я что-то пропустил?
Как только вы знаете длину своего массива во время выполнения, я думаю, что лучше решить эту проблему, не используя 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];
}
Причина, по которой актер не работает, заключается в том, что вы пытаетесь преобразовать 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;
}
}
Если вы знаете свою длину строки/столбца (в зависимости от основной строки или столбца, а что нет)... Я считаю, что это что-то вроде...
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));
}
Я мог бы смешивать свои столбцы и строки...
Как и все остальные, векторы хороши, поскольку вы используете С++:
auto matrix_like_thing = std::vector<std::vector<char> >(rows, std::vector<char>(cols, '\0'));
matrix_like_thing[0][4] = 't';
Если вы используете С++, вы можете создать простую оболочку для упрощения доступа, например:
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)