Newsgroup: it.comp.lang.delphi
Titolo: Integer vs Longint

Salve a tutti,
mentre mi rileggevo l'ottimo Object Pascal Language Guide della Borland
mi sono imbattuto nella seguente affermazione:
Types can be classified as either fundamental or generic. The range and
format of a fundamental type is the same in all implementations of 
Object Pascal, regardless of the underlying CPU and operating system.
The range and format of a generic type is platform-specific and could
vary across different implementations. Most predefined types are
fundamental, but a handful of integer, character, string, and 
pointer types are generic. It’s a good idea to use generic types when 
possible, since they provide optimal performance and portability. 
However, changes in storage format from one implementation of a generic
type to the next could cause compatibility problems—for example, if you
are streaming data to a file.
Ora, il punto è: in base a cosa si afferma che il codice scritto 
utilizzando un tipo generico, ad esempio integer è più portatile del
suo analogo scritto utilizzando longint? Non è forse vero il contrario?
Grazie,
Clemente.
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

Clemente.
E' un vecchio discorso che risale al linguaggio C,
e' piu' portabile verso piattaforme minori, passando
ad esempio, da 32 a 16 bit non avrai errore di
compilazione nel caso in cui il compilatore a 16
bit non gestisca i 32, e' un discorso che ormai
non credo regga piu' (specialmente per delphi)...
Per l'efficienza invece ha ragione, molto spesso
l'uso di istruzioni macchina che usano valori
pari alla parola del processore e' piu' efficiente
dell'uso di istruzioni che lavorano su dati
piu' piccoli.

non credo regga piu' (specialmente per delphi)...
Scusa, adesso ti spiego il vero motivo: immagina di aver
scritto un programma che riceve dei dati in input, per
"stare largo" hai scelto un Longint che permette di
inserire 2 miliardi di elementi nella struttura informativa
del tuo programma.
Dieci anni dopo la velocita' dei processori e' enormemente
superiore e la qta di memoria ram anche, il tuo utente
dice "finalmente posso inserire nel mio programma
100 miliardi di dati !"; no, non puo' perche' tu hai messo
longint, se mettevi integer sulla nuova archiettura
non sarebbe stato a 32 bit ma a 128 quindi il tuo utente
avrebbe soddisfatto il suo desiderio semplicemente
ricompilando il programma per il nuovo computer (senza
modificare i sorgenti).
Adesso chiaramente ho esagerato comunque il concetto
e' questo: i tipi dipendenti dalla macchina permettono
al software di "crescere" insieme alla piattaforma.
p.s.
Andrea Laforgia deve aver fatto indigestione con il panettone :-)

 del tuo programma.
ma che è la versione per cerebrolesi del tuo primo post? :-)
struttura informativa? ma che intendi?  variabile? (o se proprio vogliamo
fare i fighi lvalue)... :-)
Battute a parte, il tuo primo post propone una chiave di lettura
interessante che cmq non condivido.
Un programma un minimo utile,  scritto e compilato su una piattaforma ad
architettura  32-bit non può girare su una a 16-bit al di là del fatto che
si utilizzino o meno tipi fondamentali / generici (il compilatore ottimizza
per l'architettura, le api e la gestione della memoria cambiano) e che sia
scritto o meno in C.
Ora nel caso di porting del sorgente con relativa compilazione sull'host
16-bit io preferisco usare un tipo fondamentale 32-bit e beccarmi un
errore in compilazione che mi dice che il tipo 32 non è supportato
piuttosto che un eventuale errore a runtime o peggio ancora un wrap
around del valore della variabile attorno agli estremi perchè uso un
generico e l'insieme dei valori che può assumere si riduce.
Oltre tutto se devo realizzare del codice portabile mi sembra il caso di
pretendere che il size di un tipo non cambi da una piattaforma /
implementazione ad un'altra (vedi java ad esempio) ergo uso un
fondamentale.
Tirando le somme a me pare (e potrei sbagliarmi) che:
tipo generico -> ottimizzazione ma codice dipendente dalla piattaforma
tipo fondamentale -> codice portabile in quanto dove compilabile garantisce
contro range violation.

suo analogo scritto utilizzando longint? Non è forse vero il contrario?
In realta`, il problema non e` se usare integer o longint, in quanto
entrambi sono dipendenti dal sistema, ne` la guida afferma quanto hai
riportato.  In realta`, sul discorso della portabilita` si puo` essere
piu` o meno d'accordo, mentre e` vero senz'altro che, utilizzando tipi
"generic", si ottengono prestazioni ottimali (usi le dimensioni della
macchina su cui stai lavorando).  Le due cose, in realta`, credo si
fondino, cioe` si ha una portabilita` delle performance ;-) 
Un tipo "integer" e` automaticamente adattato alle dimensioni della
parola macchina e quindi puoi usare il tipo "integer" sapendo che
sara`, presumibilmente, la scelta migliore in quanto a efficienza su
qualsiasi piattaforma.  

 delle performance ;-)
ecchevvordě? :-)

ecchevvordě? :-)
Vuol dire che sei sicuro di utilizzare sempre al meglio le risorse
della macchina.  Usare un intero significa usare sicuramente un tipo
trattabile dal processore nel migliore dei modi, su qualsiasi
piattaforma tu ti trovi.  Poi e` chiaro che in un linguaggio come
Delphi (vedi anche il fatto che le architetture distinte su cui e`
distribuito sono relativamente poche) queste considerazioni assumono
un carattere marginale, anche perche` raramente si scrive in Delphi un
programma che possa spremere la CPU al millesimo, ma ti assicuro che
in C o in C++ questi problemi, specie se si lavora a basso livello,
vengono presi in considerazione.

contro range violation.
cedo che ti sbagli, imho naturalmente ;-)
ciao
carlo

 i casi che si presentano
Ma la cosa più simpatica è quando affermi che ho posto due differenti
domande (ti ricordo che longint è un tipo fondamentale).
Primo Post:
Ora, il punto è: in base a cosa si afferma che il codice scritto
utilizzando un tipo generico, ad esempio integer è più portatile del
suo analogo scritto utilizzando longint? Non è forse vero il contrario?
Secondo post:
la guida dice che generico è più portabile di fondamentale. Secondo voi è
vero?

[...](ti ricordo che longint č un tipo fondamentale).
Infatti non ricordavo che lo fosse e, comunque, da un punto di vista
logico, non ha senso che lo sia (cosi` come non ha senso che lo siano
Shortint, Smallint, Word e Longword).  In realta` questi tipi
dovrebbero variare, in dimensioni, al variare dell'architettura, cosi`
come accade, ad esempio, in C, in cui e` solo assicurato:
sizeof(char) = 1 <= sizeof(short) <= sizeof(int) <= sizeof(long)
Ma nulla e` stabilito a priori su quale sia la lunghezza in bit di
ciascun tipo.