Enviado em 22/11/2017 - 17:04h
Prezado,
Ao longo desta resposta, vou utilizar uma expressão que não é muito comum no mundo do C, embora o seja em linguagens como Pascal e Perl. Trata-se da expressão “tipo escalar”. E eu a uso para designar tipos de dados que não são dados compostos. Nesse contexto, um
char ou
int são um escalares, ao passo que um
array (vetor, matriz, cubo, hipercubo etc.) são tipos compostos.
Eu acho essa terminologia particularmente útil para o caso em questão por causa da analogia com a Matemática: um escalar não tem dimensão, mas é apenas um valor numérico. Um
char , do modo semelhante, também é apenas um valor numérico em C.
Sendo assim, o título da postagem tem um problema quando fala em “
char de três dimensões”, uma vez que escalares por definição são adimensionais. A questão ficou mais bem colocada no corpo da mensagem, quando você explicitou que gostaria de trabalhar com uma matriz de
strings .
Em parte, a coisa fica um pouco complicada de expressar naturalmente porque o C não possui nem matrizes, como forma de estruturar dados, nem
strings como tipo escalar.
Na verdade, o C não possui
arrays multidimensionais de tipo nenhum. Todos os
arrays em C são apenas unidimensionais. Na analogia com a Matemática, o C só pode criar vetores, não
arrays de mais alta ordem.
Entretanto — e aqui reside uma outra diferença entre o C e nossa Álgebra tradicional —, o C não exige que os componentes de um vetor sejam tipos escalares. A única exigência é que todos os elementos sejam do mesmo tipo, mas tal tipo pode ser qualquer tipo, incluindo um tipo que designe um
array .
Desse modo, uma maneira de simular
arrays com
N dimensões é usar um array unidimensional cujos elementos sejam
arrays com
N-1 dimensões. Como caso particular, uma matriz, que pode ser entendida como um
array bidimensional, pode ser representada em C como um
array de
arrays .
A respeito da falta de um tipo escalar para representar
strings , a abordagem adotada pelo C foi se valer da forma como
strings são tipicamente armazenadas na memória, que é pela disposição dos caracteres que compõem a
string em posições adjacentes de memória. Ora, o que é uma disposição de dados relacionados em posições contíguas de memória, senão um
array ? Assim, para o C, a forma de tratar
strings num programa foi expor sua representação interna. Dados que representem
strings têm de ser declarados como
arrays de caracteres.
Essa escolha, que simplifica a implementação da linguagem, tem algumas consequências um pouco desagradáveis para quem
usa a linguagem. Se
char é um valor numérico (e o é em C), pode haver a necessidade de usar
arrays de
char que não funcionem como
strings , mas apenas como agregados de valores numéricos de pouca magnitude. Como evitar a confusão entre ambos? Como impedir a tentativa de tratar como
string algo que
string não é?
Outra dificuldade é que
arrays em C expõem muito claramente sua natureza composta ao impedir que eles sejam alvos de atribuições. Por conta disso, mesmo que os nomes
a e
b designem
arrays de mesmo tipo num programa, a instrução “
b=a; ” é ilegal. Para copiar o conteúdo de
a para
b , é necessário explicitar a cópia de elemento a elemento, ou realizar tal cópia por meio de uma função, mas isso apenas esconde a complexidade de quem chama a função, que internamente continua tendo de tratar a cópia elemento a elemento. (Pelo lado positivo, expor os detalhes ajuda o programador a estar ciente de que operações com
arrays são custosas. Linguagens que
aparentemente tratam
strings como escalares podem induzir os programadores a pensar que é trivial copiar strings de um lado para o outro ou realizar operações tais como comparações de valores, concatenações, extrações de partes ou manipulação de conteúdo. Mas isso é irreal.)
Na prática, portanto, você queria ter uma matriz de
strings , e acabou tendo de ficar com um
array de
arrays de
strings , que se desdobra ainda mais em
array de
arrays (matriz) de
arrays de caracteres (
string ).
É claro que você sabia disso desde o começo, mas eu espero que as explicações acima tenham ajudado a entender
por que é assim.
Quanto a questão de como inicializar valores para o
array no momento da declaração, penso que também é interessante pensar de um modo
bottom-up .
O caso mais simples é quando você tem um
array de escalares. Nesse caso, a forma mais geral da declaração seria mais ou menos a seguinte.
nome_do_tipo nome_do_array[N ]={valor_0 , valor_1 , valor_2 , ..., valor_(N-1) };
No caso,
N é um valor inteiro e positivo, e a lista de valores pode até
N elementos válidos para o tipo
nome_do_tipo , e cujos índices variam de
0 a
N-1 . Se a lista de valores estiver presente, o valor de
N pode omitido de entre os colchetes, de modo a ser calculado automaticamente pelo compilador, por meio de uma contagem da quantidade de elementos na lista. Se o valor de
N estiver presente entre os colchetes, a lista não precisa conter exatamente
N elementos: os primeiros elementos do
array serão ocupados pelos elementos da lista, e os demais valores fora da lista serão ocupados com o valor
default do tipo
nome_do_tipo (geralmente zero).
void f(void){
No caso particular de
arrays de
char , o C permite outra sintaxe, para favorecer o uso de
strings , que é especificando o conteúdo da
string entre aspas. As quatro declarações abaixo declaram
strings com conteúdo idêntico.
char str1[6]="Paulo";
Além disso, no caso de
arrays de
arrays , a atribuição de valores iniciais leva em consideração que cada elemento do
array de nível mais externo (i.e. aquele cujo índica fica mais à esquerda) é também um
array . A declaração abaixo traz alguns exemplos.
int mat1[3][4]={ {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12} }; // Ou seja: mat1[0]={1, 2, 3, 4}, mat1[1]={5, 6, 7, 8}, mat1[2]={9, 10, 11, 12}.
