Existem matrizes irregulares em C / C ++?

Existe algo como um array irregular em C ou C ++?

Quando eu compilar isso:

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

Eu recebo este erro:

error: declaração de `jagged ‘como array multidimensional deve ter limites para todas as dimensões, exceto a primeira

No CI usaria uma matriz de pointers.

Por exemplo:

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

etc etc.

Há várias maneiras de fazer isso. Aqui está outro jeito:

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

Se você quer apenas inicializá-lo, você pode dizer:

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

mas o array ainda terá a forma [2] [3]. Se você quiser um verdadeiro array irregular, terá que criá-lo dinamicamente. E se você fizer isso, e estiver usando C ++, você deve usar um std::vector , como sugere o friol.

Em C ++ (não compilado e provavelmente há uma syntax mais compacta):

 std::vector > myArray; myArray.push_back(std::vector()); myArray.push_back(std::vector()); 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); 

Então agora você pode acessar os elementos com, por exemplo, myArray [0] [0], etc.

Em C99 você pode fazer o seguinte:

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

A única diferença aqui (em comparação com a resposta do rampion) é que as matrizes não decaem para pointers e é preciso acessar as matrizes individuais através de outro nível de indireção – (por exemplo, *jagged[0] – e o tamanho de cada linha para ser gravado – ou seja, sizeof(*jagged[0]) não irá compilar) – mas eles são irregulares – aparecendo até o osso;)

O motivo pelo qual você recebeu o erro é que você deve especificar os limites para pelo menos a dimensão externa; ou seja

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

Você não pode ter jagged [0] ser um array de 2 elementos de int e jagged [1] ser um array de 3 elementos de int; Uma matriz de elementos-N é um tipo diferente de uma matriz de elementos-M (onde N! = M), e todos os elementos de uma matriz devem ser do mesmo tipo.

O que você pode fazer é o que os outros sugeriram acima e criar irregular como uma matriz de pointers para int; Dessa forma, cada elemento pode apontar para matrizes inteiras de tamanhos diferentes:

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

Mesmo que row0 e row1 sejam tipos diferentes (matrizes de intolerância de 2 elementos vs. de elementos de 3 elementos), no contexto do inicializador, ambos são implicitamente convertidos para o mesmo tipo (int *).

Com as listas de boot do C ++ 11, isso pode ser escrito de forma mais compacta:

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

A saída é:

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

Para referência: