[Resolvido] passando struct simples da lista encadeada com argume

[Gilian 0]

O negocio é o seguinte, eu fiz a função de busca de lista encadeada

a minha função tem como argumentos: Um ponteiro para o nó inicial da

lista, a chave a ser procurada, e um ponteiro

que será "preenchido" (apontará) para esse nó procurado.

 

Só que o problema é que quando eu aplico minha função, é como se

esse ponteiro que deveria apontar para meu elemento

procurado não voltasse preenchido.

 

O código C está aí, ele tá todo comentado pra ficar

bem facil de ler. Mas vou cola-lo de qualquer forma aqui.

Já estou a dias nesse negocio, lí mto sobre ponteiros mas esse eu

não entendí...

 

Abç!!

 

#include "stdio.h"
#include "stdlib.h"

/*Definindo a estrutura Nó de lista simplesmente encadeada */
      struct NoLSE {
        int info;
        struct NoLSE *prox ;
        } ;
    
 /*funcao que busca um elemento e preenche o ponteiro pont*/
 void busca (struct NoLSE *no1 , int chave ,struct NoLSE *pont) {
     struct NoLSE *pt;
     pt = no1 ;
     pont = NULL ;   
     while (pt != NULL) {
       if (pt->info == chave) {
           pont = pt ;           /* Aqui é onde deveria ocorrer o apontamento certo? */
           pt = NULL ;
             } 
       else {
         pt = pt->prox ;      
           } ;    
     } ;
} ;
/*fim da função*/                
           
int main () {
        struct NoLSE *pont ;            /*declarando variaveis do tipo nó de lista encadeada*/
        struct NoLSE *no1 ;
        struct NoLSE *no2 ;       
        no1 = (struct NoLSE*) malloc(sizeof(struct NoLSE));  /*alocando espaço na memoria*/
        no2 = (struct NoLSE*) malloc(sizeof(struct NoLSE));        
        no1->info = 10 ;                /*atribuindo valores*/
        no2->info = 20 ;
        no1->prox = no2 ;               /*construindo a lista (apontando nós)*/
        no2->prox = NULL ;
        busca(no1,20,pont) ;        /*chamando a funçao que deveria achar o no que contem 20
                                    como informação e fazer o ponteiro "pont" apontar para 
                                    esse nó */
                                                  
/*teste*/printf ("%d" , ((*pont).info == no1->info)) ;/* O erro é exibido aqui, é como se
                                                      /* pont não retornasse apontando 
                                                      /* para o elemento procurado!    
                                                      /* a impressao prova o erro!     
                                                      /* na verdade nao imprime é nada! rsrs */
}

[_Isis_ 202]

17 pont = pt ; /* Aqui é onde deveria ocorrer o apontamento certo? */

6: chave = 20

5: *pt = {info = 20, prox = 0x0}

4: pt = (struct NoLSE *) 0x804b018

(gdb) display pont

7: pont = (struct NoLSE *) 0x0

(gdb) s

18 pt = NULL ;

7: pont = (struct NoLSE *) 0x804b018

6: chave = 20

5: *pt = {info = 20, prox = 0x0}

4: pt = (struct NoLSE *) 0x804b018

(gdb) s

15 while (pt != NULL) {

7: pont = (struct NoLSE *) 0x804b018

6: chave = 20

Disabling display 5 to avoid infinite recursion.

5: *pt = Cannot access memory at address 0x0

[Gabriel... 0]

Caríssimo,

 

Eu vi aqui rapidão, mas acho que o problema esteja aqui:

 

while (pt != NULL) {

if (pt->info == chave) {

pont = pt ; /* Aqui é onde deveria ocorrer o apontamento certo? */

pt = NULL ;

}

else {

pt = pt->prox ;

} ;

} ;

Mais especificamente aqui:

pt = NULL

Pois se ele acha a chave, então:

pont = pt;

Depois em seguida você colocou:

pt = NULL ;

Logo, sempre:

pont = NULL;

Tente retirar a linha:

pt = NULL ;

[Gabriel... 0]

Caríssimo,

Esquece o que eu falei ai em cima....

 

Tente pegar o ponteiro (do valor onde a chave seja igual ao valor passado) como retorno da função:

 

#include "stdio.h"
#include "stdlib.h"

/*Definindo a estrutura Nó de lista simplesmente encadeada */
      struct NoLSE {
        int info;
        struct NoLSE *prox ;
        } ;
    
 /*funcao que busca um elemento e retorna o ponteiro*/
struct NoLSE *busca (struct NoLSE *no1 , int chave) {
     struct NoLSE *pt;
     pt = no1 ;
     while (pt != NULL) {
       if (pt->info == chave) 
       {
           return pt;     
       }    
       pt = pt->prox ;         
     } 
     return NULL;
} ;


int main () {
        struct NoLSE *pont ;            /*declarando variaveis do tipo nó de lista encadeada*/
        struct NoLSE *no1 ;
        struct NoLSE *no2 ;  
             
        no1 = (struct NoLSE*) malloc(sizeof(struct NoLSE));  /*alocando espaço na memoria*/
        no2 = (struct NoLSE*) malloc(sizeof(struct NoLSE));        
        no1->info = 10 ;                /*atribuindo valores*/
        no2->info = 20 ;
        no1->prox = no2 ;               /*construindo a lista (apontando nós)*/
        no2->prox = NULL ;
        pont=busca(no1,20) ;
        
        printf ("%d" , ((*pont).info == no1->info)) ;
        
        system("PAUSE");             
}

[Gilian 0]

 

Tente pegar o ponteiro (do valor onde a chave seja igual ao valor passado) como retorno da função:

 

 

Olá Gabriel!

 

mas então meu velho, o caso é que essa função ainda é simplificada, nessa função

ainda teria mais outro ponteiro que entrava como parametro da função ("ante"), esse outro ponteiro sairia da

função "preenchido" (apontando) para o nó anterior ao nó encontrado na busca. para ajudar em inserçoes e remoçoes posteriores...

Eu queria saber como faço pra essa função realmente modificar para onde "pont" aponta, (e meu outro ponteiro "ante" -q aponta p o anterior-)

 

por isso que fazer com que ela retorne o ponteiro não não é viavel entende (se fosse só pra retornar o ponteiro que aponta para o nó achado aí tudo bem, mas necessito de duas modificaçoes "ante" e "pont")

Valeu!

 

(q coisa, eu tbm faço ciencia da computação, rsrs)

[VictorCacciari 42]

Logo, se você não consegue usar o ponteiro, use um ponteiro para ele!

=D

 

Não esqueça, em C, passagens por referência são feitas com ponteiros. (em outras linguagens também são, mas o compilador administra eles para nós, em C é feito "na unha")

/*funcao que busca um elemento e preenche o ponteiro pont*/
void busca (struct NoLSE *no1 , int chave ,struct NoLSE **pont) {
     struct NoLSE *pt;
     pt = no1 ;
     (*pont) = NULL ;   
     while (pt != NULL) {
       if (pt->info == chave)
       {
           (*pont) = pt ;           /* Aqui é onde deveria ocorrer o apontamento certo? */
           pt = NULL ;
       } 
       else
       {
         pt = pt->prox ;      
       }    
     }
}

[Gilian 0]

Logo, se você não consegue usar o ponteiro, use um ponteiro para ele!

=D

 

Não esqueça, em C, passagens por referência são feitas com ponteiros. (em outras linguagens também são, mas o compilador administra eles para nós, em C é feito "na unha")

/*funcao que busca um elemento e preenche o ponteiro pont*/
void busca (struct NoLSE *no1 , int chave ,struct NoLSE **pont) {
     struct NoLSE *pt;
     pt = no1 ;
     (*pont) = NULL ;   
     while (pt != NULL) {
       if (pt->info == chave)
       {
           (*pont) = pt ;           /* Aqui é onde deveria ocorrer o apontamento certo? */
           pt = NULL ;
       } 
       else
       {
         pt = pt->prox ;      
       }    
     }
}

 

Woow meu velho!!

funcionou perfeitamente!

daí lá na chamada da função foi só eu botar onde entrava o "Pont" : (&pont)

aí deu tudo certo!

 

mas me diga uma coisa, isso daí é chamado de "atribuição indireta" ?

 

lembro q meu professor falou algo relacionado, mas não tinha entendido mto bem.

 

Obrigado a todos!!!