Лучший способ представить двумерный массив на C++ с размером, определяемым во время выполнения

Для истинного двумерного массива:

int n = get_int_from_user();

char** matrix = new char*[n];
for (int i = 0; i < n; i++) {
    matrix[i] = new char[n];
}

// Operations on matrix.

for (int i = 0; i < n; i++) {
    delete [] matrix[i];
}
delete matrix;

Просто с головы до ног. Ошибки, без сомнения. Однако я думаю, что другие люди опубликовали более элегантный подход.

Обычно я делаю что-то вроде этого:

char *matrix = new char [width * height];

matrix[i + j * width] = 'c'; // same as matrix[i][j] = 'c';

delete [] matrix;

Ручной динамический способ:

Допустим, вам нужен массив шириной * высотой, наиболее эффективный способ - просто использовать одномерный массив:

char *matrix = new char[width*height];

Чтобы удалить его:

delete[] matrix;

Чтобы получить к нему доступ:

char getArrayValue(char *matrix, int row, int col)
{
  return matrix[row + col*width];
}

Чтобы изменить это:

void setArrayValue(char *matrix, int row, int col, char val)
{
  matrix[row + col*width] = val;
}

Матрица усиления:

Рассмотрите возможность использования boost :: matrix, если у вас может быть зависимость.

Затем вы можете подключиться к библиотекам улучшить линейную алгебру.

Вот какой-то пример кода boost :: matrix:

#include <boost/numeric/ublas/matrix.hpp>
using namespace boost::numeric::ublas;
matrix<char> m (3, 3);
for (unsigned i = 0; i < m.size1 (); ++ i)
    for (unsigned j = 0; j < m.size2 (); ++ j)
        m (i, j) = 3 * i + j;

В стеке для некоторых компиляторов:

Некоторые компиляторы фактически позволяют создавать в стеке массивы с размерами, определяемыми во время выполнения. g ++ - пример такого компилятора. Однако вы не можете сделать это по умолчанию VC++.

Итак, в g ++ это действительный код:

int width = 10;
int height = 10; 
int matrix[width][height];

Дрю Холл упомянул, что эта функция C99 называется массивами переменной длины (VLA) и, вероятно, может быть включена в любом современном компиляторе.

Кажется, вам не хватает всего C++ (C с классами) :-). Это тот вид использования, который требует от класса его реализации.

Вы мог просто используете STL или другую стороннюю библиотеку классов, которая, я уверен, будет иметь структуру данных, которую вы ищете, но, если вам нужно свернуть свою собственную, просто создайте класс со следующими свойствами.

• конструктор, который при заданном n просто создаст новый массив символов n * n (например, charray).
• функции-члены, которые получают и устанавливают значения на основе x.y, которые просто ссылаются на charray [x * n + y];
• деструктор, который удаляет [] массив.

А как насчет std::vector< std::vector<int> > array2d;?

Мне нравится подход с одномерным массивом (выбранный ответ Брайана Р. Бонди) с расширением, в котором вы обертываете элементы данных в класс, чтобы вам не нужно было отслеживать ширину отдельно:

class Matrix
{
    int width;
    int height;
    char* data;
public:
    Matrix();
    Matrix(int width, int height);
    ~Matrix();

    char getArrayValue(int row, int col);
    void setArrayValue(int row, int col, char val);
}

Реализация - это упражнение для читателя. ;)

Думаю, это было бы неплохо.

int n = get_int_from_user();

char **matrix=new (char*)[n];

for(int i=0;i<n;i++)
    matrix[i]=new char[n];

matrix[0][0] = 'c';
//...
matrix[n][n] = 'a';

for(int i=0;i<n;i++)
    delete []matrix;
delete []matrix;

std::vector<int> m;

Затем вызовите m.resize () во время выполнения.

int* matrix = new int[w*h];

если вы хотите сделать что-то вроде исключения Гаусса, ваша матрица должна быть

int** matrix = new int*[h];
for(size_t i(0); i < h; ++i)
    matrix[i] = new int[w];

(при исключении Гаусса нам обычно нужно обменивать одну строку на другую, поэтому лучше поменять местами указатели на строки за постоянное время, чем переставлять путем копирования за линейное время).