Como declarar corretamente char* em C [RESOLVIDO]

paulo1205
(usa Ubuntu)

Enviado em 07/11/2021 - 20:14h

char *Matriz[3][2] = {

   {"Texto1", ""}, // {"Texto1", "", 0}, Preciso declarar assim?

   {"Texto2", ""},

   {"Texto3", ""},

}; 

#include <stdio.h>



char *Matriz[3][2] = {

   {"Texto1", ""}, // {"Texto1", "", 0}, Preciso declarar assim?

   {"Texto2", ""},

   {"Texto3", ""},

};



int main(void){

    Matriz[0][0][2]='s';  // Tenta transformar "Texto1" em "Testo1". Posso fazê-lo?

} 

$ g++ -Wall -Werror -O2 -pedantic-errors x.c -o x

x.c:7:1: error: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]

 };

 ^

x.c:7:1: error: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]

x.c:7:1: error: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]

x.c:7:1: error: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]

x.c:7:1: error: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]

x.c:7:1: error: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings] 

gcc -Wall -Werror -O2 -pedantic-errors x.c -o x  # Compila sem erro.



$ ./x  # Executa o código compilado acima.

Segmentation fault (core dumped) 

#include <stdio.h>



const char *Matriz[3][2] = { {"Texto1", ""}, {"Texto2", ""}, {"Texto3", ""} };



int main(void){

    // Se descomentada, a linha abaixo seria um erro, pois agora os caracteres apontados por cada elemento são constantes.

    /*Matriz[0][0][2]='s';*/



    // Isto é possível, pois usamos o ponteiro apenas para ler um caráter, não para modificá-lo.

    return Matriz[0][0][2];  // Vai retornar o valor 120 (correspondente a 'x').

} 

#include <stddef.h>

#include <string.h>



// Declara algumas strings (arrays de caracteres incluindo byte terminador) não-constantes.

char sv1[]="Teste1", sv2[]="Teste2";



// Declara algumas strings (arrays de caracteres incluindo byte terminador) constantes.

const char sc1[]="TesteC1", sc2[]="TesteC2";



// Declara alguns arrays com elementos variáveis que não são strings (falta o byte terminador).

char av1[4]={'T','S','T','1'}, av2[4]={'T','S','T','2'};



// Declara alguns arrays com elementos constantes que não são strings (falta o byte terminador).

const char ac1[4]={'C','N','T','1'}, ac2[4]={'C','N','T','2'};





// Declara matriz de ponteiros (não-constantes) para caracteres (não-constantes).

// Nas listas de inicialização de elementos, não convém (em C++, não podemos) usar constantes literais entre aspas,

// já que os ponteiros não indicam dados constantes, mas podemos usar ponteiros para dados não-constantes, tais como

// as conversões a partir de arrays de caracteres não-constantes (sejam eles strings ou não), e o ponteiro nulo.

char *Matriz1[3][2]={ {sv1, sv2}, {av1, av2}, {NULL, NULL} };



// Declara matriz de ponteiros (não-constantes) para caracteres constantes.

// Nas listas de inicialização, podemos usar constantes literais entre aspas, já que os ponteiros indicam dados

// constantes, além de todos os outros casos de ponteiros para dados constantes ou variáveis, tais como os obtidos

// a partir de arrays, quer constituam strings ou não, e mais o ponteiro nulo.

const char *Matriz2[3][2]={ {"Texto1", sc1}, {sv1, ac1}, {av1, NULL} };



// Declara matriz de ponteiros constantes para caracteres (não-constantes).

// Nas listas de inicialização de elementos, não convém (em C++, não podemos) usar constantes literais entre aspas,

// já que os ponteiros, embora constantes, não indicam dados constantes, mas podemos usar ponteiros para dados

// não-constantes, tais como as conversões a partir de arrays de caracteres não-constantes (sejam eles strings

// ou não), e o ponteiro nulo.

char *const Matriz3[3][2]={ {NULL, NULL}, {sv1, sv2}, {av1, av2} };



// Declara matriz de ponteiros constantes para caracteres constantes.

// Nas listas de inicialização, podemos usar constantes literais entre aspas, já que os ponteiros indicam dados

// constantes, além de todos os outros casos de ponteiros para dados constantes ou variáveis, tais como os obtidos

// a partir de arrays, quer constituam strings ou não, e mais o ponteiro nulo.

const char *const Matriz4[3][2]={ {"Texto1", sv2}, {sc2, av2}, {ac2, NULL} };





int main(void){

	size_t l;

	char c;

	char *pc;

	const char *pcc;



	// Com Matriz1, posso fazer:

	pc=Matriz1[0][0];    // Obter o valor de qualquer elemento da matriz e atribuí-lo a um ponteiro para dados não-constantes (mesmo tipo).

	pcc=Matriz1[0][1];   // Obter o valor de qualquer elemento da matriz e atribuí-lo a um ponteiro para dados constantes (tipo compatível).

	c=Matriz1[0][1][0];  // Obter um dado apontado por qualquer elemento que seja um ponteiro válido e que não exceda os limites do dado apontado.

	Matriz1[1][0]=sv2;   // Alterar ponteiro contido em um dos elementos da matriz, desde que o tipo do novo valor seja compatível (não pode ser ponteiro para dados constantes, por exemplo).

	Matriz1[1][1][0]=c;  // Alterar um dado apontado por qualquer elemento que seja um ponteiro válido e que não exceda os limites do dado apontado.



	// Com Matriz1, não posso fazer:

	Matriz1[2][0]="Texto5";  // Alterar ponteiro contido em um dos elementos da matriz para se referir ao conteúdo de uma constante literal entre aspas (o C até permite, mas é periogoso, como já se viu; em C++, dá erro).

	Matriz1[2][0]=pcc;       // Alterar ponteiro contido em um dos elementos da matriz para se referir dados indicados como constantes (aqui, nem mesmo o compilador C deixa passar).



	// O compilador não vai alarmar, mas eu também não devo fazer com Matriz1:

	l=strlen(Matriz1[1][0]);  // Usar dados que não são strings (porque eu sei que não têm o byte terminador) como se fossem strings.

	Matriz1[0][1][100]=c;     // Exceder os limites do conteúdo apontado por um dos elementos da matriz, quer seja para gravar conteúdo...

	c=Matriz1[0][1][100];     // ... quer para ler conteúdo.

	Matriz1[2][1][0]=c;       // Como eu sei que este elemento da matriz contém um ponteiro inválido, não posso usar tal ponteiro para gravar conteúdo...

	c=Matriz1[2][1][0];       // ... nem para ler conteúdo.





	// Com Matriz2, posso fazer:

	pcc=Matriz2[0][0];       // Obter o valor de qualquer elemento da matriz e atribuí-lo a um ponteiro para dados constantes (mesmo tipo).

	c=Matriz2[0][0][0];      // Obter um dado apontado por qualquer elemento que seja um ponteiro válido e que não exceda os limites do dado apontado.

	Matriz2[0][1]="Texto2";  // Alterar ponteiro contido em um dos elementos da matriz para se referir ao conteúdo de uma constante literal entre aspas (tipo compatível).

	Matriz2[1][0]=sv2;       // Alterar ponteiro contido em um dos elementos da matriz (o ponteiro original pode apontar para dados constantes ou dados variáveis).

	Matriz2[1][1]=pcc;       // Alterar ponteiro contido em um dos elementos da matriz para se referir dados indicados como constantes (aqui, nem mesmo o compilador C deixa passar).



	// Com Matriz2, não posso fazer:

	pc=Matriz2[0][0];    // Obter o valor de qualquer elemento da matriz e atribuí-lo a um ponteiro para dados não-constantes (tipo incompatível).

	Matriz2[1][1][0]=c;  // Alterar um dado apontado por qualquer elemento, independentemente do valor do ponteiro.



	// O compilador não vai alarmar, mas eu também não devo fazer com Matriz2:

	l=strlen(Matriz2[2][0]);  // Usar dados que não são strings (porque eu sei que não têm o byte terminador) como se fossem strings.

	c=Matriz2[0][1][100];     // Exceder os limites do conteúdo apontado por um dos elementos da matriz, mesmo que somente para ler conteúdo.

	c=Matriz2[2][1][0];       // Como eu sei que este elemento da matriz contém um ponteiro inválido, não posso usar tal ponteiro nem mesmo para ler conteúdo.





	// Com Matriz3, posso fazer:

	pc=Matriz3[1][0];    // Obter o valor de qualquer elemento da matriz e atribuí-lo a um ponteiro para dados não-constantes (mesmo tipo).

	pcc=Matriz3[1][1];   // Obter o valor de qualquer elemento da matriz e atribuí-lo a um ponteiro para dados constantes (tipo compatível).

	c=Matriz3[1][1][0];  // Obter um dado apontado por qualquer elemento que seja um ponteiro válido e que não exceda os limites do dado apontado.

	Matriz3[2][1][0]=c;  // Alterar um dado apontado por qualquer elemento que seja um ponteiro válido e que não exceda os limites do dado apontado, pois embora os elementos da matriz sejam constantes, os conteúdos apontados não o são.



	// Com Matriz3, não posso fazer:

	Matriz3[1][0]=sv2;  // Alterar ponteiro contido em um dos elementos da matriz, mesmo que o tipo do novo valor seja compatível, pois os elementos são constantes, ainda que os dados apontados não o sejam.



	// O compilador não vai alarmar, mas eu também não devo fazer com Matriz3:

	l=strlen(Matriz3[2][1]);  // Usar dados que não são strings (porque eu sei que não têm o byte terminador) como se fossem strings.

	Matriz3[1][1][100]=c;     // Exceder os limites do conteúdo apontado por um dos elementos da matriz, quer seja para gravar conteúdo...

	c=Matriz3[1][1][100];     // ... quer para ler conteúdo.

	Matriz3[0][0][0]=c;       // Como eu sei que este elemento da matriz contém um ponteiro inválido, não posso usar tal ponteiro para gravar conteúdo...

	c=Matriz3[0][0][0];       // ... nem para ler conteúdo.





	// Com Matriz4, posso fazer:

	pcc=Matriz4[0][0];   // Obter o valor de qualquer elemento da matriz e atribuí-lo a um ponteiro para dados constantes (mesmo tipo).

	c=Matriz4[0][0][0];  // Obter um dado apontado por qualquer elemento que seja um ponteiro válido e que não exceda os limites do dado apontado.



	// Com Matriz4, não posso fazer:

	pc=Matriz4[0][0];        // Obter o valor de qualquer elemento da matriz e atribuí-lo a um ponteiro para dados não-constantes (tipo incompatível).

	Matriz4[0][1]="Texto2";  // Alterar ponteiro contido em um dos elementos da matriz, mesmo que o tipo do novo valor seja compatível, pois os elementos são constantes, ainda que os dados apontados não o sejam.

	Matriz4[1][1][0]=c;      // Alterar um dado apontado por qualquer elemento, independentemente do valor do ponteiro.



	// O compilador não vai alarmar, mas eu também não devo fazer com Matriz4:

	l=strlen(Matriz4[2][0]);  // Usar dados que não são strings (porque eu sei que não têm o byte terminador) como se fossem strings.

	c=Matriz4[0][1][100];     // Exceder os limites do conteúdo apontado por um dos elementos da matriz, mesmo que somente para ler conteúdo.

	c=Matriz4[2][1][0];       // Como eu sei que este elemento da matriz contém um ponteiro inválido, não posso usar tal ponteiro nem mesmo para ler conteúdo.

} 

char str1[6]="Teste";  // Tamanho do array é 6, suficiente para os 5 do texto mais o byte nulo. Válido em C e em C++.

char str2[]="Teste";   // Tamanho do array calculado automaticamente como 6, a partir dois 5 visíveis entre aspas, mais o nulo implícito. Válido em C e em C++.

char arr3[5]="Teste";  // Tamanho do array é 5. Válido em C, que suprime o byte nulo (sem o nulo, esse array não pode ser considerado como string!), mas ERRO em C++ por não acomodar os 6 caracteres referentes aos 5 do texto visível mais o nulo implícito.

char arr4[4]="Teste".  // Tamanho do array é 4. ERRO tanto em C quanto em C++, por não acomodar nem mesmo os caracteres visíveis da constante literal entre aspas.