Newsgroup: it.comp.lang.c
Titolo: [NEWBIE] costruttore per 'lista'

altro problema niubbico... sob!!!
volendo giocare un po' con le liste, ho iniziato dall'inizio...
/* definizione tipo */
struct nodo{
        int nome;
        struct nodo *resto; /* pointer al resto della lista */
};
/* definizione costruttore */
struct nodo *crealista(int newnode, struct nodo *rest);
/* implementazione costruttore */
struct nodo *crealista(int newnode, struct nodo *rest){
        static struct nodo *newlistPtr; /* nodo static seno` sparisce */
        newlistPtr->nome=newnode;
        newlistPtr->resto=rest;
        return(newlistPtr);
}
...la chiamata a questo costruttore viene effettuata cosi`:
struct nodo *listaPtr;
listaPtr=crealista(0,NULL);
(esempio banale)
IL PROBLEMA e` che questa roba da` *seg.fault* !!
crealista() si pianta all'assegnamento ' newlistPtr->nome = newnode; '
(indipendentemente dai parametri)
c'e` un perche`??
blubbbb mi sono scervellato perche` la nuova struttura 'spariva' appena 
dopo averla creata, e l'ho messa static, ma quest'altro prob. nn lo 
indovino
grazie in advance,
-- 
    Pardo
 
http://pardo.cjb.net
 
    ( BACKUP: 
http://pardo.tsx.org
 )

 c'e` un perche`??
Certo!  newlistPtr e` 0 quindi stai cercando di scrivere in zone
basse della memoria, fortunatamente sono protette quindi hai
un bell'errore subito.
Aggiungi:
        newlistPtr = (struct nodo*) malloc(sizeof(struct nodo));
come prima istruzione della tua crealista, e togli lo static che non serve.
(Il cast non e` obbligatorio, ma secondo me e` meglio farlo...).
Alex

Pardo <no....@nowhere.nul> wrote in news:anppo8$eip$1
@
lacerta.tiscalinet.it
:
Nella funzione crealista scrivi in un puntatore (newlistPtr) non 
inizializzato. Questa è la ragione del gpf.
In teoria basta inizializzare il puntatore con malloc(sizeof(nodo));
In pratica, non ho capito perchè usi un puntatore static. A occhio non ha 
alcun senso.

         newlistPtr = (struct nodo*) malloc(sizeof(struct nodo));
okkkkkkk..... mi domando PERCHE` nn ci ho pensato subito che dovevo 
usare malloc..... e mi sono inventato la boiata del nodo statico..... 
bho saranno state le lasagne a pranzo!! ;P
grazie!!!!


 ha alcun senso.
la mia intenzione era di dichiarare statico il nodo
(altro ragionamento sbagliato)
dimenticavo la malloc... vabbeh mica x niente sono niubbo del C !!!
grazie a tutti!!


 (altro ragionamento sbagliato)
Si, è sbagliato perchè dichiarando static il puntatore in pratica la 
funzione può restituire ad ogni chiamata lo stesso puntatore, in pratica lo 
stesso nodo... e non mi sembra sia quello che vuoi fare. Tuttavia mettendo 
una malloc dopo la dichiarazione tu lo reinizializzi ad ogni chiamata, 
rendendo vana e inutile la dichiarazione static.
-- 
In silenzio anche un idiota sembra intelligente. Ma non c'è problema,
l'idiota vuol sempre dire la sua.

 serve. (Il cast non e` obbligatorio, ma secondo me e` meglio farlo...).
Mah...
Se metti il cast ti assumi tutta la responsabilita' della conversione di 
tipo (anzi quasi tutta, con un cast semplice c'e' ancora un tipo di 
conversione che non ti viene permesso facendo un cast cosi'): non so se uno 
che inizia sia pronto ad accollarsi la responsabilita', soprattutto quando 
si iniziano ad allocare strutture un po' complesse (es. un puntatore a 
puntatore a int per una matrice di interi).
Io consiglierei il contrario, ovvero non castare nulla a meno di non esserne 
obbligati (e' implicito che si deve anche sapere cosa si sta facendo :P).
-- 
Mox
"Trust the programmer."
"Don't prevent the programmer from doing what needs to be done."
"Keep the language small and simple."
"Provide only one way to do an operation."

 puntatore dentro una variabile statica?
Certo, puoi avere una struct statica che fra i suoi vari campi
ha uno o piu` puntatori.  La dichiareresti ad es
    static struct quelchele lavariabile;
cioe` senza nessun * (gli * apparirebbero entro la definizione
del tipo denominato "struct quelchele").
Alex

 (Il cast non e` obbligatorio, ma secondo me e` meglio farlo...).
Perche`?? Il C  e` weak typed,  un cast  (IMHO) equivale ad  un cartello
rosso lampeggiante  con scritto "sto facendo  qualcosa di potenzialmente
pericoloso!".
Visto che la conversione da 'void *'  a 'T *' e viceversa e` automatica,
direi che e` meglio non abusare del cast.
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
"La Via prosegue senza fine."
	Bilbo Baggins - Il Signore degli Anelli - J.R.R. Tolkien

 direi che e` meglio non abusare del cast.
Per DEFINIZIONE di "abusare", certo: ma a mio parere usare il
cast su malloc non e` un abuso, ma una buona abitudine.
Non rivelero` mai naturalmente che la mia preferenza e` una macro:
#define NEW(atype)  (((atype)*)malloc(sizeof(atype)))
visto che le macro sono forse la parte piu` abusata del C non vorrei
incoraggiarne ulteriori scempi (ma qui mi pare proprio meglio:-).
Alex

 incoraggiarne ulteriori scempi (ma qui mi pare proprio meglio:-).
Mi sembra di leggere lo Stroustrup :)  Vedo che gli anni a lavorare in C++ 
hanno lasciato il segno :)
<JOKE>
Se proprio vogliamo abusare delle macro e insegnare delle pessime abitudini 
ai programmatori, facciamolo seriamente:
    #define CAST(obj, type) (*((type *)&(obj)))
Cosi' puio veramente castare qualsiasi oggetto a qualsiasi tipo, alla faccia 
di tutti i controlli del compilatore (almeno, che mi risulti) :P
</JOKE>
[1] A me il cartellino piu' che "rosso lampeggiante" pare piccolo, scritto 
in nero opaco su sfondo nero opaco, appiccicato in una parte che non e' 
visibile a meno di un'attenta analisi... il warning mi da piu' l'idea di un 
cartellino rosso lampeggiante.


 trovo piu' inutile che mai :)
Effettivamente, nel caso ci si dimentichi di includere "stdlib", il cast
puo' dare dei problemi, pero' in questo caso il codice sarebbe compilabile
anche da un compilatore C++.
--------------------------------
Inviato via 
http://usenet.libero.it

 anche da un compilatore C++.
Un bel #ifdef per mettere il cast solo se è definita _cplusplus (che 
onestamente non mi ricorddo se sia proprio scritta così)?

 #define NEW(atype)  (((atype)*)malloc(sizeof(atype)))
Che bello non sono l'unico, anche se me ne sono sempre vergognato...

 onestamente non mi ricorddo se sia proprio scritta così)?
Si', anche.
