Lista Encadeada em Linguagem C

Lista Encadeada em Linguagem C

Olá Pessoal…

Hoje irei mostrar como fazer uma Lista Encadeada Dinâmica usando a Linguagem C, e o código podendo ser executado tanto em Linux quanto em Windows.


Primeiramente, o que seria uma lista encadeada? Simples, supondo que você tenha que fazer um programa que cadastre um número indefinido de pessoas, você irá criar uma matriz/vetor?… Errado, pois mesmo que você crie 1000 posições, isso irá consumir muito memória, desde o início do processo, sem contar que posso ter 800 pessoas, ou até mesmo 1200 pessoas, ou seja, o valor é variável, para isso é criado uma lista encadeada, que é manipulada de forma dinâmica.

Exemplo de Lista Encadeada Dinâmica
Exemplo de Lista Encadeada Dinâmica

Basicamente, funciona da seguinte forma, você insere um valor, em uma estrutura, que pode ser chamada de Unidade, Posição ou Nó, a partir deste, você cria a próxima posição, ou seja, você aponta para uma nova posição, por isso em cada estrutura, além dos elementos comuns (como int, char, float), existe um elemento ponteiro, que irá apontar para o próximo elemento.

Sendo que para criar as posições, deve-se usar alocação de memória, com a função MALLOC, e para excluir, é só usar o FREE, porém, a exclusão, não é tão simples, pois se você exclui a posição 3, a posição 2 agora, tem que apontar para a posição 4, que será a nova posição 3, então tem que se fazer um jogo com as variáveis. Abaixo um código fonte, adpato por mim, para ser usado tanto em Linux quanto Windows:

//Bibliotecas utilizadas
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
//Se o sistema for Windows adiciona determinada biblioteca, e definindo comandos de limpar e esperar
#ifdef WIN32
    #include <windows.h>
    #define LIMPA_TELA system("cls")
//Senão for Windows (ex.: Linux)
#else
    #include <unistd.h>
    #define LIMPA_TELA system("/usr/bin/clear")
#endif
 
//Máximo de bytes para uma String
#define BUFFER 64
 
//Espera 3 segundos
#define ESPERA sleep(3)
 
//Estrutura da lista que será criada
typedef struct lista {
    char *nome;
    int idade;
    struct lista *proximo;
} Dados;
 
//Funções para manusear os dados (irão retornar dados)
Dados *inicia_dados  (char *nome, int idade);
Dados *insere_dados  (Dados *dados, char *nome, int idade);
Dados *delbusca_dados(Dados *dados, char *chave);
Dados *deleta_dados  (Dados *dados, int nTipo);
int   checa_vazio    (Dados *dados);
 
//Funções para mostrar dados
void  exibe_dados    (Dados *dados);
void  exibe_tamanho  (Dados *nova);
void  busca_dados    (Dados *dados, char *chave);
 
//Funções do Menu
void criavazia(void);    //1
void insereinicio(void); //2
void inserefim(void);    //3
void listavazia(void);   //4
void prielemento(void);  //5
void ultelemento(void);  //6
void exibe(void);        //7
void exibetam(void);     //8
void deletapri(void);    //9
void deleta(void);       //a
void delbusca(void);     //b
void busca(void);        //c
 
//Inicializando os dados da lista
Dados *principal = NULL;
 
//---------------------------------
//     Opção '1'
//---------------------------------
 
//Criando uma lista vazia
void criavazia(void){
    char *nome;
    int idade;
    //Alocando dados para uma String
    nome = (char *)malloc(BUFFER);
    //Lendo String Nome
    fprintf(stdout, "\n\nDigite o Nome: \n----> ");
    scanf("%s", nome);
    fprintf(stdout, "\n");
    //Lendo int Idade
    fprintf(stdout, "Digite a Idade: \n----> ");
    scanf("%d", &idade);
    fprintf(stdout, "\n");
    //Lançando os dados lidos na lista Principal
    free(principal);
    principal = inicia_dados(nome, idade);
}
 
//Iniciando os dados da lista vazia
Dados *inicia_dados(char *nome, int idade) {
    Dados *novo;
    //Alocando memória para a posição atual da lista
    novo = (Dados *)malloc(sizeof(Dados));
    //Lançando os dados lidos
    novo->nome = (char *)malloc(strlen(nome)+1);
    strncpy(novo->nome, nome, strlen(nome)+1);
    novo->idade = idade;
    //Apontando para a próxima posição da lista
    novo->proximo = NULL;
    return novo;
}
 
//---------------------------------
//     Opção '2'
//---------------------------------
 
//Inserindo no início da lista
void insereinicio(void){
    char *nome;
    int idade;
    //Reservando espaço para String
    nome = (char *)malloc(BUFFER);
    //Armazenando String Nome
    fprintf(stdout, "\n\nDigite o Nome: \n----> ");
    scanf("%s", nome);
    fprintf(stdout, "\n");
    //Armazenando int Idade
    fprintf(stdout, "Digite a Idade: \n----> ");
    scanf("%d", &idade);
    fprintf(stdout, "\n");
    //Lançando dados no ínicio da lista
    principal = insere_dados(principal, nome, idade);
}
 
//Inserindo dados recebidos
Dados *insere_dados(Dados *dados, char *nome, int idade) {
    Dados *inicio;
    //Alocando memória para a posição atual
    inicio = (Dados *)malloc(sizeof(Dados));
    //Lançando os dados lidos
    inicio->nome = (char *)malloc(strlen(nome)+1);
    strncpy(inicio->nome, nome, strlen(nome)+1);
    inicio->idade = idade;
    //O próximo valor aponta para a lista já existente
    inicio->proximo = dados;
    return inicio;
}
 
//---------------------------------
//     Opção '3'
//---------------------------------
 
//Inserção de dados no final de uma lista
void inserefim(void) {
    char *nome;
    int idade;
    //Alocação de espaço para String Nome
    nome = (char *)malloc(BUFFER);
    //Armazenando String Nome
    fprintf(stdout, "\n\nDigite o Nome: \n----> ");
    scanf("%s", nome);
    fprintf(stdout, "\n");
    //Armazenando Int Idade
    fprintf(stdout, "Digite a Idade: \n----> ");
    scanf("%d", &idade);
    fprintf(stdout, "\n");
    //Criando listas auxiliares        
    Dados *final,*aux;
    //Alocando dados para a posição final da lista
    final = (Dados *)malloc(sizeof(Dados));
    //Setando os valores Nome e Idade
    final->nome = (char *)malloc(strlen(nome)+1);
    strncpy(final->nome, nome, strlen(nome)+1);
    final->idade = idade;
    //A pŕoxima posição será Nulo
    final->proximo=NULL;
    //A lista auxiliar será igual a Principal
    aux=principal;
    //Enquanto o próximo de auxiliar não for Nulo
    while(aux->proximo!=NULL){
        aux=aux->proximo;
    }
    //O último valor, será Nulo, e depois apontando para
    //o Final
    aux->proximo=NULL;
    aux->proximo=final;
}
 
//---------------------------------
//     Opção '4'
//---------------------------------
 
//Função que testa se a lista está vazia
void listavazia(void){
    if (principal == NULL) 
        fprintf(stdout, "\n\nLista esta Vazia!\n\n ");
    else
        fprintf(stdout, "\n\nLista nao esta Vazia!\n\n ");
    getchar();
}
 
//---------------------------------
//     Opção '5'
//---------------------------------
 
//Mostrar o primeiro elemento da lista
void prielemento(void){
    fprintf(stdout, "------------------------\n");  
    fprintf(stdout, "Nome: %s\n", principal->nome);
    fprintf(stdout, "Idade: %d\n", principal->idade);
    fprintf(stdout, "------------------------\n");
    getchar();
}
 
//---------------------------------
//     Opção '6'
//---------------------------------
 
//Mostrando o último elemento da lista
void ultelemento(void){
    Dados *aux=principal;
    //Enquanto o próximo elemento não for NULL
    //Avance uma posição
    while(aux->proximo!=NULL){
        aux=aux->proximo;
    }
    fprintf(stdout, "------------------------\n");  
    fprintf(stdout, "Nome: %s\n", aux->nome);
    fprintf(stdout, "Idade: %d\n", aux->idade);
    fprintf(stdout, "------------------------\n");
    getchar();
}
 
//---------------------------------
//     Opção '7'
//---------------------------------
 
//Exibindo dados da lista
void exibe(void) {
    //Se não estiver vazio, exibe os dados
    if (!checa_vazio(principal))
        exibe_dados(principal);
}
 
//Exibindo todos os dados do menu
void exibe_dados(Dados *dados) {
    fprintf(stdout, "Cadastro:\n\n");
    fprintf(stdout, "------------------------\n");
    //Exibindo todos os valores da lista
    for (; dados != NULL; dados = dados->proximo) {
        fprintf(stdout, "Nome: %s\n", dados->nome);
        fprintf(stdout, "Idade: %d\n", dados->idade);
        fprintf(stdout, "------------------------\n");
    }
    getchar();
}
 
//---------------------------------
//     Opção '8'
//---------------------------------
 
//Exibindo o tamanho da lista
void exibetam(void){
    //Se não estiver vazio, exibe os dados
    if (!checa_vazio(principal))
        exibe_tamanho(principal);
}
 
//Exibindo o tamanho total (bytes) e quantidade
void exibe_tamanho(Dados *nova){
  int aux=0, tamanho=0;
  fprintf(stdout, "\n------------------------\n");
  //Correndo todos os valores da Lista
  for (; nova != NULL; nova = nova->proximo) {
    aux++;
    tamanho+=sizeof(nova);
  }
  fprintf(stdout, "Total de Elementos: %d\nTamanho Total: %d bytes\n",aux,tamanho);
  fprintf(stdout, "------------------------\n");
  getchar();
}
 
//---------------------------------
//     Opção '9' e 'a'
//---------------------------------
 
//Deleta o Primeiro valor
void deletapri(void) {
    //Se não estiver vazio, deleta os dados
    if (!checa_vazio(principal))
        principal = deleta_dados(principal,1);
}
 
//Deleta o Último valor
void deleta(void) {
    //Se não estiver vazio, deleta os dados
    if (!checa_vazio(principal))
        principal = deleta_dados(principal,2);
}
 
//Deleta registros da lista, Tipo 1 = Inicio, Tipo 2 = Fim
Dados *deleta_dados(Dados *dados, int nTipo) {
    if(nTipo==1){
        //Apontando para a próxima posição
        Dados *novo;
        novo = dados->proximo;
        //Limpando os dados
        free(dados->nome);
        free(dados);
        fprintf(stdout, "O primeiro registro foi deletado  com sucesso.\n");
        getchar();
        return novo;
    }
    if(nTipo==2){
        Dados *novo=dados, *aux=dados;
        //Se a lista estiver no fim, exclui o que restou
        if(novo->proximo==NULL){
            free(novo);
            aux=NULL;
        }
        else{
            //Laço de repetição para chegar no fim da lista
            while(novo->proximo!=NULL){
                novo=novo->proximo;
            }
            //Preenchendo os dados da lista auxiliar
            while(aux->proximo!=novo){
                aux=aux->proximo;
            }
            //Limpando os dados e apontando para nulo
            free(novo);
            aux->proximo=NULL;
        }
        fprintf(stdout, "O ultimo registro foi deletado com sucesso.\n");
        getchar();
        return aux;
    }
}
 
//---------------------------------
//     Opção 'b'
//---------------------------------
 
//Deletando valor buscado
void delbusca(void) {
    char *chave;
    //Se não estiver vazio
    if (!checa_vazio(principal)) {
        chave = (char *)malloc(BUFFER);
        //Armazenando o valor digitado
        fprintf(stdout, "Digite o nome para buscar: \n--> ");
        scanf("%s", chave);
        //Deletando a chave buscada
        principal = delbusca_dados(principal, chave);
    }
}
 
//Deletando os valores buscados
Dados *delbusca_dados(Dados *dados, char *chave) {
    int achou=0,cont=0;
    Dados *juntou, *aux, *nova=dados;        
 
    //Correndo a lista e verificando se encontrou a string buscada, se sim, aumenta o contador e seta a variável de busca
    for (; nova != NULL; nova = nova->proximo) {
        if (strcmp(chave, nova->nome) == 0) {
            achou=1;
            cont++;
        }
    }
 
    //Se encontrou a busca
    if(achou==1){
        int ind=0;
        //Correndo a lista
        for(ind=0;ind<cont;ind++){
            //Se encontrou na primeira casa apaga a primeira casa
            if(strcmp(chave,dados->nome)==0){
                aux=dados;
                dados=dados->proximo;
                free(aux);
            }
            //Senão, procura até encontrar
            else{
                aux=dados;
                //Posiciona na frente do encontro para exclusão
                while(strcmp(chave,aux->nome)!=0){
                    aux=aux->proximo;
                }
 
                juntou=dados;
                //Enquanto o auxiliar juntou for diferente do posicionado para exclusão
                while(juntou->proximo!=aux){
                    juntou=juntou->proximo;
                }
                //Aponta para o próximo valor válido
                juntou->proximo=aux->proximo;
 
                free(aux);
            }
        }
        fprintf(stdout, "Excluido.\n");
    }
    else
        fprintf(stdout, "Nenhum resultado encontrado.\n");
 
    getchar();
    return dados;
}
 
//---------------------------------
//     Opção 'c'
//---------------------------------
 
//Função que busca os dados
void busca(void) {
    char *chave;
    //Senão estiver vazio a lista
    if (!checa_vazio(principal)) {
        chave = (char *)malloc(BUFFER);
        //Lendo o nome que será buscado
        fprintf(stdout, "Digite o nome para buscar: \n--> ");
        scanf("%s", chave);
        //chamando a função que irá procurar o nome
        busca_dados(principal, chave);
    }
}
 
//Percorre cada ponta da lista verificando busca
void busca_dados(Dados *dados, char *chave) {
    int achou = 0;
    fprintf(stdout, "Cadastro:\n\n");
    //Percorrendo todas as posições
    for (; dados != NULL; dados = dados->proximo) {
        //Se encontrou, mostra os dados
        if (strcmp(chave, dados->nome) == 0) {
            fprintf(stdout, "------------------------\n");
            fprintf(stdout, "Nome: %s\n", dados->nome);
            fprintf(stdout, "Idade: %d\n", dados->idade);
            fprintf(stdout, "------------------------\n");
            achou++;
        }
    }
 
    //Mostrando o resultado da busca
    if (achou == 0)
        fprintf(stdout, "Nenhum resultado encontrado.\n");
    else
        fprintf(stdout, "Foram encontrado(s) %d registro(s).\n", achou);
 
    getchar();
}
 
//---------------------------------
//     Função Auxiliar
//---------------------------------
 
//Função que testa se a lista esta vazia
int checa_vazio(Dados *dados) {
    //Se a lista estiver vazia
    if (dados == NULL) {
            fprintf(stdout, "Lista vazia!\n");
            getchar();
            return 1;
    } else
            return 0;
}
 
//---------------------------------
//     Função Principal
//---------------------------------
 
int main(void) {
    char escolha;
    int chave=0;
    //Laço que irá mostrar o menu esperando uma opção (char)
    do {
        //Limpando a tela, e mostrando o menu lembrando que primeiramente, os itens estão bloqueados até que seja criada uma lista vazia
        LIMPA_TELA;
        fprintf(stdout, "\n\t\tCadastro de Pessoas\n\n");
        fprintf(stdout, "Escolha uma opcao: \n");
        fprintf(stdout, "1 - Criar lista vazia\n");
        if(chave==1){
            fprintf(stdout, "2 - Inserir no Inicio de uma lista\n");
            fprintf(stdout, "3 - Inserir no Fim de uma lista\n");
        }
        fprintf(stdout, "4 - Lista Vazia...\n");
        if(chave==1){
            fprintf(stdout, "5 - Exibir dados do primeiro elemento\n");
            fprintf(stdout, "6 - Exibir dados do ultimo elemento\n");
            fprintf(stdout, "7 - Exibir todos os valores da Lista\n");
            fprintf(stdout, "8 - Exibir o tamanho da Lista\n");
            fprintf(stdout, "9 - Eliminar primeiro elemento\n");
            fprintf(stdout, "a - Eliminar último elemento\n");
            fprintf(stdout, "b - Eliminar elemento buscado\n");
            fprintf(stdout, "c - Busca Dados\n");
        }
        fprintf(stdout, "d - Sair\n\n");
        fprintf(stdout, "Resposta: ");
        scanf("%c", &escolha);
        //Se a chave for diferente de zero, porém a escolha for diferente de 1, 4 e d, a escolha será z (opção inválida)
        if((chave==0)&&((escolha!='1')&&(escolha!='d')&&(escolha!='4')))
            escolha='z';
 
        switch(escolha) {
            //Criando lista vazia
            case '1':
                chave=1;
                criavazia(); 
                break;
            //Inserindo no início
            case '2':
                insereinicio();
                break;                
            //Inserindo no final
            case '3':
                //Se a lista não estiver vazia
                if(principal!=NULL){
                    inserefim();
                }
                //senão inclui no inicio
                else{
                    insereinicio();
                }
                break;
            //Checando se a lista está vazia
            case '4':
                listavazia();
                break;
            //Mostrando Primeiro elemento
            case '5':
                prielemento();
                break;
            //Mostrando Último elemento
            case '6':
                ultelemento();
                break;
            //Exibindo todos elementos
            case '7':
                exibe();
                break;
            //Exibindo tamanho da lista
            case '8':
                exibetam();
                break;
            //Deleta primeiro elementos
            case '9':
                deletapri();
                break;                
            //Deleta último elemento
            case 'a':
                deleta();
                break;
            //Deleta elemento buscado
            case 'b':
                delbusca();
                break;                
            //Buscando elementos
            case 'c':
                busca();
                break;
            //Saindo e finalizando o programa
            case 'd':
                fprintf(stderr,"Obrigado por utilizar esse programa!\n");
                fprintf(stderr,"------>Terminal de Informação<------\n\n");
                ESPERA;
                exit(0);
                break;
            //Se foi algum valor inválido
            default:
                fprintf(stderr,"Digite uma opcao valida (pressione -Enter- p/ continuar)!\n");
                getchar();
                break;
        }
        //Impedindo sujeira na gravação da escolha
        getchar();
    }
    while (escolha > 0); //Loop Infinito
    return 0;
}

Esses e outros códigos, estão disponíveis gratuitamente no nosso GitHub, acesse em github.com/dan-atilio/Linguagem_C.

Um print, do programa em execução no OpenSUSE:

Exemplo de Programa que usa Lista Encadeada
Exemplo de Programa que usa Lista Encadeada

Pessoal, para quem também possui interesse em listas em C, recomendo acessar o blog BDFatec, do nosso amigo Chuck, lá há vários conteúdos bacanas.

Referência: Lista encadeada em C

Download do código fonte:
Download pelo OneDrive
Ou
Download pelo 4Shared

Bom pessoal, por hoje é só.
Abraços e até a próxima.

About Dan_Atilio

Analista e desenvolvedor de sistemas. Técnico em Informática pelo CTI da Unesp. Graduado em Banco de Dados pela Fatec Bauru. Entusiasta de soluções Open Source e blogueiro nas horas vagas. Autor do projeto Terminal de Informação, onde são postados tutoriais e notícias envolvendo o mundo da tecnologia.

28 thoughts on “Lista Encadeada em Linguagem C

  1. Bom dia
    estou tentando fazer uma lista com opção inserir no meio
    por exemplo: já tenho lista os valores 10,12 e 15 e quando digitar 11, 13 estes valores vão ser inseridos em suas posições
    este é meu código ele da alguns erros e não consigo corrigir

    //cria a lista
    if(primeiro == NULL)
    {
    primeiro=(lista*)malloc(sizeof(lista));
    primeiro->info=valor;
    primeiro->proximo_nodo=NULL;
    primeiro->anterior_nodo=NULL;
    ultimo = primeiro;
    }//if(primeiro==null
    else

    atual = primeiro;

    //procura posicao para inserir
    while(atual != NULL && atual->infoproximo_nodo;
    }//while

    novo = (lista*)malloc(sizeof(lista));
    novo->info = valor;

    //insere no inicio
    if(primeiro->proximo_nodo == NULL)
    {
    primeiro->proximo_nodo = novo;
    novo->proximo_nodo = NULL;
    }//primeiro == null

    //insere no meio da lista
    else
    {
    anterior->proximo_nodo = novo;
    novo->proximo_nodo = atual;
    }

    1. Grande Pascoal, tudo joia?

      Cara a linha que vi que está meio estranha, é essa:

      “//procura posicao para inserir
      while(atual != NULL && atual->infoproximo_nodo;
      }//while”

      Verifique se a sintaxe aqui está correta… quanto a lógica, é simples, se for a sua dúvida… Você tem o valor na posição 10 e na posição 13, e quer inserir na posição 12, você verifica a posição atual, se for menor que 12 (no caso 10), e se for, ok, ai você verifica a próxima posição, se for maior que 12 (no caso 13), ai você tem a posição que é pra inserir, é entre esses dois, ai para inserir, faça um nó auxiliar, e aponte para o próximo nó (no caso o 13), então faça um nó guardando o 12, e faça o nó do 10 apontar para o nó do 12.
      Espero ter ajudado. Qualquer dúvida, estou a disposição.
      Abraços. Atenciosamente,
      Daniel Atilio

  2. Eai amigo, gostaria se pode me ajudar com uma função para inserir um valor em penultimo lugar da lista, ou seja, antes do ultimo valor, se puder me ajudar eu agradeço…
    Tem como modificar este que fiz para inserir no fim fazendo com que ele insira antes do ultmo?

    void inserirFinal(Lista ** lista, Nodo cl)
    {
    Lista * aux = *lista;
    Lista * anterior = NULL;
    Lista * novo = (Lista *)calloc(1, sizeof(Lista));
    novo->info = cl;
    novo->prox = NULL;

    if(*lista == NULL)
    {
    *lista = novo;
    }
    else
    {
    while(aux!=NULL)
    {
    anterior = aux;
    aux = aux->prox;
    }
    anterior -> prox = novo;
    }
    }

    1. Boa noite Newton, tente fazer assim… em um laço de repetição, guarde o último valor, e leia no lugar dele… ai depois restaure o último valor… +- assim:
      while(aux!=NULL)
      {
      anterior = aux;
      aux = aux->prox;
      }
      ultimo = anterior;
      anterior -> prox = novo;
      //… tratamento para inclusão)
      anterior->prox=ultimo;

      Qualquer dúvida, pode entrar em contato.
      Abração.

  3. Olá
    Como eu faria se eu quisesse fazer com arquivo?
    eu fiz minha struct assim:

    /*variaveis globais*/
    FILE *arquivo;
    typedef struct cadastro
    {
    char *nome, email;
    int tel;
    }Arquivo;

    Isso é redundante?

    Mnha função main está assim:

    int main(int argc, char *argv[])
    {
    char arq;

    if (argc !=N)
    {
    printf(“Erro. Execute novamente.”);
    return -1;
    }

    arquivo=fopen(argv[1],”a+”);

    arq=argv[1];
    verificacao(arq);

    menu(arq);

    fclose(arquivo);
    return 0;
    }

    a função verificacacao verifica se o arquivo abriu…

    Obrigado !

    1. Boa tarde Vi,
      Primeiramente, onde você está populando os dados da sua estrutura? É uma função externa?, pois da forma como vejo, está fazendo um main, com parâmetros inexistentes, dessa forma, ele nunca vai conseguir abrir arquivos.
      Outra coisa, é que na estrutura, coloque um ponteiro para apontar no próximo endereço de memória, para você poder percorrer os arquivos.
      No mais, acho que está tudo ok.
      Muito Obrigado pelo apoio ao blog.
      Abraços e bom fim de semana.

  4. Olá no busca dados no for depois do parenteses tens um ; que não devia lá estar não sei se reparaste…

    void busca_dados(Dados *dados, char *chave) {
    int achou = 0;
    fprintf(stdout, “Cadastro:nn”);
    //Percorrendo todas as posições
    for (dados != NULL; dados = dados->proximo) {
    //Se encontrou, mostra os dados
    if (strcmp(chave, dados->nome) == 0) {
    fprintf(stdout, “————————n”);
    fprintf(stdout, “Nome: %sn”, dados->nome);
    fprintf(stdout, “Idade: %dn”, dados->idade);
    fprintf(stdout, “————————n”);
    achou++;
    }
    }

    1. Boa noite Mariana,
      Muito Obrigado pela observação. O ‘;’ utilizado, sem nenhum conteúdo, apenas ignora parâmetros recebidos, por exemplo:

      int nVal=1;
      for(nVal;nVal!=3;nVal++)

      Nesse caso, como a variável do meio, já esta com o teste, e a última incrementando, podemos ignorar o primeiro parâmetro, assim economizando código e processamento. Por exemplo, tente executar a seguinte rotina:

      #include

      int main(){
      int nVal=1;
      for(;nVal!=3;nVal++){
      printf(“%dn”,nVal);
      }
      }

      Note que mesmo tendo um ‘;’ após o parênteses, o código será compilado e executado normalmente.
      Mais uma vez, obrigado pela contribuição ao blog.
      Tenha uma ótima semana.
      Abraços.

  5. Olá bom dia..Como eu faria para criar uma função de uma busca em profundidade (sem recursividade) para buscar os nós e imprimí-los na ordem lida..

    1. Bom dia Wagner.
      Primeiramente você teria que ter a posição do nó inicial (cabeça), nisso você poderia fazer um While ou um For testando até que a lista tenha dados (ex.: aux->proximo!=NULL), dentro do for ou do laço você já poderia imprimir com o printf.
      Espero ter ajudado.
      Abraços e boa semana.

  6. Boa tarde…
    Estou com um pouco de dificuldade… Gostaria se possível resolvesse estes dois problemas para mim…

    Dese já, agradeço antecipadamente…

    1 – Escreva um programa que implemente primeiro algoritmo. Sendo que o mesmo deverá armazenar vários resultados a serem apresentados em uma lista simplesmente encadeada.
    2 – Escreva um programa que implemente primeiro algoritmo do trabalho prático da semana 1. Sendo que o mesmo deverá armazenar vários resultados a serem apresentados em uma lista duplamente encadeada.

      1. Olá

        Estou tentando resolver um problema parecido com o do Fabiano Corrêa. Já consegui desenvolver alguma coisa, mas não está funcionando como o esperado.
        A ideia é que o usuário possa inserir dados em uma lista simplesmente encadeada, mas que esses dados sejam armazenados em caracteres Maiúsculos. Assim, quando o usuário for consultar os dados, eles estejam convertidos em Maiúsculo. Segue o código que já tenho:

        #include <stdio.h>
        #include <stdlib.h>
        #include <string.h>
        #include <unistd.h>
        #include <windows.h>

        #define CLEAR_SCREEN “cls”
        #define BUFFER 64
        #define TAM_t 20

        /* Estrutura da lista declarada para armazenar os dados. */
        typedef struct lista
        {
        char *t;
        struct lista *proximo;

        } Dados;

        int PaMaius (char *t)
        {

        int i=0;
        
        
        
        while (*(t+i) != '')
        {
        
            if (*(t+i) >= 'a' && *(t+i) <= 'z') *(t+i) = 'A' + *(t+i) - 'a';
        
            i++;
        
        }
        
        return 0;
        

        }

        /* Prototipo das funcoes de manuseio dos dados. */
        Dados *inicia_dados(char *t);
        Dados *insere_dados(Dados *dados, char *t);
        void exibe_dados(Dados *t);
        void busca_dados(Dados *dados, char *chave);
        Dados *deleta_dados(Dados *dados);
        int checa_vazio(Dados *dados);

        /* Prototipo das funcoes do menu.*/
        void insere(void);
        void exibe(void);
        void busca(void);
        void deleta(void);

        /* Inicializa a estrutura de dados principal. */
        Dados *principal = NULL;

        /* Cria a nova lista apontando o proximo no para NULL. */
        Dados *inicia_dados(char *t)
        {

        Dados *novo;
        
        novo = (Dados *)malloc(sizeof(Dados));
        novo->t = (char *)malloc(strlen(t)+1);
        strncpy(novo->t, t, strlen(t)+1);
        novo->proximo = NULL;
        
        return novo;
        

        }

        /* Como a lista nao esta mais vazia, apontamos o proximo no para lista anterior. */
        Dados *insere_dados(Dados *dados, char *t)
        {

        Dados *novo;
        
        novo = (Dados *)malloc(sizeof(Dados));
        novo->t = (char *)malloc(strlen(t)+1);
        strncpy(novo->t, t, strlen(t)+1);
        novo->proximo = dados;
        
        return novo;
        

        }

        /* Percorre todos os campos da lista e imprime ate o ponteiro proximo chegar em NULL. */
        void exibe_dados(PaMaius *t)
        {

        fprintf(stdout, "nAntes: %sn", t);
        
        PaMaius(t);
        
        printf("Depois: %sn", t);
        
        system ("pause");
        
        exit(0);
        
        
        for (; dados != NULL; dados = dados->proximo)
        {
            fprintf(stdout, "t: %sn", dados->t);
            fprintf(stdout, "------------n");
        }
        
        getchar();
        

        }

        /* Percorre cada ponta comparando o t com a chave. */
        void busca_dados(Dados *dados, char *chave)
        {

        int achou = 0;
        
        fprintf(stdout, "Cadastro:nn");
        for (; dados != NULL; dados = dados->proximo)
        {
            if (strcmp(chave, dados->t) == 0)
            {
        
                fprintf(stdout, "------------n");
                fprintf(stdout, "t: %sn", dados->t);
                fprintf(stdout, "------------n");
                achou++;
            }
        }
        
        if (achou == 0)
            fprintf(stdout, "Nenhum resultado encontrado.n");
        else
            fprintf(stdout, "Foram encontrados %d registros.n", achou);
        
        Sleep(3000);
        

        }

        /* Deleta o ultimo registro inserido. */
        Dados *deleta_dados(Dados *dados)
        {

        Dados *novo;
        
        novo = dados->proximo;
        free(dados->t);
        free(dados);
        
        fprintf(stdout, "O ultimo registro inserido foi deletado com sucesso.n");
        Sleep(200);
        
        return novo;
        

        }

        /* Apena checa se a lista e NULL ou nao. */
        int checa_vazio(Dados *dados)
        {

        if (dados == NULL)
        {
            fprintf(stdout, "Lista vazia!n");
            Sleep (200);
            return 1;
        }
        else
            return 0;
        

        }

        /* Obtem os dados necessarios para chamar as funcoes de manuseio de dados. */
        void insere(void)
        {

        char *t;
        
        
        t = (char *)malloc(BUFFER);
        
        int main ( void  )
        {
        
            char t[TAM_t];
        
        
        
        
        
            printf("Qual o texto?n");
            fgets(t, TAM_t, stdin);
        }
        
        
        
        if (principal == NULL)
            principal = inicia_dados(t);
        else
            principal = insere_dados(principal, t);
        

        }

        void exibe(void)
        {

        if (!checa_vazio(principal))
            exibe_dados(principal);
        

        }

        void busca(void)
        {

        char *chave;
        
        if (!checa_vazio(principal))
        {
        
            chave = (char *)malloc(BUFFER);
        
            fprintf(stdout, "Digite o texto para buscar: n--> ");
            scanf("%s", chave);
        
            busca_dados(principal, chave);
        }
        

        }

        void deleta(void)
        {

        if (!checa_vazio(principal))
            principal = deleta_dados(principal);
        

        }

        int main(void)
        {

        char escolha;
        
        do
        {
            system (CLEAR_SCREEN);
            printf("nListann");
            printf("Escolha uma opcao: n");
            printf("1 - Insere Dadosn");
            printf("2 - Exibe Dadosn");
            printf("3 - Busca Dadosn");
            printf("4 - Deleta Dadosn");
            printf("5 - Sairnn");
            fflush (stdout);
        
            scanf("%c", &escolha);
        
            switch(escolha)
            {
            case '1':
                insere();
                break;
        
            case '2':
                exibe();
                break;
        
            case '3':
                busca();
                break;
        
            case '4':
                deleta();
                break;
        
            case '5':
                exit(0);
                break;
        
            default:
                printf("Digite uma opcao valida!n");
                Sleep(200);
                break;
            }
        
            getchar();
        }
        
        while (escolha > 0); /* Loop Principal. */
        
        return 0;
        

        }

        Se você puder me ajudar a ajustar esse código, agradeço muito!!

  7. Olá

    Na verdade, eu tinha dois códigos separados e os dois estavam funcionando bem. Mas eu precisava juntar os dois, e aí é que não deu muito certo.
    O código que eu utilizei para converter em maiúsculo foi esse (está ok):

    #include<stdlib.h>
    #include<stdio.h>
    #define TAM_TEXTO 20

    int PaMaius(char *);

    int main ( void )
    {

    char texto[TAM_TEXTO];
    
    printf("Qual o texto?n");
    fgets(texto, TAM_TEXTO, stdin);
    
    printf("nAntes: %sn", texto);
    
    PaMaius(texto);
    
    printf("Depois: %sn", texto);
    
    system ("pause");
    
    exit(0);
    

    }

    int PaMaius (char *t)
    {

    int i=0;
    
    while (*(t+i) != '')
    {
    
        if (*(t+i) >= 'a' && *(t+i) <= 'z') *(t+i) = 'A' + *(t+i) - 'a';
    
        i++;
    
    }
    
    return 0;
    

    }

    E eu fiz um outro código, um lista simplesmente encadeada para armazenar nomes e números de telefone. Esse aqui:

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <unistd.h>
    #include <windows.h>

    #define CLEAR_SCREEN “cls”
    #define BUFFER 64

    /* Estrutura da lista declarada para armazenar os dados. */
    typedef struct lista
    {
    char *nome;
    int telefone;
    struct lista *proximo;
    } Dados;

    /* Prototipo das funcoes de manuseio dos dados. */
    Dados *inicia_dados(char *nome, int telefone);
    Dados *insere_dados(Dados *dados, char *nome, int telefone);
    void exibe_dados(Dados *dados);
    void busca_dados(Dados *dados, char *chave);
    Dados *deleta_dados(Dados *dados);
    int checa_vazio(Dados *dados);

    /* Prototipo das funcoes do menu.*/
    void insere(void);
    void exibe(void);
    void busca(void);
    void deleta(void);

    /* Inicializa a estrutura de dados principal. */
    Dados *principal = NULL;

    /* Cria a nova lista apontando o proximo no para NULL. */
    Dados *inicia_dados(char *nome, int telefone)
    {

    Dados *novo;
    
    novo = (Dados *)malloc(sizeof(Dados));
    novo->nome = (char *)malloc(strlen(nome)+1);
    strncpy(novo->nome, nome, strlen(nome)+1);
    novo->telefone = telefone;
    novo->proximo = NULL;
    
    return novo;
    

    }

    /* Como a lista nao esta mais vazia, apontamos o proximo no para lista anterior. */
    Dados *insere_dados(Dados *dados, char *nome, int telefone)
    {

    Dados *novo;
    
    novo = (Dados *)malloc(sizeof(Dados));
    novo->nome = (char *)malloc(strlen(nome)+1);
    strncpy(novo->nome, nome, strlen(nome)+1);
    novo->telefone = telefone;
    novo->proximo = dados;
    
    return novo;
    

    }

    /* Percorre todos os campos da lista e imprime ate o ponteiro proximo chegar em NULL. */
    void exibe_dados(Dados *dados)
    {

    fprintf(stdout, "Cadastro:nn");
    
    fprintf(stdout, "------------n");
    
    for (; dados != NULL; dados = dados->proximo)
    {
        fprintf(stdout, "Nome: %sn", dados->nome);
        fprintf(stdout, "Telefone: %dn", dados->telefone);
        fprintf(stdout, "------------n");
    }
    
    getchar();
    

    }

    /* Percorre cada ponta comparando o nome com a chave. */
    void busca_dados(Dados *dados, char *chave)
    {

    int achou = 0;
    
    fprintf(stdout, "Cadastro:nn");
    for (; dados != NULL; dados = dados->proximo)
    {
        if (strcmp(chave, dados->nome) == 0)
        {
    
            fprintf(stdout, "------------n");
            fprintf(stdout, "Nome: %sn", dados->nome);
            fprintf(stdout, "Telefone: %dn", dados->telefone);
            fprintf(stdout, "------------n");
            achou++;
        }
    }
    
    if (achou == 0)
        fprintf(stdout, "Nenhum resultado encontrado.n");
    else
        fprintf(stdout, "Foram encontrados %d registros.n", achou);
    
    Sleep(3000);
    

    }

    /* Deleta o ultimo registro inserido. */
    Dados *deleta_dados(Dados *dados)
    {

    Dados *novo;
    
    novo = dados->proximo;
    free(dados->nome);
    free(dados);
    
    fprintf(stdout, "O ultimo registro inserido foi deletado com sucesso.n");
    Sleep(200);
    
    return novo;
    

    }

    /* Apena checa se a lista e NULL ou nao. */
    int checa_vazio(Dados *dados)
    {

    if (dados == NULL)
    {
        fprintf(stdout, "Lista vazia!n");
        Sleep (200);
        return 1;
    }
    else
        return 0;
    

    }

    /* Obtem os dados necessarios para chamar as funcoes de manuseio de dados. */
    void insere(void)
    {

    char *nome;
    int telefone;
    
    nome = (char *)malloc(BUFFER);
    
    fprintf(stdout, "nnDigite o Nome: n--> ");
    scanf("%s", nome);
    fprintf(stdout, "n");
    
    fprintf(stdout, "Digite o telefone: (somente numeros)n--> ");
    scanf("%d", &telefone);
    fprintf(stdout, "n");
    
    if (principal == NULL)
        principal = inicia_dados(nome, telefone);
    else
        principal = insere_dados(principal, nome, telefone);
    

    }

    void exibe(void)
    {

    if (!checa_vazio(principal))
        exibe_dados(principal);
    

    }

    void busca(void)
    {

    char *chave;
    
    if (!checa_vazio(principal))
    {
    
        chave = (char *)malloc(BUFFER);
    
        fprintf(stdout, "Digite o nome para buscar: n--> ");
        scanf("%s", chave);
    
        busca_dados(principal, chave);
    }
    

    }

    void deleta(void)
    {

    if (!checa_vazio(principal))
        principal = deleta_dados(principal);
    

    }

    int main(void)
    {

    char escolha;
    
    do
    {
        system (CLEAR_SCREEN);
        printf("nAgenda Telefonicann");
        printf("Escolha uma opcao: n");
        printf("1 - Insere Dadosn");
        printf("2 - Exibe Dadosn");
        printf("3 - Busca Dadosn");
        printf("4 - Deleta Dadosn");
        printf("5 - Sairnn");
        fflush (stdout);
    
        scanf("%c", &escolha);
    
        switch(escolha)
        {
        case '1':
            insere();
            break;
    
        case '2':
            exibe();
            break;
    
        case '3':
            busca();
            break;
    
        case '4':
            deleta();
            break;
    
        case '5':
            exit(0);
            break;
    
        default:
            printf("Digite uma opcao valida!n");
            Sleep(200);
            break;
        }
    
        getchar();
    }
    
    while (escolha > 0); /* Loop Principal. */
    
    return 0;
    

    }

    E aí tirei a parte do telefone e tentei modificar para armazenar somente os nomes (ou um texto qualquer que o usuário preferir). Tentei inserir o código de converter para maiúsculo, pois o usuário poderia digitar um texto em minúsculo, mas quando, no menu, ele escolhesse por exemplo a opção de exibir lista, os resultados precisam estar convertidos para maiúsculo.
    Foi então que eu fiquei um pouco confusa. Fiz aquele código que eu mostrei no post anterior, mas ele não está funcionando.
    Preciso de uma lista simplesmente encadeada para armazenar o que o usuário digitar, mas na hora de apresentar os resultados da lista, os caracteres precisam estar em maiúsculo.

    Grata pela atenção.
    Abraços

    1. Boa noite Elisa.
      Entendi, então o problema seria deixar como maiúsculo… pois bem, na declaração das funções, adicione o PaMaius, seria o primeiro paso:

      //...
      Dados *deleta_dados(Dados *dados);
      int checa_vazio(Dados *dados);
      int PaMaius(char *t);
      //...
      

      O segundo passo é na função “insere”, logo após ler o nome, chame sua função PaMaius.

      //...
      fprintf(stdout, "nnDigite o Nome: n--> ");
      scanf("%s", nome);
      PaMaius(nome);
      fprintf(stdout, "n");
      //...
      

      E no fim do seu código, adicione sua função PaMaius.

      //...
      while (escolha > 0); /* Loop Principal. */
      return 0;
      }
      
      int PaMaius (char *t)
      {
      //...
      

      Espero ter ajudado. Boa sorte.
      Abraços.

      1. Obrigada pela ajuda. Ajudou muito mesmo!
        Consegui terminar o código.
        Obrigada
        Abraços.

        #include <stdio.h>
        #include <stdlib.h>
        #include <string.h>
        #include <unistd.h>
        #include <windows.h>

        #define CLEAR_SCREEN “cls”
        #define BUFFER 64

        /* Estrutura da lista declarada para armazenar os dados. */
        typedef struct lista
        {
        char *nome;

        struct lista *proximo;
        

        } Dados;

        /* Prototipo das funcoes de manuseio dos dados. */
        Dados *inicia_dados(char *nome);
        Dados *insere_dados(Dados *dados, char *nome);
        void exibe_dados(Dados *dados);
        void busca_dados(Dados *dados, char *chave);
        Dados *deleta_dados(Dados *dados);
        int checa_vazio(Dados *dados);

        /* Prototipo das funcoes do menu.*/
        void insere(void);
        void exibe(void);
        void busca(void);
        void deleta(void);

        /* Inicializa a estrutura de dados principal. */
        Dados *principal = NULL;

        /* Cria a nova lista apontando o proximo no para NULL. */
        Dados *inicia_dados(char *nome)
        {

        Dados *novo;
        
        novo = (Dados *)malloc(sizeof(Dados));
        novo->nome = (char *)malloc(strlen(nome)+1);
        strncpy(novo->nome, nome, strlen(nome)+1);
        novo->proximo = NULL;
        
        return novo;
        

        }

        /* Como a lista nao esta mais vazia, apontamos o proximo no para lista anterior. */
        Dados *insere_dados(Dados *dados, char *nome)
        {

        Dados *novo;
        
        novo = (Dados *)malloc(sizeof(Dados));
        novo->nome = (char *)malloc(strlen(nome)+1);
        strncpy(novo->nome, nome, strlen(nome)+1);
        novo->proximo = dados;
        
        return novo;
        

        }

        /* Percorre todos os campos da lista e imprime ate o ponteiro proximo chegar em NULL. */
        void exibe_dados(Dados *dados)
        {

        fprintf(stdout, "Cadastro:nn");
        
        fprintf(stdout, "------------n");
        
        for (; dados != NULL; dados = dados->proximo)
        {
            fprintf(stdout, "PALAVRA: %sn", dados->nome);
        
            fprintf(stdout, "------------n");
        }
        
        getchar();
        

        }

        /* Percorre cada ponta comparando o nome com a chave. */
        void busca_dados(Dados *dados, char *chave)
        {

        int achou = 0;
        
        fprintf(stdout, "Cadastro:nn");
        for (; dados != NULL; dados = dados->proximo)
        {
            if (strcmp(chave, dados->nome) == 0)
            {
        
                fprintf(stdout, "------------n");
                fprintf(stdout, "Palavra: %sn", dados->nome);
        
                achou++;
            }
        }
        
        if (achou == 0)
            fprintf(stdout, "Nenhum resultado encontrado.n");
        else
            fprintf(stdout, "Foram encontrados %d registros.n", achou);
        
        Sleep(3000);
        

        }

        /* Deleta o ultimo registro inserido. */
        Dados *deleta_dados(Dados *dados)
        {

        Dados *novo;
        
        novo = dados->proximo;
        free(dados->nome);
        free(dados);
        
        fprintf(stdout, "O ultimo registro inserido foi deletado com sucesso.n");
        Sleep(200);
        
        return novo;
        

        }

        /* Apena checa se a lista e NULL ou nao. */
        int checa_vazio(Dados *dados)
        {

        if (dados == NULL)
        {
            fprintf(stdout, "Lista vazia!n");
            Sleep (200);
            return 1;
        }
        else
            return 0;
        

        }

        int PaMaius (char t)
        {
        int i=0;
        while (
        (t+i) != ‘’)
        {
        if (*(t+i) >= ‘a’ && *(t+i) <= ‘z’) *(t+i) = ‘A’ + *(t+i) – ‘a’;
        i++;
        }
        return 0;
        }

        /* Obtem os dados necessarios para chamar as funcoes de manuseio de dados. */
        void insere(void)
        {

        char *nome;
        
        
        nome = (char *)malloc(BUFFER);
        fprintf(stdout, "nnDigite uma palavra:");
        fprintf(stdout, "nNao separe com espaco: use - ou _ ");
        fprintf(stdout, "nn-->");
        scanf("%s", nome);
        
        PaMaius(nome);
        
        fprintf(stdout, "n");
        
        if (principal == NULL)
            principal = inicia_dados(nome);
        else
            principal = insere_dados(principal, nome);
        

        }

        void exibe(void)
        {
        fprintf(stdout, “Palavras ja convertidas em Maiusculo “);
        if (!checa_vazio(principal))
        exibe_dados(principal);
        }

        void busca(void)
        {

        char *chave;
        
        if (!checa_vazio(principal))
        {
        
            chave = (char *)malloc(BUFFER);
        
            fprintf(stdout, "Digite a PALAVRA para buscar: (Em MAIUSCULO)n--> ");
            scanf("%s", chave);
        
            busca_dados(principal, chave);
        }
        

        }

        void deleta(void)
        {

        if (!checa_vazio(principal))
            principal = deleta_dados(principal);
        

        }

        int main(void)
        {

        char escolha;
        
        do
        {
            system (CLEAR_SCREEN);
            printf("Cadastrar Palavras nn");
            printf("Escolha uma opcao: n");
            printf("1 - Insere Dadosn");
            printf("2 - Exibe Dadosn");
            printf("3 - Busca Dadosn");
            printf("4 - Deleta Dadosn");
            printf("5 - Sairnn");
            fflush (stdout);
        
            scanf("%c", &escolha);
        
            switch(escolha)
            {
            case '1':
                insere();
                break;
        
            case '2':
                exibe();
                break;
        
            case '3':
                busca();
                break;
        
            case '4':
                deleta();
                break;
        
            case '5':
                exit(0);
                break;
        
            default:
                printf("Digite uma opcao valida!n");
                Sleep(200);
                break;
            }
        
            getchar();
        }
        
        while (escolha > 0); /* Loop Principal. */
        
        return 0;
        

        }

  8. Bom dia, estou precisando muito dessa ajuda estou fazendo EAD, já li e reli mas não consigo compreender preciso desse toque! agradeço

    Pense em um problema ou situação do dia-a-dia em que você use uma lista sequencial e faça o que se pede :

    Inicio em um trabalho à noite (00:00 às 06:20) retorno pra casa, descanso acordo me apronto pra outra jornada de trabalho de 10:30 às 22:30 (esse 12×36) retorno e me apronto pra outra jornada de trabalho das 00:00 às 06:20 onde o restante do dia é descaso e estudo.

    a) Defina seu problema em uma frase, de forma objetiva e clara.
    Resp: organizado e sequencial, mas exaustivo!

    b) Justifique porque a estrutura de dados lista é a estrutura de dados correta e adequada para seu problema.
    Resp: Porque lista é mais organizado e não tem como retornar , você vai eliminando quando vai sendo concluído cada objetivo!

    Aqui é complicado!!!
    c) Crie uma struct que modele cada nó da lista, comentando, objetivamente, o que representa cada membro da mesma.

    d) Crie uma função, de no máximo 10 linhas, que exiba todos os elementos da lista criada, sem usar variáveis globais.

    1. Boa noite Nilson, tudo bem?
      Para a questão C, acho que você deveria criar uma struct, que possua duas variáveis, uma integer e uma caracter/string, sendo a primeira algo sequencial (como 1, 2, 3, 4…), e a segunda a descrição, como por exemplo (“AAA”, “BBB”, “CCC”, etc).
      Para a questão D, você pode usar a função exibe_dados.
      Um grande abraço.

  9. Boa tarde.

    Eu gostaria de tirar uma dúvida a respeito de um erro que está acontecendo na minha lista encadeada. O problema é o seguinte: eu tenho que criar uma lista encadeada que vai servir como uma agenda, para marcação de eventos (aniversários, compromissos, dentista, etc). Eu devo ter cada nó da minha lista como um mês, e cada lista que já exista nesse nó, será um dia. Então o usuário pode consultar os eventos que terão em um determinado dia do mês ou procurar diretamente pelo nome, e o programa retornar o dia e o horário.

    Até aqui, tudo certo. Contudo, o que está ocorrendo é que o programa compila normalmente, mas quando vou fazer o preenchimento dos dados, na parte do nome do evento, o programa trava e da erro. Eu gostaria de saber porque ele não aceita uma simples string. Vou postar meu algoritmo:

    #include
    #include
    #include
    #include
    #include

    using namespace std;

    struct DATA {

    int dia, horario,mes;
    string nome; ================== Aqui deve ser o problema.

    DATA *ProxData;

    };

    DATA* FuncaoCriaListaVazia () {

    return NULL;
    }

    DATA* FuncaoInserirEvento (DATA *data)
    {
    DATA *NovaData;

    NovaData = (DATA*)malloc(sizeof(DATA));

    cout << "\nPreencha os dados:\n" << endl;
    cout <> NovaData->nome; ====== Quando preencho aqui, o programa trava.
    cout <> NovaData->mes;
    cout <> NovaData->dia;
    cout <> NovaData->horario;

    NovaData->ProxData = data;

    return NovaData;
    }

    void FuncaoBuscarEventos (DATA *data){

    int MesEvento,DiaEvento;
    DATA* aux;

    if(data == NULL){
    cout << "\nA agenda esta vazia" << endl;
    }
    else{

    cout <> MesEvento;
    cout <> DiaEvento;
    for(aux = data; aux != NULL; aux = aux->ProxData){
    if(aux->mes == MesEvento){
    if(aux->dia == DiaEvento){
    // cout << "Evento: " <nome << endl; ===A ideia era buscar um evento pelo nome
    cout << "\nDia: " <dia << endl;
    cout << "Horario " <horario << " horas" << endl;
    cout << "\n" << endl;
    }
    else{
    cout << "\nNao existe nenhum evento agendado para este dia." << endl;
    }
    }
    }
    }
    }

    DATA* FuncaoRetiraEvento (DATA* data){

    int dia;
    DATA* DataAnterior = NULL;
    DATA* aux = data;

    cout <> dia;
    /* procura elemento na lista, guardando anterior */
    while (aux != NULL && aux->dia != dia){
    DataAnterior = aux;
    aux = aux->ProxData;
    }
    /* verifica se achou elemento */
    if (aux == NULL){
    return data; /* não achou: retorna lista original */
    }
    /* retira elemento */
    if (DataAnterior == NULL){/* retira elemento do inicio */

    data = aux->ProxData;
    }
    else{ /* retira elemento do meio da lista */
    DataAnterior->ProxData = aux->ProxData;
    }

    free(aux);
    return data;
    }

    void FuncaoImprimeEventos (DATA *data)
    {
    DATA *aux;
    int MesEvento,DiaEvento;

    cout <> MesEvento;
    cout <> DiaEvento;

    for (aux = data; aux != NULL; aux = aux->ProxData){
    if(MesEvento == aux->mes){
    if(DiaEvento == aux->dia){
    cout << "\n";
    cout << "DIA DO EVENTO: " <dia << endl;
    cout << "HORARIO DO EVENTO: " <horario << endl;
    }
    }
    }
    }

    int main () {

    int opcao;
    DATA *data;
    string NomeEvento;

    data = FuncaoCriaListaVazia ();

    do{
    cout << "\tMENU\n" << endl;
    cout << "1 – Inserir evento " << endl;
    cout << "2 – Apagar evento " << endl;
    cout << "3 – Buscar evento " << endl;
    cout << "4 – Todos os eventos do dia " << endl;
    cout << "5 – Sair do programa " << endl;

    cout <> opcao;

    switch(opcao){

    case 1:
    system(“CLS”);
    data = FuncaoInserirEvento (data);
    cout << "\n" << endl;
    system("pause");
    system("CLS");
    break;
    case 2:
    system("CLS");
    FuncaoRetiraEvento (data);
    cout << "\n" << endl;
    system("pause");
    system("CLS");
    break;
    case 3:
    system("CLS");
    FuncaoBuscarEventos (data);
    cout << "\n" << endl;
    system("pause");
    system("CLS");
    break;
    case 4:
    system("CLS");
    FuncaoImprimeEventos (data);
    break;
    case 5:
    system("CLS");
    cout << "Programa encerrado." << endl;
    break;
    }
    }while(opcao != 5);

    system("pause");
    }

    1. Boa tarde Luciano, tudo bem?
      Olhando o código, não sei dizer o porque do problema (as includes também saíram do texto que colou).
      Procurando no stack overflow (erros com cout string c++), achei esses dois links (que citam alguns dos problemas, como falta de include):
      http://stackoverflow.com/questions/9088340/unable-to-use-cout-with-a-c-string-unless-i-run-it-through-data-or-c-str
      http://stackoverflow.com/questions/6320995/why-i-cannot-cout-a-string

      Se quiser, me envie o fonte, para eu poder compilar também, e verificar se consigo identificar a falha.
      Um grande abraço.

  10. tenho uma tarefa que e preciso armazenar as seguintes informacoes :descricao,duracao, e perioridade.A aplicacao devera mostrar o seguinte menu:1- Inserir tarefa deve ser mantido sempre por ordem crescente de perioridade. 2-Atualizar. 3-listar todas as tarefas do corrente dia deve estar por ordem crescente de perioridade. 4-listar as tarefas com perioridade nao inferior a uma perioridade definida pelo utilizador. 5-eliminar uma tarefa . 6-eliminar todas as tarefas .se pudessem mi ajudar eu agradeco desde ja.

Deixe uma resposta

%d blogueiros gostam disto: