programas - que es un arreglo en c++

¿Existen arreglos irregulares en C/C++?

Question

¿Hay algo así como una matriz dentada en C o C ++?

Cuando compilo esto:

int jagged[][] = { {0,1}, {1,2,3} };

Me sale este error:

error: la declaración de `dentada ''como una matriz multidimensional debe tener límites para todas las dimensiones excepto la primera

Answer 1

Con las listas de inicializadores de C ++ 11, this se puede escribir de forma más compacta:

#include <vector>
#include <iostream>

int main() {
    // declare and initialize array
    std::vector<std::vector<int>> arr = {{1,2,3}, {4,5}};
    // print content of array
    for (auto row : arr) {
        for (auto col : row)
            std::cout << col << " ";
        std::cout << "/n";
    }
}

El resultado es:

$ g++ test.cc -std=c++11 && ./a.out
1 2 3 
4 5 

Para referencia:

• http://en.cppreference.com/w/cpp/utility/initializer_list

Answer 2

En C ++ (no compilado, y probablemente haya una sintaxis más compacta):

std::vector<std::vector<int> > myArray;

myArray.push_back(std::vector<int>());
myArray.push_back(std::vector<int>());

myArray[0].push_back(0);
myArray[0].push_back(1);

myArray[1].push_back(1);
myArray[1].push_back(2);
myArray[1].push_back(3);

Ahora puede acceder a los elementos con, por ejemplo, myArray [0] [0], etc.

Answer 3

En C99 puedes hacer lo siguiente:

int jagged_row0[] = {0,1};
int jagged_row1[] = {1,2,3};

int (*jagged[])[] = { &jagged_row0, &jagged_row1 }; // note the ampersand

// also since compound literals are lvalues ...
int (*jagged2[])[] = { &(int[]){0,1}, &(int[]){1,2,3} };  

La única diferencia aquí (en comparación con la respuesta de rampion) es que las matrices no se degradan en punteros y uno tiene que acceder a las matrices individuales a través de otro nivel de indirección (p *jagged[0] Ej. *jagged[0] ) y el tamaño de cada fila para ser grabado, es decir, sizeof(*jagged[0]) no se compilará) - pero son irregulares, apareciendo hasta el hueso;)

Answer 4

En CI usaría una matriz de punteros.

Por ejemplo:

int *jagged[5];

jagged[0] = malloc(sizeof(int) * 10);
jagged[1] = malloc(sizeof(int) * 3);

etcétera etcétera.

Answer 5

Hay muchas formas de hacerlo. Aquí hay otra forma:

int jagged_row0[] = {0,1};
int jagged_row1[] = {1,2,3};
int *jagged[] = { jagged_row0, jagged_row1 };

Answer 6

La razón por la que recibió el error es que debe especificar los límites para al menos la dimensión externa; es decir

int jagged[][3] = {{0,1},{1,2,3}};

No puede haber variado [0] ser una matriz de 2 elementos de int y dentada [1] ser una matriz de 3 elementos de int; una matriz de N elementos es un tipo diferente de una matriz de elementos M (donde N! = M), y todos los elementos de una matriz deben ser del mismo tipo.

Lo que puede hacer es lo que los otros han sugerido anteriormente y crear irregular como una matriz de punteros a int; De esta forma, cada elemento puede apuntar a matrices enteras de diferentes tamaños:

int row0[] = {0,1};
int row1[] = {1,2,3};
int *jagged[] = {row0, row1};

Aunque row0 y row1 son tipos diferentes (arrays de 2 elementos frente a 3 elementos de int), en el contexto del inicializador ambos se convierten implícitamente al mismo tipo (int *).

Answer 7

Si solo desea inicializarlo, puede decir:

int jagged[][3] = { {0,1}, {1,2,3} };

pero la matriz todavía tendrá la forma [2] [3]. Si quieres una matriz dentada verdadera, tendrás que crearla dinámicamente. Y si haces eso, y estás usando C ++, deberías usar std::vector , como sugiere friol.