Newsgroup: it.comp.lang.c++
Titolo: lista dinamica

Ho il seguente programma:
#include <iostream.h>
struct Lnodo {
       char dato;
       Lnodo *succ;
       };
void main () {
Lnodo *base=NULL, *p;
cout << "Introdurre una sequenza di caratteri (^Z per terminare):" << endl;
char ch;
while (cin.get(ch)) {
   p = new Lnodo;
   p->dato = ch;
   p->succ = base;
   base = p;
   }
while (p) {
   cout << p->dato;
   base = p;
   p = p->succ;
   delete base;
   }
}
Vorrei sapere l'istruzione
   p = new Lnodo;
che dimensione da a p?
Grazie.


La tua domanda e' rivolta a sapere la dimensione di Lnodo se ho ben capito.
Be', teoricamente sarebbe della dimensione di un char + la dimensione di un
puntatore, per cui dovrebbe essere di 5 bytes.
Ma poi entrano in gioco altri fattori che dipendono dal fatto che la
dimensione delle strutture potrebbero essere estese automaticamente dal
compilatore aggiungendo dei campi dummy in modo tale da dare sempre un
multiplo di un numero minimo di bytes di allocazione per una struttura.
Ad esempio, sul VisualC++ 6, la tua struttura ha size 8, pur essendo
chiaramente composta da 5 bytes.
Il main comunque deve restituire un int per il C++ standard e inoltre
dovresti usare <iostream>, facendo precedere std:: a cout, cin e endl.
Maurus

 dimensione di un puntatore, per cui dovrebbe essere di 5 bytes.
Non vorrei dire una fregnaccia, ma la dimensione di p non è sizeof(LNodo*)?
Non dovrebbe essere uguale a sizeof(void*)?
--
"Computer science is not about computers any more than astronomy
is about telescopes." -- EW Dijkstra

Ti ringrazio, ma scusa la mia ignoranza, mi potresti spiegare perchè il
programma stampa l'imput da tastiera al contrario.
Grazie

> capito.
In effetti la domanda poteva essere ambigua.
Maurus


Perche' se guardi bene come hai implementato la tua lista, lo hai fatto
proprio al contrario!
Dovresti invertire la logica di succ.
Maurus

 chiaramente composta da 5 bytes.
Anche il Borland, è abbastanza comune per IA32.
Comunque il modo migliore secondo me è usare sizeof(LNodo) e sizeof(LNodo*)
per conoscere i valori, dato che dipendono da molte cose quei valori.
Ad esempio con il Borland se cambi l'opzione del compilatore data align,
ottieni risultati diversi, con byte sizeof(LNodo) è 5, con word è 6, con
double word o quad word si ottiene 8.
Ovviamente sizeof(LNodo*) è comunque 4 perché i processori IA32 indirizzano
la memoria a 32 bit.
Ma ripeto... non è assolutamente una regole e quindi l'unico modo certo è
usare sizeof.

 La dimensione di p si', e' la dimensione di un puntatore qualsiasi.
credo che lo standard non garantisca che tutti i puntatori abbiano le 
stesse dimensioni - anche se non conosca alcuna architettura per cui 
cio` sia vero.
ciao Anto


 cio` sia vero.
Come sarebbe possibile?
-- 
Marco Barisione (ICQ 84277092)

 Come sarebbe possibile?
 
e lo chiedi a me? :-))
Beh, comunque non la vedo cosi` impossibile: se il compilatore decide di 
memorizzare gli int solo nelle prime 2^16 celle di memoria per un int* 
bastano 16 bit, mentre per gli altri puntatori magari ne sua 32.
Ok, sarebbe una str**zata enorme: ma d'altronde io non scrivo compilatori 
ne` standard, quindi :-))


 bastano 16 bit, mentre per gli altri puntatori magari ne sua 32.
Mi sembra piu' plausibile un'architettura nella quale i puntatori che
indirizzano word intere richiedono meno bit di quelli che indirizzano
singoli byte.
Ciao,
Nicola

 Come sarebbe possibile?
lo può essere. Leggere la FAQ di comp.lang.c, riguardo alla portabilità 
(scarsa) di parecchie comuni presupposizioni sui puntatori. Alcune sono 
da mettersi le mani nei capelli (ad esempio quanto vale NULL sulla Lisp 
Symbolic Machine)
-- 
 < 
http://www.reactos.com/
 >  Open source clone of Windows NT. Current
     Don't stand, REACT!      version 0.0.21. C, C++ and ASM developers
                              and beta testers are welcome!