Ir ao conteúdo
  • Cadastre-se

C criar código c associando letras a-z e num 1-26 e somar a palavra no final


Ir à solução Resolvido por arfneto,

Posts recomendados

é mais ou menos como descrito no titulo, quero criar um código que associe cada numero a letra em ordem crescente a=1, b=2 até z=26;

e ao rodar ele peça para voce digitar uma palavra dai ele faz a soma das letras dessa palavra.

ex.:  baba = 6  porque b=2 a=1 =b2 a=1

Link para o post
Compartilhar em outros sites
  • Membro VIP

Mostre o que você tentou fazer. Dica: cada letra tem seu código numérico asc-ii. Uma subtração simples converte de letra pro número que você quer.

Link para o post
Compartilhar em outros sites
51 minutos atrás, .if disse:

Mostre o que você tentou fazer. Dica: cada letra tem seu código numérico asc-ii. Uma subtração simples converte de letra pro número que você quer.

o problema é na hora de ler a palavra e somar, não faço a menor ideia como fazer funcionar de forma que a quantidade de letras fique dinamico sem compremeter o calculo

51 minutos atrás, .if disse:

Mostre o que você tentou fazer. Dica: cada letra tem seu código numérico asc-ii. Uma subtração simples converte de letra pro número que você quer.

@.if <code> #include <stdio.h>

const char numero[]="abcdefghijklmnopqrstuvwxyz";


int main (){
    int i=0;
     int valorfinal[140];
    char a,b,c,d,e,f,g,h;
    int soma;

    while(++i){
        if(numero[i-1]==0) break;
       valorfinal[i+96] = numero[i-1]-('a'-1);


}

printf("meu caro amigo diga o que queres:");
scanf("%c%c%c%c",&a,&b,&c,&d);
soma = valorfinal[a] + valorfinal[b]+ valorfinal[c]+ valorfinal[d];
printf("%d",soma);}  <code>

 

eu sei que meu calculo esta zoado, um exemplo é se voce digitar 3 letras ou menos e deixar um espaço em branco, ele vai bugar, queria saber como resolver isso, só consegui ver o índice do vetor (ex.: valorfinal -> [ ]  <- )  como meio pra fazer a associação entre letra e numero e usar como calculo

Link para o post
Compartilhar em outros sites
31 minutos atrás, bilbol disse:

o problema é na hora de ler a palavra e somar, não faço a menor ideia como fazer funcionar de forma que a quantidade de letras fique dinamico sem compremeter o calculo

 

apenas uma tabela. x = f(x). São 256 valores possiveis para cada "letra" afinal. 

Link para o post
Compartilhar em outros sites
11 minutos atrás, arfneto disse:

 

apenas uma tabela. x = f(x). São 256 valores possiveis para cada "letra" afinal. 

@arfneto não entendo o que diz, só conheço o básico do c, como if switch while, printf essas coisas

Link para o post
Compartilhar em outros sites
34 minutos atrás, bilbol disse:

@arfneto não entendo o que diz, só conheço o básico do c, como if switch while, printf essas coisas

 

É bem mais básico que isso. Não tem nenhum comando. Só uma tabela...

Link para o post
Compartilhar em outros sites
  • Solução

a bem da verdade, se sabe que s

ó vai usar essas 26 letras e em sequência não precisa de nada. Para cada letra em 

    char letra;

o valor será

    int valor = letra - 'a' + 1;

para a entre 'a' e 'z' inclusive, e 0 para qualquer outro valor. Quando letra for 'a' a conta vai dar 'a' - 'a' + 1 que é o esperado 1

 

Mas na prática como tem que testar todas as letras para ver se estão no intervalo pode ser mais simples e MUITO mais rápido simplesmente usar a tabela.

 

E uma conta simples. Matemática, uma planilha apenas. y = f(x). Expliquei algo similar aqui hoje: como tem que testar todas as letras pode somar sempre e assim não precisa testar NUNCA.

 

Vou até postar um exemplo ao final, não como a solução para seu caso mas como uma solução usando uma técnica comum em C e Assembler, porque é muito rápido e não tem contas ou comparações.

 

De volta ao seu programa

 

quase nada do que escreveu faz sentido :( desde esses <code> no meio do código. Não é assim que funciona...

 

const char numero[]="abcdefghijklmnopqrstuvwxyz";

int main (){
    int i=0;
    int valorfinal[140];
    char a,b,c,d,e,f,g,h;
    int soma;

    while(++i)
    {
       if(numero[i-1]==0) break;
       valorfinal[i+96] = numero[i-1]-('a'-1);
    }

 

Muito bom ter usado const char[] para o vetor numero: é esperto declarar como tal tudo que sabe que deve ser constante. Mas como vai usar todas as letras em seguida os códigos também estarão em seguida, de 97 a 126 inclusive. Não precisa deles todos, de 'a' = 97 em diante...

 

Mas

  • se quer apenas a soma, que d1@b0 pretende com um vetor de 140 int chamado valorfinal?
  • porque declarou esses 8 char se vai usar apenas um por vez?
  • porque razão não deu um valor inicial a soma? Tipo 0? Coo vai saber se está certo se não sabe de onde começou?
  • que pretende com while(i++) se i começa com zero? claro que não vai parar nunca
  • e essa conta? numero[i-1] é a letra do vetor constante. Se está subtraindo depois de somar porque não comecóu com i igual a 1 e somou depois?
  • que pretende com scanf() lendo 4 letras por vez? Porque não duas? ou 5? ou 12?
  • porque não testa o retorno de scanf()? não faz sentido seguir sem ler p0rr@ nenhuma. scanf(%c%c%c%c.....) pode retornar o que? -1, 0, 1, 2 3 ou 4. E aí? Não faz diferença?
  • e depois soma 4 valores sem saber se leu ao menos 1
  • e o infeliz que vai ler "meu caro amigo diga o que queres"... Como ele vai adivinhar que ode digitar 4 letras? Percepção extrasensorial?

São muitas coisas para você considerar...

 

Um exemplo:

 

Claro que para "a111z" o valor deve ser 27 então esse programa

 

#include <stdio.h>
char parcela[256]= {0}; // tudo zerado

int main( void )
{
    int soma = 0;
    // arruma o vetor antes de tudo
    for( int i='a'; i <='z';i+=1) parcela[i] = i - 'a' + 1;

    const char* linha_de_teste = "a111z";
    char* p = (char*) linha_de_teste; // a primeira letra, 'a'
    while ( *p != 0 )
    {    // soma o valor correspondente a letra, como esta na tabela
        soma = soma + parcela[ (int) *p ];
        p = p+1; // avanca para a letra seguinte
    };  // while()
    printf("    Para '%s' a soma calculada foi %d\n", linha_de_teste, soma );    
    return 0;
}

 

Deve mostrar

 

toninho@DSK-2009:~/projects/um$ gcc -o tst -Wall -std=c17 f.c
toninho@DSK-2009:~/projects/um$ ./tst
    Para 'a111z' a soma calculada foi 27
toninho@DSK-2009:~/projects/um$ 

 

Assim é.

 

Teste seu programa sempre com constantes e valores conhecidos antes de perder tempo lendo valores e escrevendo coisas na tela. Depois de ter alguma esperança do resultado pode colocar a leitura...

 

Outro exemplo:

 

Já que funcionou agora pode usar recortar e colar e criar outro programa que lê a string e mostra a soma... Sem destruir o programa anterior. É de graça. Não precisa fazer um programa só. Ninguem vai saber.


 

#include <stdio.h>
#include <stdlib.h>
char parcela[256]= {0}; // tudo zerado

int main( void )
{
    int soma = 0;
    // arruma o vetor antes de tudo
    for( int i='a'; i <='z';i+=1) parcela[i] = i - 'a' + 1;

    // desta vez vai ler da console ate vir uma linha em branco
    char    linha[80];

    printf("Entre com a linha para ver a soma: ");
    fgets(linha,80,stdin);
    char* p = linha; // p aponta prara a primeira letra
    while ( *p != 0 ) // 0 marca o fim da string
    {
        soma = soma + parcela[ (int) *p ];
        p = p + 1;
    }
    printf("\nA soma calculada foi %d\n", soma );    
    return 0;
}

 

O loop é o mesmo mas usa fgets() para ler a linha toda...

 

toninho@DSK-2009:~/projects/um$ gcc -o tst -Wall -std=c17 f2.c
toninho@DSK-2009:~/projects/um$ ./tst
Entre com a linha para ver a soma: a

A soma calculada foi 1
toninho@DSK-2009:~/projects/um$ ./tst
Entre com a linha para ver a soma: a z

A soma calculada foi 27
toninho@DSK-2009:~/projects/um$ ./tst
Entre com a linha para ver a soma: a1111a111a3z

A soma calculada foi 29
toninho@DSK-2009:~/projects/um$ 
toninho@DSK-2009:~/projects/um$ 

 

Exemplo 3:

 

Mais recortar e colar guardando f.c e f2.c :) 
 

Esse é mais prático, como se espera de um programa em 😄 apenas passa o valor na linha de comando, usando aspas se ele tiver espaços, claro:
 

#include <stdio.h>
#include <stdlib.h>
char parcela[256]= {0}; // tudo zerado

int main( int argc, char** argv )
{
    if ( argc < 2 )
    {
        printf( "passe o valor na linha do programa!!\n");
        return -1;
    };  // if()

    int soma = 0;
    // arruma o vetor antes de tudo
    for( int i='a'; i <='z';i+=1) parcela[i] = i - 'a' + 1;

    char* p = &argv[1][0]; // p aponta para a primeira letra do argumento
    while ( *p != 0 ) // 0 marca o fim da string
    {
        soma = soma + parcela[ (int) *p ];
        p = p + 1;
    }
    printf("\nA soma calculada foi %d\n", soma );    
    return 0;
}

 

E mostra

 

toninho@DSK-2009:~/projects/um$ gcc -o tst -Wall -std=c17 f3.c
toninho@DSK-2009:~/projects/um$ ./tst
passe o valor na linha do programa!!
toninho@DSK-2009:~/projects/um$ ./tst abab

A soma calculada foi 6
toninho@DSK-2009:~/projects/um$ ./tst "a a a a 1 1 1 1"

A soma calculada foi 4

 

Link para o post
Compartilhar em outros sites
  • Membro VIP

Olha a tabela asc-ii

89a3710ca406392c97651653c6c14deb.jpg

Para transformar 'a' em 1 basta subtrair-lhe 96 algo como 'a'-96=1

 

// Online C compiler to run C program online
#include <stdio.h>
const char numero[]="abcdefghijklmnopqrstuvwxyz";
unsigned char num1,num2,num26;
int main() {
    // Write C code here
    num1=numero[0]-96;
    printf("%d\n",num1);
    num2=numero[1]-96;
    printf("%d\n",num2);
    num26=numero[25]-96;
    printf("%d\n",num26);
    return 0;
}

teste em

https://www.programiz.com/c-programming/online-compiler/

Que lhe sirva de norte🙂

Link para o post
Compartilhar em outros sites
19 minutos atrás, .if disse:

Olha a tabela asc-ii

89a3710ca406392c97651653c6c14deb.jpg

Para transformar 'a' em 1 basta subtrair-lhe 96 algo como 'a'-96=1

 


// Online C compiler to run C program online
#include <stdio.h>
const char numero[]="abcdefghijklmnopqrstuvwxyz";
unsigned char num1,num2,num26;
int main() {
    // Write C code here
    num1=numero[0]-96;
    printf("%d\n",num1);
    num2=numero[1]-96;
    printf("%d\n",num2);
    num26=numero[25]-96;
    printf("%d\n",num26);
    return 0;
}

teste em

https://www.programiz.com/c-programming/online-compiler/

Que lhe sirva de norte🙂

eu ja estou ciente disso eu só não sei como eu faço pra associar a leitura de uma palavra com o calculo da soma tipo printf("Digite um nome"); scanf("%c", nome); printf("%d", somadasletrasdonome);

Link para o post
Compartilhar em outros sites
  • Membro VIP

Outro norte...

Um modo minimalista (não testado) ainda usando seu número[ ]
 

unsigned int i=0,num=0;
while (numero[i++]) num+=numero[i];

 

... e já ia esquecendo... de nada 😑

Link para o post
Compartilhar em outros sites
1 hora atrás, .if disse:

Que lhe sirva de norte🙂

 

Pode ser usado, mas como eu mostrei não precisa da tabela. 'a' vale 'a', basta isso. e a conta é letra - 'a' + 1 apenas, para 'a' entre 97 e 126 inclusive, só que isso não faz diferença. Veja os 3 exemplos que eu mostrei acima...

1 hora atrás, bilbol disse:

eu ja estou ciente disso eu só não sei como eu faço pra associar a leitura de uma palavra com o calculo da soma tipo printf("Digite um nome"); scanf("%c", nome); printf("%d", somadasletrasdonome);

 

Não leu os 3 exemplos que eu mostrei? E a relação de problemas com seu código inicial? São programas funcionais com a execução logo abaixo...

Link para o post
Compartilhar em outros sites

@arfneto primeiramente muito obrigado pela resolução, vi que voce colocou funções extras que eu não conhecia e nem pretendia usar como o char * (não sei o porque desse asterisco) e stdin. Então me diga, seria impossivel fazer este código utilizando apenas loop, printf e scanf? e usando somente int e char sem esse asterisco que eu n sei para o que é.

Link para o post
Compartilhar em outros sites
58 minutos atrás, bilbol disse:

char * (não sei o porque desse asterisco) e stdin. Então me diga, seria impossivel fazer este código utilizando apenas loop, printf e scanf? e usando somente int e char sem esse asterisco que eu n sei para o que é

 

O modo que te mostrei, e mostrei 3 programas, é o normal. O que vai encontrar nos livros e nas empresas e o que roda mais rápido. stdin é o nome da entradaem C, o teclado. E deve imaginar que você devia saber isso, porque você devia: todo programa em C começa com 3 arquivos abertos, stdin, stdout e stderr, a entrada, a saída e a saída de erro.

 

char* indica um ponteiro para um char, como int* indicaria um ponteiro para um int. E o asterisco indica o valor que está dentro do endereço. O contrário disso seria o operador &. Então por exemplo

	int     a = 12;
	int*	pInt = &a;
	int     b = *pInt;

 

  • a vale 12.  e pInt é um ponteiro para int.
  • O valor inicial dele é o endereço de a.
  • b é int e o valor inicial dele é o valor de um int cujo endereço está em pInt, e assim b também vale 12

Você não vai conseguir nada em C ou C++ sem entender esse lance de ponteiro e endereço. Ao invés de tentar resolver sem isso estude isso.

 

Se não entendeu nada dos 3 programas que eu te mostrei pergunte aqui pela linha específica...

 

 

Link para o post
Compartilhar em outros sites
  • Membro VIP

Encerrando minha participação pois o garoto já reconheceu e agradeceu seu mestre, como deve ser...

A tabela asc-ii foi uma tentativa frustrada para lhe mostrar a origem numérica dos caracteres alfanuméricos. Talvez (só talvez) com sua visualização ele perceberia que poderia converter outros caracteres em números e fazer a matemática que quiser. Mas enfim, já vi que dei com os burros n'água (clique se desejar)

Mas mesmo assim senti vontade testar isso - que penso ser o cerne da dúvida do garoto - pra treinar o tico e teco no aspecto minimalismo... sem comentários

const char *numero="abcde";
usigned int soma=0;

int main() {
printf("soma= ");
while (*numero) soma+=*numero++ - 96;
printf("%d",soma);
  
    return 0;
}

E também pra tentar relembrar o conceito de ponteiros, vetores e afins que pra mim são as entidades mas sinistras do c que até hoje me assustam.

 

Boa sorte

  • Curtir 1
Link para o post
Compartilhar em outros sites
3 horas atrás, .if disse:

A tabela asc-ii foi uma tentativa frustrada para lhe mostrar a origem numérica dos caracteres alfanuméricos

 

:)

 

Faz todo sentido usar a tabela ASCII --- dos anos 60 como a tabela EBCDIC --- para mostrar que números como 48 para '0' ou '65' para 'A' não são entidades sobrenaturais e tem uma razão de ser. Ainda mais quando o mundo está ficando tão complicado que a tabela atual de caracteres, chamada Unicode, tem capacidade para pouco mais de 1,1 milhão de letras e acho que cerca de 150.000 já estão em uso :) 

 

Sobre asc-ii

 

Já vi isso escrito como ASC2 ou ASC-2 também, e já ouvi. No entanto lembro que o 'II' indica Information Interchange e não o número 2 em algarismos romanos como o hífen sugere.

 

Sobre o programa

@.if 
espero que não se importe, mas vou usar seu programa para mostrar umas coisas comuns que podem passar despercebidas em C por um tempo quando se está aprendendo


 

image.png.e138aff52ce6ec2e3785805ed4819c21.png

 

Estas são duas versões do (seu) mesmo programa. Em geral é legal incluir tudo, inclusive os #include, de modo que o usuário do forum possa rapidamente recortar e colar o texto e compilar em sua máquina. Apenas para aproveitar a oportunidade ...

 

    const char *numero  ="abcde";

 

Esse vetor na verdade é a palavra que o usuário quer traduzir, e talvez "numero" não seja um bom nome. À direita está como palavra e fica mais claro que o objetivo do programa é obter soma a partir de palavra.
 

É muito importante evitar o uso de variáveis globais, coisas que foram declaradas fora de main() porque ficam válidas durante toda a execução do programa. Isso é proibido em muitos círculos e é um risco de segurança e gera incontáveis problemas. 

 

No programa à direita as declarações estão dentro de main()

 

O que se está declarando nessa linha? numero. E numero é const char*. É isso que está sendo declarado. É claro que se numero é um ponteiro para char *numero é um char, e a declaração é entendida pelo compilador. Mas para o leitor, em especial o leitor aluno, é melhor deixar clara a realidade: numero é const char* e declarar 

 

    const char*    numero  ="abcde";


while (*numero) soma+=*numero++ - 96;

 

Essa linha pode parecer assustadora 😬 para iniciantes porque envolve uma série de coisas que muitas vezes o cara não sabe. E omite algumas que o cara pode demorar para entender, como a noção de prioridade de operadores.

 

  • a condição de saída do loop: *numero
    • qual o tipo de numero? numero é const char* 
    • então *numero é um char, o char que o programa encontra a partir do valor em numero, a noção de ponteiro afinal. Como um envelope com um valor. Em numero tem um valor, um endereço. E nesse endereço tem um char. E o valor dele é *numero. C.
    • Em C 0 e falso e todo o resto é verdadeiro. O loop while então vai rodar enquanto o valor apontado por numero for diferente de zero. Dentro do loop o valor de numero muda, apontando para as sucessivas letras de numero, e fica claro que o nome numero não está bom.
    • a condição então seria, por extenso
      	while ( *numero != 0 )

      e isso funciona porque ao final de toda string tem um zero e o compilador monta isso ao ler numero = "abcde" colocando um zero depois do 'e'. Isso desde que dentro do loop o valor de numero seja incrementado :) 

    • o corpo do loop: o while vai rodar tudo até o próximo ';', ou seja soma+=*numero++ - 96;

    • claro que isso equivale a 
       

          while (*numero) { soma+=*numero++ - 96 };

      com as chaves deixando claro o intervalo. Linhas em branco não fazem diferença.

    • o número mágico 96: as letras tem códigos em sequência como estão na tabela, entre 97 e 126 inclusive. Se 'a' vale 97 na tabela ASCII e o usuário quer atribuir o valor 1 para 'a' então o valor da letra apontada por numero deve ser 97 - 1, que é claro 96. 97 é o código de 'a' então é bem mais claro ler isso como
       

      		'a' - 1

      e o compilador cuida d etrocar isso por 96. O programa gerado será claro o mesmo.

    • 'soma += x' é a mesma coisa que 'soma = soma + x;' apenas é mais compacto em especial se sua variável tiver 12 letras :) . No entanto é mais difícil de ler.

    • *numero++ é folclórico e comum em C. E em C++ está até no nome. Isso quer dizer que vai incrementar o valor depois de atribuir. A posição do ++ ou -- indica se vai operar antes ou depois de usar o valor.
       

          x = 12;
          y = x++;
          // aqui x = 13, mas y = 12
          y = ++x;
          // aqui y = 14, x = 14
        


      Não é assim um ganho enorme. É claro compacto mas pouco legível, E pode ter efeitos colaterais que lembram o que deve ser o 1nfern0.

      • Agora com *numero++ o cara tem que saber a prioridade: o programa vai rodar (*numero)++ ou *(*numero)++? 

      • O asterisco tem prioridade e vai usar o valor apontado por numero primeiro, e depois somar um em numero adiantando o ponteiro para a próxima letra, e o código equivale a
         

         	// soma+=*numero++ - 96;
        	// equivale a 
        
        	soma = soma + *numero + 'a' - 1; // a = 97 em ASCII
        	numero += 1; // passa para o proximo char

         

      • o loop todo poderia ser então
         

        	while (*numero != 0)
        	{
            	    soma = soma + *numero - 'a' + 1;
            	    numero += 1;
        	}


         

Não é preciso usar dois printf() separados

 

O que é const char* p?

 

	const char* p  ="abcde";

 

Isso indica que numero aponta para um char, numero é char*. Podia ser declarado assim com o mesmo efeito

 

const char *numero  ="abcde";
const char igual[]  ="abcde";

 

mas char* e char[] não são a mesma coisa e isso é uma cosia difícil de C. Não vou discutir aqui porque nada tem a ver e já está muito comprido esse trem.

 

Mas isso quer dizer que p aponta para um char, e que não pode ser usado para alterar esse char... p não é const.
 

Exemplo

 

#include <stdio.h>

int main(void)
{

const char *valor  ="abcde";
const char outro[]  ="ABCDE";

const char* p = valor;
printf("Primeira letra: '%c'\n", *valor );
printf("Primeira letra: '%c' Segunda: '%c'\n", *p, *(p+1) );

p = outro;
printf("Primeira letra: '%c' Segunda: '%c'\n", *p, *(p+1) );
return 0;
}

 

Mas p não pode alterar nada...
 

*p = 'C';
valor[1] = 'Y';
outro[0] = 'A';

 

leva a 
 

toninho@DSK-2009:~/projects/um$ gcc -o if -Wall -std=c17 if.c
if.c: In function ‘main’:
if.c:15:4: error: assignment of read-only location ‘*p’
   15 | *p = 'C';
      |    ^
if.c:16:10: error: assignment of read-only location ‘*(valor + 1)’
   16 | valor[1] = 'Y';
      |          ^
if.c:17:10: error: assignment of read-only location ‘outro[0]’
   17 | outro[0] = 'A';
      |          ^
toninho@DSK-2009:~/projects/um$ 

 

Conclusão: p pode apontar para outras coisas mas não pode alterar nada porque p é const char*

 

E se fosse char* const p = valor; ?
 

	char* const p = valor; // p = char* const, outra coisa

 

Aí p é o que? char* const. E é outro bicho: p aponta para char, pode alterar o valor. Mas não pode apontar para outra coisa...

 

Outro exemplo

 

#include <stdio.h>

int main(void)
{

char valor[]  = { "abcde" };
char outro[]  = { "abcde" };
char* const p = valor;
printf("Primeira letra: '%c'\n", *valor );
printf("Primeira letra: '%c' Segunda: '%c'\n", *p, *(p+1) );

// p = outro; // essa linha nao compila

*p = 'X';
*(p+1) = 'Y';
printf("Primeira letra: '%c' Segunda: '%c'\n", *p, *(p+1) );

return 0;
}

 

Esse programa roda ok:
 

toninho@DSK-2009:~/projects/um$ ./if
Primeira letra: 'a'
Primeira letra: 'a' Segunda: 'b'
Primeira letra: 'X' Segunda: 'Y'

 

E muda as letras. Mas se tirar o comentário da linha 12...

 

toninho@DSK-2009:~/projects/um$ gcc -o if -Wall -std=c17 if.c
if.c: In function ‘main’:
if.c:12:3: error: assignment of read-only variable ‘p’
   12 | p = outro; // essa linha nao compila
      |   ^
toninho@DSK-2009:~/projects/um$ 

 

E p não pode apontar para outra coisa...

 

E se usar os dois const?
 

	const char* const p = valor;

 

Aí como esperado valem as duas coisas: p só pode apontar para valor, e não pode ser usado para alterar nada.

Usando o programa de antes
 

#include <stdio.h>

int main(void)
{

char valor[]  = { "abcde" };
char outro[]  = { "abcde" };
const char* const p = valor;
printf("Primeira letra: '%c'\n", *valor );
printf("Primeira letra: '%c' Segunda: '%c'\n", *p, *(p+1) );

p = outro; // essa linha nao compila

*p = 'X';
*(p+1) = 'Y';
printf("Primeira letra: '%c' Segunda: '%c'\n", *p, *(p+1) );

return 0;
}

 

O compilador se queixa claro das duas situações

 

toninho@DSK-2009:~/projects/um$ gcc -o if -Wall -std=c17 if.c
if.c: In function ‘main’:
if.c:12:3: error: assignment of read-only variable ‘p’
   12 | p = outro; // essa linha nao compila
      |   ^
if.c:14:4: error: assignment of read-only location ‘*p’
   14 | *p = 'X';
      |    ^
if.c:15:8: error: assignment of read-only location ‘*(p + 1)’
   15 | *(p+1) = 'Y';
      |        ^
toninho@DSK-2009:~/projects/um$ 

 

Sugiro ler com cuidado. Mesmo profissionais costumam se enrolar com isso. veja a diferença nas mensagens de erro citando location e pointer no compilador gcc acima.

 

 

 

 

 

  • Amei 1
Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisa ser um usuário para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×
×
  • Criar novo...

Aprenda a ler resistores e capacitores

EBOOK GRÁTIS!

CLIQUE AQUI E BAIXE AGORA MESMO!