Lista encadeada simples

[joubet]

Qual seria uma boa definição de lista encadeada simples ?

Considere o programa:

#include <stdlib.h>
#include <stdio.h>
int main()
{
    struct vvalores

{
    int valor1;
    int valor2;
    int valor3;
       } valor = {9,11,20};
    
       system("CLS");
       printf ("visualizacao de itens de dados de uma estrutura na tela:","\n");
       printf ("\n");
       printf ("\n");
       printf ("Mostre valor1: %d\n",valor.valor1,"\n");
       printf ("Mostre valor2: %d\n",valor.valor2,"\n");
       printf ("Mostre valor3: %d\n",valor.valor3,"\n");
       return(0);
}

se eu quiser encadear essa estrutura com outra, digamos:

struct dados_pessoais

{
    char nome[30];
    int identidade;
    int CPF;
       } valor = {joao,22345,20399974755};

Como ficaria o programa ?

Obrigado

[EduardoS]

Em uma lista encadeada, cada elemento possui um ponteiro para o próximo elemento, no exemplo acima:

struct vvalores
{
    int valor1;
    int valor2;
    int valor3;
    vvalores* proximo;
} valor = {9,11,20, NULL};

[joubet]

Eu fazendo as seguintes alterações no programa, eu teria um exemplo simples de lista encadeada ?

#include <stdlib.h>
#include <stdio.h>
int main()
{
    struct vvalores

{
    int valor1;
    int valor2;
    int valor3;

      struct vvalores *proximo;
       } valor = {9,11,20};
       
     struct dados_pessoais

{
    char nome[30];
    int identidade;
    int CPF;
 struct dados_pessoais *proximo;

       } valor2 = {“joao”,22345,20399974755};

    
       system("CLS");
       printf ("visualizacao de itens de dados de uma estrutura na tela:","\n");
       printf ("\n");
       printf ("\n");
       printf ("Mostre valor1: %d\n",valor.valor1,"\n");
       printf ("Mostre valor2: %d\n",valor.valor2,"\n");
       printf ("Mostre valor3: %d\n",valor.valor3,"\n");
       printf (“\n”);
       printf ("Mostre valor1: %s\n",valor2.nome,"\n");
       printf ("Mostre valor2: %d\n",valor2.identidade,"\n");
       printf ("Mostre valor3: %d\n",valor2.CPF,"\n");
       
       return(0);
}

1 - Eu só acho que os printfs estão mostrando as estruturas como estruturas separadas, e na prática como duas estruturas, e não como uma listas encadeada. Tem alguma forma melhor de se representar ou mostrar a lista encadeada simples

na função printf() no programa acima ?

2 - Por que o Null no fim da da inicialização da variável atribuída a estrutura ?

3- existe uma forma geral de se representar a ideia de estrutura ?

Obrigado

[EduardoS]

1 - Eu só acho que os printfs estão mostrando as estruturas como estruturas separadas, e na prática como duas estruturas, e não como uma listas encadeada. Tem alguma forma melhor de se representar ou mostrar a lista encadeada simples

na função printf() no programa acima ?

A utilidade das listas encadeadas é armazenar coleções, logo, a melhor forma de exibilas pelo printf é com um loop.

2 - Por que o Null no fim da da inicialização da variável atribuída a estrutura ?

Porque no inicio não existe próximo elemento, e o NULL é muito usado para indicar isso.

3- existe uma forma geral de se representar a ideia de estrutura ?

Ahn... difícil explicar, é um pouco intuitivo, um número complexo por exemplo, ele tem a parte real e a imaginária, logo precisariamos de uma estrutura para representa-lo:

struct complex
{
   float x;
   float y;
};

[joubet]

Como assim loop ? não entendi. Eu nõo continuarei a ter duas estruturas "valor" e "valor2" eu pensava que pelo ponteiro "*proximo" tivesse alguma forma de se acessar as duas estruturas, dai o nome de encadeada.

Acho que meu código-exemplo não está encadeando a lista, acho que não tem lista encadeada. O que estaria faltando o livro do Schildt não é muito didático nesse ponto.

Um outro erro que percebi em meu raciocínio, lendo o citado livro, é achar, que lista encadeada precisa de duas estruturas, sendo assim o código pase para analise seria

#include <stdlib.h>
#include <stdio.h>
int main()
{
struct dados_pessoais

{
    char nome[30];
    int identidade;
    int CPF;
 struct dados_pessoais *proximo;

       } valor2 = {“joao”,22345,20399974755};

    
       system("CLS");
       printf ("visualizacao de itens de dados de uma estrutura na tela:","\n");
       printf ("Mostre valor1: %s\n",valor2.nome,"\n");
       printf ("Mostre valor2: %d\n",valor2.identidade,"\n");
       printf ("Mostre valor3: %d\n",valor2.CPF,"\n");
       
       return(0);
}

pensava que para fazer lista encadeada precisava de duas estrutura, veja que não é isso, pois achava que "encadear"deixava implicito duas estruturas. poderia analisar este último código ?

Obrigado

[EduardoS]

Uma lista encadeada é uma lista em que cada elemento possui um ponteiro para o próximo, isso facilita a inclusão de novos elementos, no código acima ele pega os dados do primeiro elemento, para pegar o do segundo basta:

printf ("Mostre valor1: %s\n",valor2.proximo->nome,"\n");

Ah, se executar isso vai dar pau porque o próximo é nulo, seria preciso incluir um novo elemento antes.

[joubet]

Fiz as seguintes alterações como você sugeriu:

1- na linha

} valor2 = {“joao”,22345,20399974755};

mudei para

} valor2 = {“joao”,22345,20399974755,0};

Ao rodar o programa, recebi, a seguinte mensagem de erro:

Mostra o item de dado nome: <null>

Eu esperava que não desse esse erro, porque como sugerido acima, coloquei mais um elemento, até troquei o zero por null, mas deu o mesmo erro. O que está errado ?

2 - fiz o seguinte teste, mudei a linha

printf ("\nMostre o valor do item de dado nome: %s\n",valor2.proximo->nome,"\n");

para

printf ("\nMostre o valor do item de dado nome: %s\n",proximo->nome,"\n");

deu a seguinte mensagem de erro:

C:\Meus documentos\struno.c In function `main':

17 C:\Meus documentos\struno.c `proximo' undeclared (first use in this function)

(Each undeclared identifier is reported only once

for each function it appears in.)

por que é necessário a variável “valor2”, o ponteiro “proximo*” não deveria bastar ?

3 – Supondo que o problema acima seja resolvido, pergunto:

Posso encadear duas estruturas como pensei em fazer no primeiro código, usando apenas um único ponteiro, no caso o ponteiro “*proximo” ?

4 – Se ao em vez de eu iniciar a variável de estrutura “valor2” como fiz, eu quisesse entrar com os dados, usando scanf, desta forma:

scanf (“%s”,proximo.nome);
scanf (“%d”,proximo.identidade);
scanf (“%d”,proximo.cpf);

Estaria certo ? estou supondo que o “&”comercial não seja preciso, porque já estou usando ponteiro “próximo*” no exemplo.

O brigado

[EduardoS]

Fiz as seguintes alterações como você sugeriu:

1- na linha

} valor2 = {“joao”,22345,20399974755};

mudei para

} valor2 = {“joao”,22345,20399974755,0};

Ao rodar o programa, recebi, a seguinte mensagem de erro:

Eu esperava que não desse esse erro, porque como sugerido acima, coloquei mais um elemento, até troquei o zero por null, mas deu o mesmo erro. O que está errado ?

Não posso dizer com certeza, mas usar int paraum CPF desse tamanho é overflow.

2 - fiz o seguinte teste, mudei a linha

printf ("\nMostre o valor do item de dado nome: %s\n",valor2.proximo->nome,"\n");

para

printf ("\nMostre o valor do item de dado nome: %s\n",proximo->nome,"\n");

deu a seguinte mensagem de erro:

por que é necessário a variável “valor2”, o ponteiro “proximo*” não deveria bastar ?

Não, o ponteiro próximo é um item da estrutura dados_pessoais e o compilador não vai achar nada com esse nome fora dela.

3 – Supondo que o problema acima seja resolvido, pergunto:

Posso encadear duas estruturas como pensei em fazer no primeiro código, usando apenas um único ponteiro, no caso o ponteiro “*proximo” ?

Ai perderia o sentido a lista encadeada, veja abaixo:

4 – Se ao em vez de eu iniciar a variável de estrutura “valor2” como fiz, eu quisesse entrar com os dados, usando scanf, desta forma:

scanf (“%s”,proximo.nome);
scanf (“%d”,proximo.identidade);
scanf (“%d”,proximo.cpf);

Estaria certo ? estou supondo que o “&”comercial não seja preciso, porque já estou usando ponteiro “próximo*” no exemplo.

O brigado

O primeiro erro é que não é possivel usar o próximo ai, veja um exemplo de lista encadeada:

#include <stdio.h>
#include <stdlib.h>
#include <conio.h> 
struct dados_pessoais
{
    char nome[30];
    int identidade;
    int cpf;
    struct dados_pessoais* proximo;
};
int main()
{
    struct dados_pessoais* primeiro = malloc(sizeof(struct dados_pessoais));
    struct dados_pessoais* atual = primeiro;
    int continua = 0;
    atual->proximo = NULL;
    while(1)
    {
        printf("Digite o nome:");
        scanf ("%s", &atual->nome);
        printf("Digite a identidade:");
        scanf ("%d", &atual->identidade);
        printf("Digite o cpf:");
        scanf ("%d", &atual->cpf);

        printf("Deseja continuar?[S/N]\n");

ler:
        continua = getch() | 0x20;
        if(continua == 0x73)
        {
            atual = atual->proximo = malloc(sizeof(struct dados_pessoais));
            atual->proximo = NULL;
        }
        else if(continua == 0x6E)
            break;
        else
            goto ler;
    }

    atual = primeiro;

    while(atual)
    {
        printf("%s tem identidade no %d e cpf %d\n", &atual->nome, atual->identidade, atual->cpf);
        atual = atual->proximo;
    }
    system("pause");

    return(0);
}

[joubet]

Esse exemplo está bem complicado. Está usando alocação de memória, goto, números hexadecimais, aliás o que representam esses números hexadecimais ? rodei seu exemplo e funcionou. Não entendi o porque da necessidade de alocar memória. Presumo que os ponteiros, próximo, primeiro e atual sejam para posicionar os itens da lista na ordem certa, mas não entendi porque se começou pelo ponteiro próximo, nem porque o ponteiro atual aponta para o ponteiro proximo que por sua vez aponta para nulo.

.
.
struct dados_pessoais* proximo;
};
int main()
{
    struct dados_pessoais* primeiro = malloc(sizeof(struct dados_pessoais));
    struct dados_pessoais* atual = primeiro;
    int continua = 0;
    atual->proximo = NULL;  

imaginava algo mais simples. De qualquer forma vou estuda-lo. Vamos tentar algo mais simples, considere o código abaixo:

Escrevi esta versão com base em suas informações,

#include <stdio.h>
int main()
{
    struct dados_pessoais

{
    char nome[30];
    int anonac;
    char sexo;
    struct dados_pessoais *proximo;
       } valor = {"joao",1997,'M'};


       system("CLS");
       printf ("visualizacao de itens de dados de uma lista encadeada tela:","\n");
      
       printf ("\nMostre o valor do item de dado nome: %s\n",valor.proximo->nome,"\n");
       printf ("\nMostre o valor do item de dado idade:  %d\n",valor.proximo->anonac,"\n");
       printf ("\nMostre o valor do item de dado ano: %c\n",valor.proximo->sexo,"\n");
       system ("pause");
       return(0);

O resultado é:

Visualização de itens de dados de uma lista encadeada na tela:

Mostre o valor do item de dado nome: <null>

Fiz uma outra versão com base em seu programa:

#include <stdio.h>
int main()
{
    struct dados_pessoais

{
    char nome[30];
    int anonac;
    char sexo;
    struct dados_pessoais *proximo;
       };
       
    struct dados_pessoais* primeiro = malloc(sizeof(struct dados_pessoais));
    struct dados_pessoais* atual = primeiro;
    atual->proximo = NULL;


       system("CLS");
        printf("Digite o nome:");
        scanf ("%s", &atual->nome);
        printf("Digite o ano:");
        scanf ("%d", &atual->anonac);
        printf("Digite o sexo:");
        scanf ("%d", &atual->sexo);
        printf("\n");
        printf ("visualizacao de itens de dados de uma lista encadeada tela:","\n\n");
      
       printf ("\nMostre o valor do item de dado nome: %s\n",atual->nome,"\n");
       printf ("\nMostre o valor do item de dado ano:  %d\n",atual->anonac,"\n");
       printf ("\nMostre o valor do item de dado sexo: %c\n",atual->sexo,"\n");
       printf("\n");
       system ("pause");
       return(0);
}

Entretanto, a dúvida com relação ao funcionamento e lógica das linhas

struct dados_pessoais* primeiro = malloc(sizeof(struct dados_pessoais));
struct dados_pessoais* atual = primeiro;
atual->proximo = NULL;

Continuam. por que preciso delas para funcionar ?

Além disso, o printf não esta conssegindo mostrar o item de dado "sexo". Se eu troco %c por %s, é mostrado <null>, os outros itens de dados são mostrados corretamente,

Se puder ajudar nesse código agradeço estou levando uma surra

obrigado

[EduardoS]

Realmente ficou mais complicado do que devia, mas a parte da lista encadeada ta ok, sobre o trecho "difícil", ele serve para controlar as inserções, abaixo com comentários:

ler:
        continua = getch() | 0x20;/*Pega uma letra digitada, o "| 0x20" transforma ela em minúscula, um "& 0xDF" transformaria ela em maiúscula, fiz isso para não rpecisar comparar com S maiúscula e minúsculo*/
        if(continua == 0x73)/*o 0x73 representa o 's', poderia escrever o char ao invés do hexadecimal, seria mais fácil de entender*/
        {/*se responder s (sim) ele avança para o próximo item e continua o loop, as duas linhas abaixo fazem parte da lista encadeada, vou explicar melhor elas mais abaixo*/
            atual = atual->proximo = malloc(sizeof(struct dados_pessoais));
            atual->proximo = NULL;
        }
        else if(continua == 0x6E)/*0x6E é o 'n', se ele respondeu não sai do loop*/
            break;
        else
            goto ler;/*se não digitou nem 's' e nem 'n' le o char de novo*/

Agora voltando a lista encadeada que é o que interessa,

Uma lista encadeada tem o objetivo de ser uma coleção, como uma array, e ela tem muitas vantagens de performace em relação a essa ultima quando é preciso inserir um número desconhecido de registros em posições arbitrárias (ok, o exemplo é tosco e não da para ver ganho de performace algum, em situações reais esse ganho fica bem mais claro).

Como o objetivo dela é inserções, o exemplo não teria o menor sentido se o malloc não estivesse la.

No exemplo declarei dois ponteiros, o "primeiro" e o "atual", o "primeiro" é o inicio da lista, o "atual" é o elemento atualemte em uso, o "próximo" do "primeiro" é o segundo elemento, o "próximo" do segundo elemento é o terceiro elemento assim por diante.

    struct dados_pessoais* primeiro = malloc(sizeof(struct dados_pessoais));
    struct dados_pessoais* atual = primeiro;
    atual->proximo = NULL;

Nesse trecho criei o primeiro elemento com o malloc, deixei o "atual" como sendo o primeiro porque ele é o elemento ativo, marquei o "próximo" como NULL porque por enquanto a lista só possui um elemento.

            atual = atual->proximo = malloc(sizeof(struct dados_pessoais));
            atual->proximo = NULL;

O programa vai passar por esse trecho sempre que o usuário responder 's', ai precisamos criar um novo elemento na nossa lista, para criar um novo elemento uso o malloc, e atribuo o "próximo" à memória recem alocada, depois (porém na mesma linha) faço o "atual" avançar uma posição "atual = atual->próximo" (isso faz com que, se o "atual" for o primeiro elemento ele passe a ser o segundo, se for o segundo passa a ser o terceiro, etc) e marco o próximo do novo atual para NULL (aqui o "atual" é o ultimo elemento, por isso preciso marcar NULL).

Agora preciso imprimir os elementos da minha lista, vou começar colocando o elemento atual como sendo o primeiro:

    atual = primeiro;

Agora é só repetir o printf para cada elemento da lista.

    while(atual)
    {
        printf("%s tem identidade no %d e cpf %d\n", &atual->nome, atual->identidade, atual->cpf);
        atual = atual->proximo;
    }
    system("pause");

Ele começa na primeira posição e imprime os valores do elemento "atual", depois avança uma posição ("atual = atual->proximo;") e repete enquanto o "atual" for diferente de NULL, ou seja, enquanto houver elementos na lista.

Espero que agora tenha ficado mais simples que o ultimo código.

[joubet]

Voltando a analisar seu programa, por que preciso fazer:

if(continua == 0x73)
        {
            atual = atual->proximo = malloc(sizeof(struct dados_pessoais));
            atual->proximo = NULL;
        }

dentro do while ? seria uma tentativa de reposicionar a memória ? mas ai não seria mais lógico usar realloc() ?

já que estamos falando de alocação dinâmica, ao final do programa não deveria ter um free(aual); ?

Continuo buscar a buscar uma forma de simplificar o programa, já tive alguns sucesso. Veja:

#include <stdio.h>
#include <ctype.h>
#include<conio.h>
int main()
{
    struct dados_pessoais

{
    char nome[30];
    int anonac;
    char sexo;
    struct dados_pessoais *proximo;
       };
       
    struct dados_pessoais* primeiro = malloc(sizeof(struct dados_pessoais));
    struct dados_pessoais* atual = primeiro;
    atual->proximo = NULL;
    
    char continuar ='S';
while(continuar)
{
       system("CLS");
       printf("Digite o nome:\n");
       scanf ("%s", &atual->nome);
       printf("Digite o ano:\n");
       scanf ("%d", &atual->anonac);
       printf("Digite o sexo:\n");
       scanf ("%d", &atual->sexo);
       printf("\n");
       printf("Deseja continuar S ou N\n");
       
       continuar=getch();
            
        if (toupper(continuar)=='N')
        {
         break; 
        } 
         
        else
            {
             continue;
            }
} 
        
        printf ("visualizacao de itens de dados de uma lista encadeada tela:","\n\n");
      
       printf ("\nMostre o valor do item de dado nome: %s\n",atual->nome,"\n");
       printf ("\nMostre o valor do item de dado ano:  %d\n",atual->anonac,"\n");
       printf ("\nMostre o valor do item de dado sexo: %c\n",atual->sexo,"\n");
       printf("\n");
       system ("pause");
       return(0);
}

Contudo quando digo que quero continuar, ou seja, digito “S” em vez de aparecer:

Resultado esperado.

Digite nome:

Joao

Digite ano:

1997

Digite sexo

M

Tenho como resultado de imediato:

Digite o nome:

Digite o ano

Neste momento o cursor aparece, e se digito algo, ai aparece

Digite sexo

É como se os outros scanf, fossem ignorados, minha ideia é eliminar o goto. Alem disso o último item de dado “sexo” ainda não está aparecendo, talvez com base em meu primeiro questionamento de hoje

Obrigado

[EduardoS]

dentro do while ? seria uma tentativa de reposicionar a memória ? mas ai não seria mais lógico usar realloc() ?

O realloc serviria, se não fosse uma lista encadeada...

Imagine que você precise de uma lista com n elementos, e claro, você não sabe o valor de n, com malloc e realloc seria possivel fazer:

struct dados_pessoais
{
    char nome[30];
    int anonac;
    char sexo;
};
int num = 0;
struct dados_pessoais *lista = NULL;
//...
num = 1;
lista = realloc(lista, num * sizeof(struct dados_pessoais));/*cria um elemento na lista*/
//...
num++;
lista = realloc(lista, num * sizeof(struct dados_pessoais));/*adiciona um elemento na lista*/
//...
printf("teste:%s ", lista[3].nome);//imprime o quarto elemento da lista
//...

Mas realocar memória assim é um processo lento, se precisar inserir, mover ou remover itens de posições arbitrárias então nem se fala.

Ao alocar ou realocar memória, quanto maior o bloco mais difícil de achar uma posição para ele, o bloco precisa ser contínuo e depois de algum tempo o heap fica fragmentado e se torna difícil achar um bloco continuo la.

Para as posições arbitrárias é ainda pior, supondo uma lista com 10 elementos, se eu quiser inserir um novo na quinta posição, terei que realocar memória, mover os elementos a partir do quinto uma posição e depois inserir, para deletar o sexto elemento, preciso mover os elemntos depois dele para ocupar o espaço faltando, e para mover um elemento, preciso mover todos os que estiverem entre as duas posições, quando a lista começa a ficar grande isso se torna realmente lento.

Com a lista encadeada para adicionar um novo elemento é só alocar memória para o novo elemento (e um bloco pequeno, fácil de alocar), e modificar no máximo um ponteiro (alem do ponteiro do novo elemento), para deletar é só liberar a memória e modificar um ponteiro, para mover, só modificar dois ponteiros, é muito mais rápido.

já que estamos falando de alocação dinâmica, ao final do programa não deveria ter um free(aual); ?

Depois seria preciso percorrer a lista para deletar todos os elementos, o loop no final seria:

while(primeiro!=NULL)
{
    atual = primeiro->proximo;
    free(primeiro);
    primeiro = atual;
}

Por fim, o seu o while não vai funcionar, não existe mais o código para adicionar um novo elemnto e os scanf vão sempre sobreescrever os dados já existentes, dentro do else, antes do continue, é rpeciso aquele trecho de código:

atual = atual->proximo = malloc(sizeof(struct dados_pessoais));
atual->proximo = NULL;

Depois tera realmente uma lista, e precisara de um while para imprimi-la.

[joubet]

Veja a nova versão do programa e os comentários que fiz para esclarecer o código.

#include <stdio.h>
#include <ctype.h>
#include<conio.h>
int main()
{
    struct dados_pessoais

{
    char nome[30];
    int anonac;
    char sexo;
    struct dados_pessoais *proximo;
       };
       
    struct dados_pessoais* primeiro = malloc(sizeof(struct dados_pessoais));
    struct dados_pessoais* atual = primeiro;
    atual->proximo = NULL;
    
    char continuar ='S';
while(continuar)
{
       system("CLS");
       printf("Digite o nome:\n");
       scanf ("%s", &atual->nome);
       printf("Digite o ano:\n");
       scanf ("%d", &atual->anonac);
       printf("Digite o sexo:\n");
       scanf ("%d", &atual->sexo);
       printf("\n");
       printf("Deseja continuar S ou N\n");
       
       continuar=getch();
            
        if (toupper(continuar)=='N')
        {
         break; 
        } 
         
        else
            {
             atual = atual->proximo = malloc(sizeof(struct dados_pessoais));
             atual->proximo = NULL; /* Preciso para adiciomar um novo elemento
             a lista e evitar que os scanfs sejam sobre-escritos
             Usa-se malloc() para lista, pois basta alocar um pequeno espaço
             de memória para um novo elemento*/
             continue;    
            }
} 
        
  printf ("visualizacao de itens de dados de uma lista encadeada tela:","\n\n");
    
atual = primeiro; /* inicializa o ponteiro atual com o primeiro p/ comecar a 
mostrar*/ 
while (atual)
{      
       printf ("\nMostre o valor do item de dado nome: %s\n",atual->nome,"\n");
       printf ("\nMostre o valor do item de dado ano:  %d\n",atual->anonac,"\n");
       printf ("\nMostre o valor do item de dado sexo: %c\n",atual->sexo,"\n");
       printf("\n");
       atual = atual->proximo; /* Mostra o proximo elemento*/
}       
       system ("pause");
       return(0);
}

Entretanto, mesmo usando while para mostrar o resultado, se eu digo “N”, tenho o seguinte resultado

Digite o nome:

Joao

Digite o ano:

1997

Digite o sexo:

M

Deseja continuar S ou N ?

N

Visualização de itens de dado de uma lista de dado na tela:

Mostra o item de dado nome: joao

Mostra o item de dado idade: 1997

Mostra o item de dado sexo:

Pressione qualquer tecla para continuar...

Se respondo “S”, tenho o seguinte resultado:

Digite o nome:

Digite o ano:

(o cursor para aqui)

joao

Digite o sexo:

Deseja continuar S / N ?

N

Visualização de itens de dado de uma lista de dado na tela:

Mostra o item de dado nome: joao

Mostra o item de dado idade: 1997

Mostra o item de dado sexo:

Visualização de itens de dado de uma lista de dado na tela:

Mostra o item de dado nome: m

Mostra o item de dado idade: 0

Mostra o item de dado sexo:

Pressione qualquer tecla para continuar..

O que esta faltando ou está errado ?

Obrigado

[EduardoS]

No scanf que pega o sexo deveria estar "%c" ao invés de "%d" para que ele pegue um char.

[joubet]

Bateu na trave, troquei %d por %c, mas ainda o item de dado sexo mostrado após digitado. Tentei %s mais ai deu “pau” no programa. A boa notícia, e que com essa mudança ao responder “S” para nova entrada de dados, não está mais aparecendo de imediato o nome e a idade para ser preenchido como acusei acima.

Depois de resolvido o problema do cursor, tive que colocar depois do último scanf, um getchar(), pois estava pulando direto para pergunta: “Deseja continuar S / N ?”

Mas mostrar o valor digitado para sexo.. nada

Obrigado

[EduardoS]

Ops... Tente " %c", assim mesmo, com o espaço antes do porcentagem.

[joubet]

Não deu certo. Mas resolvi fazer:

char sexo{1];

e trocar %c por %s, e deu certo.

Aproveito, para questionar o seguinte: Quando perguntei sobre a necessidade de um free() para liberar a memória, você sugeriu o seguinte código:

while(primeiro!=NULL)
{
    atual = primeiro->proximo;
    free(primeiro);
    primeiro = atual;
} 

Suponho, que esse código colocado depois do while que mostra os dados, correto ? não seria mais simples colocar um free(atual) antes da função system() ? não entendi o porque dessa lógica.

Obrigado

[EduardoS]

Quanto ao código, copiei e colei o ultimo no Visual C++ trocando o "%d" por " %c", ele deu um erro de compilação, inverti as linhas 17 e 18 para corrigir o erro (precisa declarar as variaveis antes do resto...), ele compilou e funcionou a execução. Que compilador você usa?

Quanto ao "%s", cuidado com ele, ele nunca grava um char só, mas sim o número de caracteres digitados pelo usuário e um \0 no final, esse \0 que é o problema porque pode sobreescrever alguma outra variavel, veja o exemplo abaixo:

#include <stdio.h>
#include <ctype.h>
#include<conio.h>
int main()
{
    struct {
        char a;
        char b;
    } teste;
    printf("digite qualquer coisa\n");
    scanf("%s", &teste.;
    printf("mais alguma coisa coisa\n");
    scanf("%s", &teste.a);
    printf("O valor de a e %c, e b e %c\n", teste.a, teste.;
    system("pause");
    return 0;
}

Suponho, que esse código colocado depois do while que mostra os dados, correto ? não seria mais simples colocar um free(atual) antes da função system() ? não entendi o porque dessa lógica.

Um único free liberaria apenas um elemento, na lista foram criados vários elementos e por isso a necessidade da lógica.

[joubet]

Uso um Dev C++ versão 4.9.9.2. (uma ide mingw)

Se eu fizer

free (primeiro)
free(atual)
free(proximo)

seria a mema coisa

Obrigad

[EduardoS]

Não seria a mesma coisa, primeiro porque o free(proximo) não é possível e segundo porque a lista pode ter n elementos, e precisa de n "free"s.