kgin

Um deles é esse aqui Você errou quando criou a função criaPilha() na inicialização da pilha. Aqui o erro E quando você utiliza a função tamanho() ela vai desempilhar e utilizar esse valor, mas o valor e desconhecido pelo fato que ele não foi inicializado na função criaPilha(). Aqui a saída do gdb mostrando o erro Veja que no endereço anterior ele era um endereço valido, mas no ultimo endereço ele aponta para lugar nenhum fazendo o programa ter SEGV e abortando. Outra coisa que eu acho que você deveria fazer e deixa o programa principal lidar com um erro ao invés de abortar o programa. você deveria só fazer algo assim. struct st_pilha *pilha_cria(void) { struct st_pilha *pilha = malloc(sizeof(*pilha)); if (pilha != NULL) { pilha->tamanho = 0; pilha->pilha = NULL; return(pilha); } return(NULL); } Só verificando o erro na função principal. Aqui o resto do algoritmo de exemplo #include <stdio.h> #include <stdlib.h> struct st_lista { int valor; struct st_lista *anterior; }; struct st_pilha { struct st_lista *pilha; int tamanho; }; void pilha_destroi(struct st_pilha **pilha); struct st_pilha *pilha_cria(void); int pilha_empilha(struct st_pilha *pilha, int valor); int pilha_desempilha(struct st_pilha *pilha); int pilha_tamanho(struct st_pilha *pilha); int main(void) { struct st_pilha *pilha = pilha_cria(); if (pilha == NULL) { printf("deu problema!\n"); exit(EXIT_FAILURE); } pilha_empilha(pilha, 10); pilha_empilha(pilha, 11); pilha_empilha(pilha, 12); pilha_empilha(pilha, 13); printf("O tamanho da pilha e %i\n", pilha_tamanho(pilha)); printf("Valor na pilha %i\n", pilha_desempilha(pilha)); printf("Valor na pilha %i\n", pilha_desempilha(pilha)); printf("Valor na pilha %i\n", pilha_desempilha(pilha)); printf("Valor na pilha %i\n", pilha_desempilha(pilha)); printf("O tamanho da pilha agora e %i\n", pilha_tamanho(pilha)); pilha_destroi(&pilha); getchar(); return(0); } void pilha_destroi(struct st_pilha **pilha) { if (*pilha != NULL) { while ((*pilha)->pilha != NULL) { struct st_lista *tmp = (*pilha)->pilha->anterior; free((*pilha)->pilha); (*pilha)->pilha = tmp; } (*pilha)->pilha = NULL; free(*pilha); } *pilha = NULL; } struct st_pilha *pilha_cria(void) { struct st_pilha *pilha = malloc(sizeof(*pilha)); if (pilha != NULL) { pilha->tamanho = 0; pilha->pilha = NULL; return(pilha); } return(NULL); } int pilha_empilha(struct st_pilha *pilha, int valor) { struct st_lista *no = malloc(sizeof(*no)); if (no != NULL) { no->valor = valor; no->anterior = pilha->pilha; pilha->pilha = no; pilha->tamanho++; return(1); } return(0); } int pilha_desempilha(struct st_pilha *pilha) { if (pilha->pilha != NULL) { int valor = pilha->pilha->valor; struct st_lista *tmp = pilha->pilha->anterior; free(pilha->pilha); pilha->pilha = tmp; pilha->tamanho--; return(valor); } return(0); } int pilha_tamanho(struct st_pilha *pilha) { return(pilha->tamanho); } Recomendo ler esse blog para entender como identificar os erros. https://sergioprado.org/identificando-problemas-de-acesso-memoria-com-o-addresssanitizer/

Procurei por todo canto e não achei nada sobre constantes. Pensei que nem existissem no visualG. Eh erro meu isso aí, não seria um exemplo muito bom pra que tá aprendendo a programar. Mas em C ou pascal dependendo da arquitetura e a quantidade de memória isso não seria um problema. a recursão poderia ser feita até umas 64 vezes em C (no pior dos casos) ou umas 128 vezes em pascal se obedece-se algumas regras. Eu achei incrível isso tenha funcionado no visualG.

tem muitos, muitos erros. Mas o principal é aqui Você não reservou a memória para o próximo elemento na pilha.

@Cristian Herchonvicz Achei meio vago o enunciado. tente fazer dessa maneira. algoritmo "loteamentos" var // Reserva dos lotes lotes_disponiveis:vetor [1..14] de inteiro // Nomes dos compradores dos lotes lotes_nomes:vetor [1..14] de caractere // Quantidade de lotes QUANTIDADE_LOTES:inteiro contador:inteiro LOTE_DISPONIVEL, LOTE_RESERVADO, LOTE_VENDIDO:inteiro procedimento mostraLotes var contador:inteiro inicio escreval("Lotes disponivies") para contador de 1 ate QUANTIDADE_LOTES faca // Mostra se o lote está disponível se lotes_disponiveis[contador] = LOTE_DISPONIVEL entao escreval("[", contador,"]-Lote disponiviel") fimSe se lotes_disponiveis[contador] = LOTE_RESERVADO entao escreval("[", contador,"]-Lote reservado para ", lotes_nomes[contador]) fimSe se lotes_disponiveis[contador] = LOTE_VENDIDO entao escreval("[", contador,"]-Lote vendido para ", lotes_nomes[contador]) fimSe fimPara fimProcedimento procedimento reservaLote var indice:inteiro opcao:inteiro inicio // Mostra os lotes mostraLotes escreval("Digite um lote para reservar ou comprar") leia(indice) // Checa se o valor do lote e valido se (indice >= 1) e (indice <= QUANTIDADE_LOTES) entao // Verifica se o lote está disponível se lotes_disponiveis[indice] = 0 entao escreval("Digite seu nome para confirmar a reserva") leia(lotes_nomes[indice]) escreval("Digite 1 para reservar o lote ou 2 para comprar") leia(opcao) se opcao = 1 entao lotes_disponiveis[indice] <- LOTE_RESERVADO seNao lotes_disponiveis[indice] <- LOTE_VENDIDO fimSe seNao se lotes_disponiveis[indice] = LOTE_RESERVADO entao escreval("Lote ja reservado") seNao escreval("O lote ja foi comprado") fimSe escreval("Deseja tentar reservar ou comprar outro lote?") escreval("Digite 1 para cadastrar novamente ou 2 para sair") leia(opcao) se opcao = 1 entao reservaLote fimSe fimSe seNao escreval("Essa opcao não existe") escreval("Deseja tentar reservar ou comprar outro lote") escreval("Digite 1 para cadastrar novamente ou 2 para sair") leia(opcao) se opcao = 1 entao reservaLote fimSe fimSe fimProcedimento inicio // Quantidade total de lotes QUANTIDADE_LOTES <- 14 // Constantes do status do lote LOTE_DISPONIVEL <- 0 LOTE_RESERVADO <- 1 LOTE_VENDIDO <- 2 // Inicia o vetor para contador de 1 ate QUANTIDADE_LOTES faca lotes_disponiveis[contador] <- 0 fimPara reservaLote mostraLotes fimAlgoritmo

Poste o enunciado.

Pode ser algo na versão que você está desenvolvendo agora. Poste novamente o algoritmo.

@Lauro Viana Aqui tá normal e não existe disciplina 0 Porque está tão complicado se é só um programa de media?

Poste o enunciado e descreva o seu problema.

Ele provavelmente está com algum problema, vá na aba problemas (ou problems caso você esteja usando em inglês) que ele vai apontar qual o erro. Se isso não der certo tente ir nas configurações do intellisense. O certo seria aparecer um erro assim quando você erra-se na sintaxe. Se você está aprendendo deixar o autocompletar desligado e uma opção interessante, mas a verificação de código aí já não acho muito interessante para o aprendizado.

Geralmente o próprio intellicense faz isso, você tem instalado?

Já tentou fazer um "chmod +x prog2" no terminal?

@DanielSantos_20 Agora sim ficou bacana! Só inclua a biblioteca ctype para usar a função toupper() #include <ctype.h> No devC++ ele provavelmente vai funcionar, mas se você compilar em outro lugar vai dar erro porque está faltando a biblioteca.

Delphi e C++Builder desde 1995 e a melhor alternativa para criar interfaces gráficas. Mas eu recomendo você começar fazendo ferramentas que sejam uteis para você, de nada adianta tentar fazer algo que você não vai usar. Eu mesmo tenho uma suíte inteira para programação do mega drive que provavelmente ninguém além de min vai usar, mas e útil para mim. Se você está tendo dificuldades com interfaces gráficas isso e porque provavelmente você não entendeu o básico. como a orientação a objetos do C++ ou funções e ponteiros do C, revisitar alguns desses conteúdos pode ajudar a entender melhor o framework que você esta usando. e preste atenção que C não tem nada a ver com C++, isso pode acabar te atrapalhando na hora de aprender.

Seu problema está aqui Perceba que na array soma você está somando +1 ao índice, por isso você está recebendo uma resposta invalida. @DanielSantos_20 De nomes mais significativos para as variáveis e constantes, seguir o código assim é horrível. Veja que uma variável ou uma constante de uma letra só como "a" no meio do código não representa nada significativo. Fica bem fácil se perder dessa maneira. Experimente algo assim #define QUANTIDADE_RESPOSTAS 5 Não use fflush() no buffer de entrada, veja uma alternativa melhor nesse tópico contornar o problema do buffer do teclado Eu dei uma arrumadinha no seu algoritmo #include <stdio.h> #include <ctype.h> #include <string.h> /* Constantes */ #define QUANTIDADE_GABARITO_RESPOSTAS 5 #define QUANTIDADE_GABARITO_ALUNOS 5 #define QUANTIDADE_ALUNOS 10 #define QUANTIDADE_LETRAS_GABARITO 4 void barraInformacoes(char *str, char caractere, int tamanho) { const int quantidade_caracteres = (tamanho-(strlen(str)-1))/2; int contador; for (contador = 0; contador < quantidade_caracteres; contador++) { printf("%c", caractere); } printf("%s", str); for (contador = 0; contador < quantidade_caracteres; contador++) { printf("%c", caractere); } printf("\n"); } int main(void) { char gabarito_respostas[QUANTIDADE_GABARITO_RESPOSTAS], gabaritos_alunos[QUANTIDADE_ALUNOS][QUANTIDADE_GABARITO_ALUNOS]; int contador1, contador2, quantidade_acetos_aluno[QUANTIDADE_ALUNOS] = {0}; /* Pega o gabarito das provas */ barraInformacoes("GABARITO", '-', 40); printf("Digite as respostas das questoes como A,B,C ou D\n"); for (contador1 = 0; contador1 < QUANTIDADE_GABARITO_RESPOSTAS; contador1++) { printf("Digite a resposta da prova [%i]:", contador1+1); scanf("%c%*c", &gabarito_respostas[contador1]); } /* Mostra as respostas no gabarito */ barraInformacoes("RESPOSTAS DO GABARITO", '-', 40); printf("[-]"); for (contador1 = 0; contador1 < QUANTIDADE_LETRAS_GABARITO; contador1++) { printf("[%c]", contador1+'A'); } printf("\n"); for (contador1 = 0; contador1 < QUANTIDADE_GABARITO_RESPOSTAS; contador1++) { printf("[%i]", contador1+1); for (contador2 = 0; contador2 < QUANTIDADE_LETRAS_GABARITO; contador2++) { if (toupper(gabarito_respostas[contador1]) == contador2+'A') { printf("[#]"); } else { printf("[ ]"); } } printf("\n"); } /* Pega as respostas dos alunos */ barraInformacoes("GABARITO DO ALUNO", '#', 40); for (contador1 = 0; contador1 < QUANTIDADE_ALUNOS; contador1++) { printf("Digite as respostas do aluno:[%i]\n", contador1+1); for (contador2 = 0; contador2 < QUANTIDADE_GABARITO_ALUNOS; contador2++) { printf("Prova[%i]\n", contador2+1); printf("A, B, C ou D por favor\n:"); scanf("%c%*c", &gabaritos_alunos[contador1][contador2]); /* Checa se a resposta coincide com a do gabarito */ if (toupper(gabaritos_alunos[contador1][contador2]) == toupper(gabarito_respostas[contador2])) { quantidade_acetos_aluno[contador1]++; } } } /* Mostra o resultado de cada aluno */ barraInformacoes("ACERTOS DE CADA ALUNO", '-', 40); for (contador1 = 0; contador1 < QUANTIDADE_ALUNOS; contador1++) { printf("O aluno %i acertou %i questoes\n", contador1+1, quantidade_acetos_aluno[contador1]); } printf("Pressione enter para encerrar o programa\n"); getchar(); return(0); } Mas eu acho que acabei incluindo código demais

@Vini Naraki Você está seguindo o mesmo enunciado do dono do tópico?

Mas para uso real (exemplo um trabalha para uma empresa) o melhor seria usar banco de dados. Veja esse tutorial sobre aquivos Arquivos em pascal O que você quer fazer e bem simples. a ideia geral e passar por todo o arquivo checando se encontra a string correspondente. exemplo de como ler uma arquivo texto. program ler_arquivos; uses Crt, SysUtils; const NOME_ARQUIVO = 'arquivo'; var arquivo:text; str:string; begin { Associa o arquivo com a variavel do tipo arquivo de texto } Assign(arquivo, NOME_ARQUIVO); { Desliga a checagem de erros } {$I-} reset(arquivo); { Abre o arquivo para leitura } { Liga a checagem de erros } {$I+} { Checa se foi possível abrir o arquivo } if IoResult = 0 then begin ClrScr; { Limpa a tela } writeln('Conteudo do arquivo'); { Lê o arquivo } while not eof(arquivo) do begin readln(arquivo, str); writeln(str); end; close(arquivo); { Fecha o arquivo } end else begin writeln('não foi possível abrir o arquivo!'); writeln('cheque se o arquivo existe'); end; end. Clique aqui para rodar o algoritmo online. Depois você pode usar função extractWord para retirar a parte que você deseja. exemplo program testes; uses { Utilizado para manipular o terminal } Crt, { Funções padrões do sistema } SysUtils, { Funções para trabalhar com strings } StrUtils; var str:string; begin writeln('Digite duas palavras separadas por ;'); readln(str); writeln('A primeira palavra e:', extractWord(1,str, [';'])); writeln('A segunda palavra e:', extractWord(2,str, [';'])); end. Clique aqui para rodar o algoritmo online. Referencias em inglês System StrUtils ExtractWord

@nilzon Você sabe fazer a leitura de arquivos? Uma aplicação desse tipo seria melhor usar SQL (banco de dados) ao invés de uma arquivo texto.

seu problema principal é que você está fazendo uma lista encadeada e não está reservando memoria para ela. Recomendo procurar como fazer listas encadeadas em pascal para só depois se pŕeocupar com o resto do enunciado.

@barrosdasilva35 mas ele está funcionando? Recomendo pegar papel e lápis, e pensar como vai ser o algoritmo antes de codificar.

pelo o que eu entendi seria mais ao menos algo assim funcao verifica_situacao_aluno(media:real):inteiro inicio se media < 3 entao retorne ALUNO_REPROVADO fimSe se ((media >= 3)e(media <= 5)) entao retorne ALUNO_RECUPERACAO fimSe se media > 5 entao retorne ALUNO_APROVADO fimSe fimFuncao você teria que retornar para o programa principal a situação do aluno. E o programa principal que mostraria a mensagem de aprovado, em recuperação ou reprovado. Exemplo completo Algoritmo "teste" var ALUNO_APROVADO, ALUNO_REPROVADO, ALUNO_RECUPERACAO:inteiro nota1, nota2:real funcao media_aluno(nota1, nota2:real):real inicio se (nota1 > 0) e (nota2 > 0) entao retorne (nota1+nota2)/2 seNao retorne -1 fimSe fimFuncao funcao verifica_situacao_aluno(media:real):inteiro inicio se media < 3 entao retorne ALUNO_REPROVADO fimSe se ((media >= 3)e(media <= 5)) entao retorne ALUNO_RECUPERACAO fimSe se media > 5 entao retorne ALUNO_APROVADO fimSe fimFuncao inicio // Situação do aluno ALUNO_APROVADO <- 3 ALUNO_REPROVADO <- 2 ALUNO_RECUPERACAO <- 1 escreva("Digite a primeira nota:") leia(nota1) escreva("Digite a segunda nota:") leia(nota2) se media_aluno(nota1, nota2) > 0 entao escreval(" Notas") escreval("1-", nota1) escreval("2-", nota2) escreval(" Media") escreval(media_aluno(nota1, nota2)) se verifica_situacao_aluno(media_aluno(nota1, nota2)) = ALUNO_APROVADO entao escreval("O aluno esta aprovado!") fimSe se verifica_situacao_aluno(media_aluno(nota1, nota2)) = ALUNO_REPROVADO entao escreval("O aluno esta reprovado!") fimSe se verifica_situacao_aluno(media_aluno(nota1, nota2)) = ALUNO_RECUPERACAO entao escreval("O aluno esta de recuperacao!") fimSe seNao escreval("A situção do aluno esta irregular") fimSe fimAlgoritmo Uma coisa que eu reparei e que o visualg e péssimo em relação a constantes. Em C ficaria bem mais simples exemplo em C

@Alexandre Xisto Eu recomendo você começar novamente e dar uma boa lida no tópico do @mauro_b A ideia do algoritmo e basicamente isso. Pegue todos os 10 registros do usuário Salve o registro usando RU como nome do arquivo Faça o passo 2 novamente até completar os 10 registros Se não compreendeu muito bem, então veja o executável final que eu fiz para demonstrar testes.zip Se você puder trocar de ferramenta recomendo fortemente, o visual studio não suporta (não sei ao certo, já faz tempo que eu testei) nenhuma versão decente da linguagem C. agora quanto ao erro foi porque você usou o fopen_s() igual ao fopen() veja a sintaxe correta aqui fopen_s, _wfopen_s

@Alexandre Xisto O problema do seu algoritmo e porque você está lendo strings (= cadeia de caracteres) e inteiros como um caractere. você deveria usar fgets() para pegar strings e scanf() para pegar números inteiros e reais. É isso está errado! o enunciado pede para criar uma struct para os elementos do cadastro. exemplo de registro struct matricula { char nome[255]; char telefone[30]; char email[150]; int ru; }; fora que você deveria ler todos os 10 registros para só no final do programa criar um arquivo para cada registro. dessa maneira #include <stdio.h> #include <stdlib.h> #define TAMANHO_NOME 150 #define TAMANHO_TELEFONE 20 #define TAMANHO_EMAIL 255 #define QUANTIDADE_MATRICULAS 10 /* Estrutura com os dados da matricula */ struct matricula { char nome[TAMANHO_NOME]; char telefone[TAMANHO_TELEFONE]; char email[TAMANHO_EMAIL]; int numero; }; int main(void) { int contador; struct matricula matriculas[QUANTIDADE_MATRICULAS]; /* Pega as informações */ for (contador = 0; contador < QUANTIDADE_MATRICULAS; contador++) { printf("Digite seu nome:"); fgets(matriculas[contador].nome, TAMANHO_NOME, stdin); printf("Digite seu RU:"); scanf("%d%*c", &matriculas[contador].numero); printf("Digite seu telefone:"); fgets(matriculas[contador].telefone, TAMANHO_TELEFONE, stdin); printf("Digite seu email:"); fgets(matriculas[contador].email, TAMANHO_EMAIL, stdin); } /* Mostra as informações */ for (contador = 0; contador < QUANTIDADE_MATRICULAS; contador++) { printf("\n\tInformacoes do aluno\n"); printf("RU:%d\n", matriculas[contador].numero); printf("Nome:%s", matriculas[contador].nome); printf("Telefone:%s", matriculas[contador].telefone); printf("Email:%s", matriculas[contador].email); } getchar(); /* Espera a tecla enter */ return(0); } Veja que no meu exemplo ele não pula as entradas analise o jeito que eu pegue a entrada do teclado para sanar o seu problema.

@Tiago Dutra TI qual seria a sua dificuldade? Já aprendeu o básico? como declarar variáveis e pegar a entrada do usuário, se não então de uma conferida no curso do guanabara. Mas se você já fez alguma coisa, então poste para melhor podermos ajudá-lo. Veja esse tópico antes de postar código no fórum:Botão code

mais ou menos. você não seguiu o enunciado, se eu entendi corretamente era pra você fazer algo assim no procedimento gerador procedimento gerador(opcao:inteiro) inicio escolha (opcao) caso 1 escreval("+-------=======------+") caso 2 escreval("~~~~~~~~:::::::~~~~~~~") caso 3 escreval("<<<<-------------->>>>>") fimEscolha fimProcedimento e você fez fora dele no programa principal. outra melhoria seria usar o próprio procedimento gerador para mostrar os gráficos ao invés de digitar varias vezes no meio do programa. Exemplo algoritmo "barras" var opcao:inteiro procedimento geradorBarras(opcao:inteiro) inicio escolha (opcao) caso 1 escreval("+-------=======------+") caso 2 escreval("~~~~~~~~:::::::~~~~~~~") caso 3 escreval("<<<<-------------->>>>>") fimEscolha fimProcedimento procedimento barraEspecial(tamanho:inteiro; borda_esquerda, borda_direita, meio:caractere) var contador, q_caracteres:inteiro inicio q_caracteres <- int(tamanho/3) para contador de 1 ate q_caracteres faca escreva(borda_esquerda) fimPara para contador de 1 ate q_caracteres faca escreva(meio) fimPara para contador de 1 ate q_caracteres faca escreva(borda_direita) fimPara escreval fimProcedimento procedimento barraSimples(tamanho:inteiro; barra:caractere) var contador:inteiro inicio para contador de 1 ate tamanho faca escreva(barra) fimPara escreval fimProcedimento inicio barraSimples(40, "=") escreval(" Escolha uma borda") escreva("1 ") geradorBarras(1) escreva("2 ") geradorBarras(2) escreva("3 ") geradorBarras(3) barraSimples(40, "=") escreva("Escolha uma das opções:") leia(opcao) escolha (opcao) caso 1 geradorBarras(1) caso 2 geradorBarras(2) caso 3 geradorBarras(3) outroCaso barraEspecial(40, "!", "!", "?") escreval(" não temos essa opcao") barraEspecial(40, "!", "!", "?") fimEscolha fimAlgoritmo

Pelo que eu percebi e por causa do comando caso está próximo da letra, é também porque você comentou na mesma linha do comando caso deixe dessa maneira que funciona. // Alcool caso "A" seu algoritmo corrigido Algoritmo "semnome" Var preco, litros, reajuste, valorfinal, precogas: real tipocomb: caractere Inicio escreva("qual o tipo de combustivel ?? A/G : ") leia(tipocomb) escreva("quantos litros voce ira querer ?? : ") leia(litros) escolha (tipocomb) // Alcool caso "A" precogas <- 4.50 se(litros <= 20)entao reajuste <- 2 senao reajuste <- 4 fimse // Gasolina caso "G" precogas <- 3 se(litros <= 15)entao reajuste <- 3.5 senao reajuste <- 6 fimse fimescolha preco <- precogas * litros valorfinal <- (preco * reajuste)/100 //calcular o desconto escreva("O valor total a pagar é: ",valorfinal) fimalgoritmo O seu calculo do combustível está errado.