C Ponteiros com string em C

Bomfz · 25 de abril de 2021

Bom dia pessoal! Estou precisando de uma ajuda, quem puder me dar um help eu agradeceria muito!

Fiz o seguinte código que tem a ideia de indentar um código que está dentro da string, isso por meio de uma função. porém ainda estou meio confuso com ponteiros, e não estou conseguindo passar a variável "aux5", que representa o resultado final do código, para a minha main, para poder exibi-lo por meio do "printf", alguém pode me ajudar?

#include <stdio.h>
#include <stdlib.h>

void identar(char codigo[1000]){
char codigo2[1000], codigo3[1000], codigo4[1000], codigo5[1000], codigo6[1000], codigo7[1000], codigo8[1000], codigo9[1000], codigo10[1000], codigo11[1000];
char aux[1000],aux2[1000],aux3[1000],aux4[1000],aux5[1000];
int i, n, x, y, z;
while(codigo[i]!='{'){
	codigo2[i]=codigo[i];
	i++;
}
codigo2[i++]='{';
codigo2[i++]='\n';
codigo2[i++]='\t';

for(n=0; n<50; n++){
	codigo3[n]=codigo[x+8];
	x++;
}
//--------------------------------------------------------------------------------------------------------------------//
i=0;
n=0;
x=0;
while(codigo3[i]!=';'){
	codigo4[i]=codigo3[i];
	i++;
}
codigo4[i++]=';';
codigo4[i++]='\n';
codigo4[i++]='\t';

for(n=0; n<50; n++){
	codigo5[n]=codigo3[x+11];
	x++;
}
//--------------------------------------------------------------------------------------------------------------------//
i=0;
n=0;
x=0;
while(codigo5[i]!='{'){
	codigo6[i]=codigo5[i];
	i++;
}
codigo6[i++]='{';
codigo6[i++]='\n';
codigo6[i++]='\t';
codigo6[i++]='\t';

for(n=0; n<50; n++){
	codigo7[n]=codigo5[x+12];
	x++;
}
//--------------------------------------------------------------------------------------------------------------------//
i=0;
n=0;
x=0;
while(codigo7[i]!=';'){
	codigo8[i]=codigo7[i];
	i++;
}
codigo8[i++]=';';
codigo8[i++]='\n';
codigo8[i++]='\t';

for(n=0; n<50; n++){
	codigo9[n]=codigo7[x+13];
	x++;
}
//--------------------------------------------------------------------------------------------------------------------//
i=0;
n=0;
x=0;
while(codigo9[i]!='}'){
	codigo10[i]=codigo9[i];
	i++;
}
codigo10[i++]='}';
codigo10[i++]='\n';


for(n=0; n<50; n++){
	codigo11[n]=codigo9[x+1];
	x++;
}
//-------------------------------------------------------CONCATENANDO----------------------------------------------------//
y=0;
z=0;

while(codigo2[y]!='\0'){
	aux[y]=codigo2[y];
	y++;
}
while(codigo4[z]!='\0'){
	aux[y++]=codigo4[z++];
}
aux[y]='\0';
//-------------------------------------------------------CONCATENANDO----------------------------------------------------//
y=0;
z=0;

while(aux[y]!='\0'){
	aux2[y]=aux[y];
	y++;
}
while(codigo6[z]!='\0'){
	aux2[y++]=codigo6[z++];
}
aux2[y]='\0';
//-------------------------------------------------------CONCATENANDO----------------------------------------------------//
y=0;
z=0;

while(aux2[y]!='\0'){
	aux3[y]=aux2[y];
	y++;
}
while(codigo8[z]!='\0'){
	aux3[y++]=codigo8[z++];
}
aux3[y]='\0';
//-------------------------------------------------------CONCATENANDO----------------------------------------------------//
y=0;
z=0;

while(aux3[y]!='\0'){
	aux4[y]=aux3[y];
	y++;
}
while(codigo10[z]!='\0'){
	aux4[y++]=codigo10[z++];
}
aux4[y]='\0';
//-------------------------------------------------------CONCATENANDO----------------------------------------------------//
y=0;
z=0;

while(aux4[y]!='\0'){
	aux5[y]=aux4[y];
	y++;
}
while(codigo11[z]!='\0'){
	aux5[y++]=codigo11[z++];
}
aux5[y]='\0';

printf("\n%s", aux5);
	
}


main(){
	char codigo[1000] = "main() {int a = 10;while(true){printf('ok');}}";
	printf("STRING ORIGINAL!\n\n");
    printf("%s", &codigo);
    
    identar(codigo);
    printf("\nSTRING MODIFICADA!\n\n");
    printf("%s", &codigo);

}

Segue anexo que como deveria ser a saída do código:

Lucca Rodrigues · 25 de abril de 2021

@Bomfz

31 minutos atrás, Bomfz disse:

ainda estou meio confuso com ponteiros

Mas você não usou ponteiros

A string codigo não será modificada se você não passar o endereço de algum elemento para a função, normalmente se faz isso do jeito que você fez mesmo, ou assim: &codigo[0], daria no mesmo, está passando o endereço do primeiro elemento.

No parâmetro da função, declare um ponteiro do mesmo tipo de codigo, então seria um ponteiro pra char.

Aliás, evite isso:

39 minutos atrás, Bomfz disse:

char codigo2[1000], codigo3[1000], codigo4[1000], codigo5[1000], codigo6[1000], codigo7[1000], codigo8[1000], codigo9[1000], codigo10[1000], codigo11[1000]; char aux[1000],aux2[1000],aux3[1000],aux4[1000],aux5[1000];

Não tem razão em fazer dessa forma.

Declare um ponteiro, chame malloc(), e se precisar de mais espaço, chame realloc(). Se é que precisa mesmo fazer assim.

Se quiser modificar a string codigo, faça isso sem excede-la, então pode inserir até 999 caracteres não-nulos.

Você pode retornar um ponteiro pra char em vez de deixar a função do tipo void. Uma função que não retorna nada é um desperdício.

46 minutos atrás, Bomfz disse:
printf("%s", &codigo);

Pra que o & aí? Você tinha feito certo aqui:

53 minutos atrás, Bomfz disse:
printf("\n%s", aux5);

O fim da string se dá no primeiro caractere nulo, então a mesma será impressa até que um 0 seja encontrado.

Bomfz · 25 de abril de 2021

14 minutos atrás, Lucca Rodrigues disse:

@Bomfz

Mas você não usou ponteiros

A string codigo não será modificada se você não passar o endereço de algum elemento para a função, normalmente se faz isso do jeito que você fez mesmo, ou assim: &codigo[0], daria no mesmo, está passando o endereço do primeiro elemento.

No parâmetro da função, declare um ponteiro do mesmo tipo de codigo, então seria um ponteiro pra char.

Aliás, evite isso:

Não tem razão em fazer dessa forma.

Declare um ponteiro, chame malloc(), e se precisar de mais espaço, chame realloc(). Se é que precisa mesmo fazer assim.

Se quiser modificar a string codigo, faça isso sem excede-la, então pode inserir até 999 caracteres não-nulos.

Você pode retornar um ponteiro pra char em vez de deixar a função do tipo void. Uma função que não retorna nada é um desperdício.

Pra que o & aí? Você tinha feito certo aqui:

O fim da string se dá no primeiro caractere nulo, então a mesma será impressa até que um 0 seja encontrado.

@Lucca Rodrigues

Bom dia Lucca, cara eu n tinha colocado ponteiros porque tentei usar e n tive sucesso. A ideia no caso seria de eliminar esse printf que está dentro da função, o que exibe o aux5 no caso, para exibir a resposta final pelo ultimo printf da main. tentei fazer umas alterações no código e o que cheguei até agr foi isso:

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>

char indentar(char *codigo[1000]){
char codigo2[1000], codigo3[1000], codigo4[1000], codigo5[1000], codigo6[1000], codigo7[1000], codigo8[1000], codigo9[1000], codigo10[1000], codigo11[1000];
char aux[1000],aux2[1000],aux3[1000],aux4[1000],aux5[1000];
int i, n, x, y, z;
while(*codigo[i]!='{'){
	codigo2[i]=*codigo[i];
	i++;
}
codigo2[i++]='{';
codigo2[i++]='\n';
codigo2[i++]='\t';

for(n=0; n<50; n++){
	codigo3[n]=*codigo[x+8];
	x++;
}
//--------------------------------------------------------------------------------------------------------------------//
i=0;
n=0;
x=0;
while(codigo3[i]!=';'){
	codigo4[i]=codigo3[i];
	i++;
}
codigo4[i++]=';';
codigo4[i++]='\n';
codigo4[i++]='\t';

for(n=0; n<50; n++){
	codigo5[n]=codigo3[x+11];
	x++;
}
//--------------------------------------------------------------------------------------------------------------------//
i=0;
n=0;
x=0;
while(codigo5[i]!='{'){
	codigo6[i]=codigo5[i];
	i++;
}
codigo6[i++]='{';
codigo6[i++]='\n';
codigo6[i++]='\t';
codigo6[i++]='\t';

for(n=0; n<50; n++){
	codigo7[n]=codigo5[x+12];
	x++;
}
//--------------------------------------------------------------------------------------------------------------------//
i=0;
n=0;
x=0;
while(codigo7[i]!=';'){
	codigo8[i]=codigo7[i];
	i++;
}
codigo8[i++]=';';
codigo8[i++]='\n';
codigo8[i++]='\t';

for(n=0; n<50; n++){
	codigo9[n]=codigo7[x+13];
	x++;
}
//--------------------------------------------------------------------------------------------------------------------//
i=0;
n=0;
x=0;
while(codigo9[i]!='}'){
	codigo10[i]=codigo9[i];
	i++;
}
codigo10[i++]='}';
codigo10[i++]='\n';


for(n=0; n<50; n++){
	codigo11[n]=codigo9[x+1];
	x++;
}
//-------------------------------------------------------CONCATENANDO----------------------------------------------------//
y=0;
z=0;

while(codigo2[y]!='\0'){
	aux[y]=codigo2[y];
	y++;
}
while(codigo4[z]!='\0'){
	aux[y++]=codigo4[z++];
}
aux[y]='\0';
//-------------------------------------------------------CONCATENANDO----------------------------------------------------//
y=0;
z=0;

while(aux[y]!='\0'){
	aux2[y]=aux[y];
	y++;
}
while(codigo6[z]!='\0'){
	aux2[y++]=codigo6[z++];
}
aux2[y]='\0';
//-------------------------------------------------------CONCATENANDO----------------------------------------------------//
y=0;
z=0;

while(aux2[y]!='\0'){
	aux3[y]=aux2[y];
	y++;
}
while(codigo8[z]!='\0'){
	aux3[y++]=codigo8[z++];
}
aux3[y]='\0';
//-------------------------------------------------------CONCATENANDO----------------------------------------------------//
y=0;
z=0;

while(aux3[y]!='\0'){
	aux4[y]=aux3[y];
	y++;
}
while(codigo10[z]!='\0'){
	aux4[y++]=codigo10[z++];
}
aux4[y]='\0';
//-------------------------------------------------------CONCATENANDO----------------------------------------------------//
y=0;
z=0;

while(aux4[y]!='\0'){
	aux5[y]=aux4[y];
	y++;
}
while(codigo11[z]!='\0'){
	aux5[y++]=codigo11[z++];
}
aux5[y]='\0';
//-------------------------------------------------------PASSANDO aux5 PARA codigo----------------------------------------------------//
int a=0;
while(aux5[a]!='\0'){
	*codigo[a]=aux5[a];
	i++;
}
	
}


main(){
	char codigo[1000] = "main() {int a = 10;while(true){printf('ok');}}";
	char codigofinal[1000];
	printf("STRING ORIGINAL!\n\n");
    printf("%s", &codigo);
    
    indentar(codigo);
    printf("\nSTRING MODIFICADA!\n\n");
    printf("%s", codigo);

}

Mas ele dá erro quando chega nessa linha da main( E o código não compila ):

    indentar(codigo);

Sobre a questão do malloc e do realloc, essas foram funções que ainda n vi, então não sei muito bem do que se trata, mas darei uma estudada sim para tentar manter uma organização melhor do código!

E sobre o uso do "&", realmente após o que você disse vi que realmente n se torna necessário nesse caso, e já vou corrigir.

segue anexo do que aparece quando tento compilar o codigo:

arfneto · 25 de abril de 2021

4 horas atrás, Bomfz disse:

Fiz o seguinte código que tem a ideia de indentar um código que está dentro da string, isso por meio de uma função. porém ainda estou meio confuso com ponteiros, e não estou conseguindo passar a variável "aux5", que representa o resultado final do código, para a minha main, para poder exibi-lo por meio do "printf", alguém pode me ajudar?

Olá!

Você deve explicar o que pretende fazer, de modo que alguém possa entender se o programa faz isso e te ajudar

Uma maneira simples é explicar o que quer fazer com TAB espaços e newlines, mostrar algumas strings antes e depois se tudo fosse como você gostaria.

Entenda que é trivial ler arquivos em C, muito mais simples que ler do teclado por exemplo, e um programa assim só faz sentido afinal se puder alinhar um texto em C, nem que seja de uma linha só.

Usando seu exemplo

	char codigo[1000] = "main() {int a = 10;while(true){printf('ok');}}";

podia gerar

\tmain()
{
\tint a = 10;
\twhile(true)
\t{
\t\tprintf('ok');
\t}
}

num arquivo de saida ou na tela e seria talvez mais gratificante

De volta ao programa

Use nomes mais expressivos. É difícil ter sucesso com aux e aix1 e aux2 ou codigon...

Note que C só tem uma dimensão de vetores, mas podem ser vetores de vetores....

	char codigo2[1000], codigo3[1000], codigo4[1000], 
         codigo5[1000], codigo6[1000], codigo7[1000], 
         codigo8[1000], codigo9[1000], codigo10[1000], codigo11[1000];
	char aux[1000], aux2[1000], aux3[1000], aux4[1000], aux5[1000];

podia ser

	char codigo[1000][10];
	char auxiliar[1000][5];

Entenda que

    char indentar(char*                            codigo[1000]);

declara indentar() como uma função que recebe um vetor codigo com 1000 ponteiros para char, e provavelmente não é isso o que você quer. Aumentei a distância entre o tipo e o nome para ajudar a entender.

E quando chama aqui

	char codigo[1000] = "main() {int a = 10;while(true){printf('ok');}}";
	char codigofinal[1000];
	printf("STRING ORIGINAL!\n\n");
	printf("%s", &codigo);

	indentar(codigo);

codigo é um vetor de 1000 char. Então um dos dois está errado e o compilador vai claro reclamar

Bomfz · 25 de abril de 2021

1 hora atrás, arfneto disse:
Olá!

Você deve explicar o que pretende fazer, de modo que alguém possa entender se o programa faz isso e te ajudar

Uma maneira simples é explicar o que quer fazer com TAB espaços e newlines, mostrar algumas strings antes e depois se tudo fosse como você gostaria.

Entenda que é trivial ler arquivos em C, muito mais simples que ler do teclado por exemplo, e um programa assim só faz sentido afinal se puder alinhar um texto em C, nem que seja de uma linha só.

Usando seu exemplo
	char codigo[1000] = "main() {int a = 10;while(true){printf('ok');}}";
podia gerar
\tmain()
{
\tint a = 10;
\twhile(true)
\t{
\t\tprintf('ok');
\t}
}
num arquivo de saida ou na tela e seria talvez mais gratificante

De volta ao programa

Use nomes mais expressivos. É difícil ter sucesso com aux e aix1 e aux2 ou codigon...

Note que C só tem uma dimensão de vetores, mas podem ser vetores de vetores....
	char codigo2[1000], codigo3[1000], codigo4[1000], 
         codigo5[1000], codigo6[1000], codigo7[1000], 
         codigo8[1000], codigo9[1000], codigo10[1000], codigo11[1000];
	char aux[1000], aux2[1000], aux3[1000], aux4[1000], aux5[1000];
podia ser
	char codigo[1000][10];
	char auxiliar[1000][5];
Entenda que
    char indentar(char*                            codigo[1000]);
declara indentar() como uma função que recebe um vetor codigo com 1000 ponteiros para char, e provavelmente não é isso o que você quer. Aumentei a distância entre o tipo e o nome para ajudar a entender.

E quando chama aqui
	char codigo[1000] = "main() {int a = 10;while(true){printf('ok');}}";
	char codigofinal[1000];
	printf("STRING ORIGINAL!\n\n");
	printf("%s", &codigo);

	indentar(codigo);
codigo é um vetor de 1000 char. Então um dos dois está errado e o compilador vai claro reclamar

Boa tarde @arfneto !

Então, o que pretendo fazer com o código é que eu possa usar um ponteiro da string 'codigo' para a função, de modo que as alterações para a indentação dessa string sejam feitas também na main, assim podendo exibir com o printf o antes e o depois.

Sobre o exemplo de indentação, realmente, se eu estivesse programando usaria somente os '\n', porém a orientação que recebi do professor era de exibi-lo usando os tabs também, por criei o código para organizar dessa forma.

Sobre os vetores, realmente você tem razão, não tinha pensado em usar matrizes e realmente trará maior organização para o código.

Sobre os ponteiros, realmente, só pude entender o erro após sua explicação! Foi de grande ajuda, e ajudou até no meu entendimento sobre o assunto de funcionamento dos ponteiros! Muito obrigado!

A nível de curiosidade, vou mandar como ficou o código, e mais tarde com certeza farei as alterações na matriz. Mais uma vez, Obrigado!

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>

void indentar(char codigo[1000]){
char codigo2[1000], codigo3[1000], codigo4[1000], codigo5[1000], codigo6[1000], codigo7[1000], codigo8[1000], codigo9[1000], codigo10[1000], codigo11[1000];
char aux[1000],aux2[1000],aux3[1000],aux4[1000],aux5[1000];
int i, n, x, y, z, a;
while(codigo[i]!='{'){
	codigo2[i]=codigo[i];
	i++;
}
codigo2[i++]='{';
codigo2[i++]='\n';
codigo2[i++]='\t';

for(n=0; n<50; n++){
	codigo3[n]=codigo[x+8];
	x++;
}
//--------------------------------------------------------------------------------------------------------------------//
i=0;
n=0;
x=0;
while(codigo3[i]!=';'){
	codigo4[i]=codigo3[i];
	i++;
}
codigo4[i++]=';';
codigo4[i++]='\n';
codigo4[i++]='\t';

for(n=0; n<50; n++){
	codigo5[n]=codigo3[x+11];
	x++;
}
//--------------------------------------------------------------------------------------------------------------------//
i=0;
n=0;
x=0;
while(codigo5[i]!='{'){
	codigo6[i]=codigo5[i];
	i++;
}
codigo6[i++]='{';
codigo6[i++]='\n';
codigo6[i++]='\t';
codigo6[i++]='\t';

for(n=0; n<50; n++){
	codigo7[n]=codigo5[x+12];
	x++;
}
//--------------------------------------------------------------------------------------------------------------------//
i=0;
n=0;
x=0;
while(codigo7[i]!=';'){
	codigo8[i]=codigo7[i];
	i++;
}
codigo8[i++]=';';
codigo8[i++]='\n';
codigo8[i++]='\t';

for(n=0; n<50; n++){
	codigo9[n]=codigo7[x+13];
	x++;
}
//--------------------------------------------------------------------------------------------------------------------//
i=0;
n=0;
x=0;
while(codigo9[i]!='}'){
	codigo10[i]=codigo9[i];
	i++;
}
codigo10[i++]='}';
codigo10[i++]='\n';


for(n=0; n<50; n++){
	codigo11[n]=codigo9[x+1];
	x++;
}
//-------------------------------------------------------CONCATENANDO----------------------------------------------------//
y=0;
z=0;

while(codigo2[y]!='\0'){
	aux[y]=codigo2[y];
	y++;
}
while(codigo4[z]!='\0'){
	aux[y++]=codigo4[z++];
}
aux[y]='\0';
//-------------------------------------------------------CONCATENANDO----------------------------------------------------//
y=0;
z=0;

while(aux[y]!='\0'){
	aux2[y]=aux[y];
	y++;
}
while(codigo6[z]!='\0'){
	aux2[y++]=codigo6[z++];
}
aux2[y]='\0';
//-------------------------------------------------------CONCATENANDO----------------------------------------------------//
y=0;
z=0;

while(aux2[y]!='\0'){
	aux3[y]=aux2[y];
	y++;
}
while(codigo8[z]!='\0'){
	aux3[y++]=codigo8[z++];
}
aux3[y]='\0';
//-------------------------------------------------------CONCATENANDO----------------------------------------------------//
y=0;
z=0;

while(aux3[y]!='\0'){
	aux4[y]=aux3[y];
	y++;
}
while(codigo10[z]!='\0'){
	aux4[y++]=codigo10[z++];
}
aux4[y]='\0';
//-------------------------------------------------------CONCATENANDO----------------------------------------------------//
y=0;
z=0;

while(aux4[y]!='\0'){
	aux5[y]=aux4[y];
	y++;
}
while(codigo11[z]!='\0'){
	aux5[y++]=codigo11[z++];
}
aux5[y]='\0';

//----------------------------------------------------------PASSANDO DE aux5 PARA codigo----------------------------------------------------

for(a=0; aux5[a]!='\0'; a++){

codigo[a]=aux5[a];
}

}


main(){
	char codigo[1000] = "main() {int a = 10;while(true){printf('ok');}}";
	char *cod;
	cod = codigo;
	printf("STRING ORIGINAL!\n\n");
    printf("%s", &codigo);
    
    indentar(cod);
    printf("\n\nSTRING MODIFICADA!\n\n");
    printf("%s", &codigo);

}

arfneto · 25 de abril de 2021

4 horas atrás, Bomfz disse:

Sobre o exemplo de indentação, realmente, se eu estivesse programando usaria somente os '\n', porém a orientação que recebi do professor era de exibi-lo usando os tabs também, por criei o código para organizar dessa forma

Não entendi o que significa. Mostre um exemplo, como eu fiz. "exibir usando tabs" é uma expressão curiosa, já que eles não são exibidos e não há como diferenciar um TAB de um espaço porque são "transparentes".

No exemplo eu deixei

\tmain()
{
\tint a = 10;
\twhile(true)
\t{
\t\tprintf('ok');
\t}
}

mas isso é o que você veria. com TAB ou espaços, na saída de seu programa

main()
{
	int a = 10;
	while(true)
	{
		printf('ok');
	}
}

4 horas atrás, Bomfz disse:

Sobre os vetores, realmente você tem razão, não tinha pensado em usar matrizes e realmente trará maior organização para o código

4 horas atrás, Bomfz disse:

A nível de curiosidade, vou mandar como ficou o código, e mais tarde com certeza farei as alterações na matriz

Como eu disse, C não tem "matrizes" como FORTRAN, apenas vetores. E você deve usar antes em seu programa para que ele fique pronto antes e certo antes, e não deixar para alterar depois. Não vai aprender nada fazendo assim. Seu programa fica ruim e difícil de ler. E não vai gostar de ver isso em se computador daqui uma semana, porque é muito, mas muito mais fácil fazer usando como te mostrei.

Ainda sobre seu programa

main() deve ser a primeira função de seu programa
em especial enquanto está aprendendo deve sempre usar -Wall como opção em seu compilador. Eu sempre uso, Em indentar() por exemplo está usando (codigo[ i ] no loop SEM NUNCA TER POSTO UM VALOR LÁ e essa em geral é uma ideia infeliz. Nunca faça isso

nunca use a variável de controle de um loop fora do loop podendo evitar. Isso:

	for (n = 0; n < 50; n++) {
		codigo9[n] = codigo7[x + 13];
		x++;
	}

é ruim. Use sempre

	for (int n = 0; n < 50; n++) {
		codigo9[n] = codigo7[x + 13];
		x++;
	}

E prefira sempre

    char*	indentar(char* cod);

É o que se espera em C. E entenda que ao escrever assim

	indentar(cod);

se der uma m3rd@ você perdeu o que tinha em cod pra testar de novo ou comparar via programa....

Isso é o que se quer escrever em geral:

	char*	nova = indentar( antiga );

O programa está melhor que antes, sim. Mas tem um longo caminho ainda.

Entrar

C Ponteiros com string em C

Posts recomendados

Bomfz

Lucca Rodrigues

Bomfz

arfneto

Bomfz

arfneto

Crie uma conta ou entre para comentar

Criar uma conta

Entrar

Quem está navegando aqui 0 usuários estão online

Últimos tópicos

Livros

Cursos

Conteúdo recente

Sobre o Clube do Hardware

Direitos autorais

Mais

Fórum

Atividades

Artigos

Análises

Livros

Cursos