Newsgroup: it.comp.lang.c
Titolo: Problema salvataggio indirizzo

Salve a tutti,
ho questa funzione per l'inserimento alla testa di una funzione,
alla funziona passo la lunghezza del dato, il dato, il puntatore 
all'elemento di testa ed un puntatore a quello che dovrebbe essere 
l'elemento predecessore.
Ed il campo *p_pred della lista dovrebbe puntare all'elemento 
predecessore rispetto all'elemento in considerazione.
Es.
ptr  - dato da inserire
head - testa
nel momento in cui ptr viene inserito in testa il campo p_pred di coda 
dovrebbe puntare a ptr.
ecco la funzione:
void insl_testa(short len_info, INFO_FIELD *p_dato, void **p_head,void 
**pred) //inserimento in testa
{
struct lista
      {
        INFO_FIELD info;
        struct lista *p_next, *p_pred;;
      } *ptr;
ptr=calloc(1, sizeof(struct lista)); //alloco la memoria per il nuovo record
memcpy(ptr, p_dato, len_info);       //copio il dato nel record
ptr->p_next=(struct lista *)*p_head; //il dato inserito diventa 
l'elemento di testa, e acquisisce la vecchia testa come elemento successivo
ptr->p_pred=NULL; //la testa non ha predecessori
((struct lista *)*p_head)->p_pred=ptr;
//con questa istruzione vorre far puntare il campo p_pred di head a ptr 
//ma con questa istruzione il programma crasha
(struct lista *)*p_head=ptr;         //la testa precedente acquisisce 
come elemento successivo ptr
}
Qualcuno conosce perchè il mio programma va in crash in quella istruzione?
Grazie mille anticipatamente a chiunque leggera' questo lungo post :)

Manuel <I...@vanilla.sky> wrote:


void insl_testa(INFO_FIELD *p_dato, struct lista **pp_head)
{
  struct lista *ptr = malloc (sizeof *ptr);
  memcpy(ptr, p_dato, sizeof *p_dato);     
  ptr->p_next=*pp_head;
  ptr->p_pred=NULL;
  if (*pp_head!=NULL) (*pp_head)->p_pred=ptr;
  *pp_head=ptr;
}
int main()
{
   struct lista p_head=NULL;
   ...
   insl_testa(...,&p_head);
   ...
}
-- 
Horst

 Qualcuno conosce perchè il mio programma va in crash in quella istruzione?
No, ma lo si può riscrivere facilmente ;-)
/*
[root@andrea Desktop]# gcc -o lista lista.c
[root@andrea Desktop]# ./lista
list = []
list = [1]
list = [2,1]
list = [3,2,1]
list = [4,3,2,1]
list = [5,4,3,2,1]
list = [6,5,4,3,2,1]
list = [7,6,5,4,3,2,1]
[root@andrea Desktop]#
*/
#include <stdio.h>
#include <stdlib.h>
typedef struct node_t {
        int data;
        struct node_t * prev;
        struct node_t * next;
} node_t, *pnode_t;
typedef struct {
        pnode_t head; 
} list_t, *plist_t;
pnode_t node_new(int data)
{
    pnode_t self = malloc(sizeof *self);
    if (self) 
    {
       self->data = data;
       self->prev = NULL;
       self->next = NULL;
    }   
    return self;
}
int node_get_value(pnode_t self)
{
    if (self)
      return self->data;
}
pnode_t node_free(pnode_t self)
{
    if (self)
    {
       free(self);
    }
}
plist_t list_new(void)
{
    plist_t self = malloc(sizeof *self);
    if (self)
    {
       self->head = NULL;      
    }
    return self;
}
void list_add_as_head(plist_t self, int x)
{
    if (self)
    {
       pnode_t newnode = node_new(x);
       if (newnode)
       {
          newnode->next = self->head;
          if (self->head)
            self->head->prev = newnode;
          self->head = newnode;
       }
    }
}
void list_free(plist_t self)
{
     if (self)
     {
        pnode_t node = self->head;
        while (node)
        {
           pnode_t temp = node->next;
           free(node);
           node = temp;  
        }      
        free(self); 
     }
}
void list_print(plist_t self)
{
    if (self)
    {
       pnode_t node = self->head;
       printf("list = [");
       while (node)
       {
          printf("%d", node_get_value(node));
          if (node->next)
            printf(",");
          node=node->next;
       }
       printf("]\n");
    }
}
int main()
{
    int x[] = {1,2,3,4,5,6,7};
    int i;
    plist_t list = list_new();
    list_print(list);
    for (i=0; i<sizeof x/sizeof x[0]; i++)
    {
        list_add_as_head(list, x[i]);
        list_print(list);
    }
    list_free(list);
    return 0;
}
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 ((struct lista *)*p_head)->p_pred=ptr;
Perche' all'inizio, quando la lista e` vuota, (* p_head) e` NULL, quindi
cercando di dereferenziare un puntatore nullo, l'applicazione, ovviamente,
va in crash.
Questa istruzione deve essere protetta con un if per garantirne la
correttezza anche nel caso iniziale della lista vuota.
Come suggerito da altri, ti consiglio di riscrivere il codice e ti 
consiglio anche di NON dichiarare mai una struct dentro una funzione:
per quanto formalmente non sia sbagliato, ti costringe a ridichiararla
ogni volta che la devi usare, perche' la sua visibilita` e` limitata
al blocco in cui la dichiari (in questo caso la funzione).
E` ovvio che questo discorso cade se hai esigenze particolari, ma
sinceramente non vedo quali possano essere :)
Saluti,
Marco
-- 
To email me, remove the no_ and _spam from my address.

Grzie mille dei vostri consigli,
poi, se puo' interessarvi, ho risolto cosi':
if( ((struct lista *)*p_head) != NULL) ((struct lista 
*)*p_head)->p_pred=ptr;