saber - La mejor forma de representar una matriz 2-D en C++ con un tamaño determinado en tiempo de ejecución

tamaño de un vector c++

Question

En C ++ me gustaría hacer algo como:

int n = get_int_from_user();

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

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

delete [][] matrix;

pero por supuesto esto no funciona. ¿Cuál es la mejor manera de hacer algo similar? He visto algunas soluciones a esto, pero parecen bastante desordenadas.

Answer 1

¿Qué pasa con std::vector< std::vector<int> > array2d; ?

Answer 2

Normalmente hago algo como esto:

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

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

delete [] matrix;

Answer 3

Para una verdadera matriz bidimensional:

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;

Justo al lado de la parte superior de mi cabeza. Errores, sin dudas. Sin embargo, otras personas han publicado un enfoque más elegante, creo.

Answer 4

boost :: multi_array

hacerlo a mano será un desastre.

Answer 5

La forma dinámica manual:

Digamos que quieres una matriz de ancho * alto, la forma más eficiente es simplemente usar una única matriz dimensional:

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

Para eliminarlo:

delete[] matrix;

Para acceder a ella:

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

Para modificarlo:

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

Boost Matrix:

Considere usar boost :: matrix si puede tener la dependencia.

A continuación, podría vincularse a las bibliotecas de álgebra lineal de impulso .

Aquí hay algunos ejemplos de código de 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;

En la pila para algunos compiladores:

Algunos compiladores realmente le permiten crear matrices en la pila con tamaños determinados en tiempo de ejecución. g ++ es un ejemplo de dicho compilador. Sin embargo, no puedes hacer esto por VC ++.

Entonces en g ++ este es código válido:

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

Drew Hall mencionó que esta característica C99 se llama Arrays de Longitud Variable (VLA) y que probablemente pueda activarse en cualquier compilador moderno.

Answer 6

Me gusta el enfoque de matriz 1-d (la respuesta seleccionada por Brian R. Bondy) con la extensión que envuelve a los miembros de datos en una clase para que no tenga que hacer un seguimiento del ancho por separado:

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

La implementación es un ejercicio para el lector. ;)

Answer 7

Parece que te estás perdiendo todo el punto de C ++ (C con clases) :-). Este es el tipo de uso que está pidiendo a gritos a una clase para implementarlo.

Podrías simplemente usar STL u otra biblioteca de clases de terceros que estoy seguro tendría la estructura de datos que estás buscando pero, si necesitas crear la tuya propia, simplemente crea una clase con las siguientes propiedades.

• constructor que, dado n, simplemente creará una nueva matriz n * n de char (por ejemplo, charray) ..
• funciones de miembros que obtienen y establecen valores basados ​​en xy que simplemente se refieren a charray [x * n + y];
• destructor que elimina [] es la matriz.

Answer 8

Creo que este sería uno bueno.

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;

Answer 9

std::vector<int> m;

Luego, llame a m.resize () en tiempo de ejecución.

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

si quieres hacer algo como eliminación gaussiana, tu matriz debe ser

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

(En la eliminación gaussiana usualmente necesitamos intercambiar una fila con otra, por lo que es mejor intercambiar punteros a filas en tiempo constante en lugar de intercambiar copiando en tiempo lineal).