Newsgroup: it.comp.lang.c++
Titolo: domanda sulla dimensione di INT e LONG INT ????

Ciao a tutti,
non sono sicuro di esseri IT, dato che la dimensione dei tipi non dipende 
dallo standard ma dalla macchina e dal compilatore... ma forse no!
Il dilemma riguarda il fatto che nella mia macchina se dichiaro INT o LONG 
INT ottengo la stessa cosa,
cioè 32 bits !?!?! Perchè?
Ho eseguito il segiente codice per prova...
 //////////////////////////
/************************************************************
Ambiente: Dev-C++ 4.9.8.1, Athlon/750 128mb RAM, Windows98
***********************************************************/
  #include <iostream>
#include <limits>
#include <iomanip>
int main() {
    using namespace std;
    cout << "long int:\n";
    numeric_limits<long int> long_info;
    cout<< long_info.digits << endl;
    cout<< long_info.min() << endl;
    cout<< long_info.max() << endl;
  cout << "int:\n";
    numeric_limits<int> int_info;
    cout<< int_info.digits << endl; cout<< int_info.min() << endl;
    cout<< int_info.max() << endl;
    cout << "float:\n";
    numeric_limits<float> float_info;
    cout<< float_info.digits << endl;
    cout<< float_info.min() << endl;
    cout<< float_info.max() << endl;
    cout << "long double:\n";
    numeric_limits<long double> long_d_info;
    cout<< long_d_info.digits << endl;
    cout<< long_d_info.min() << endl;
    cout<< long_d_info.max() << endl;
    long double x = -1;
    cout << x << endl;
    system("PAUSE");
    return 0;
}
--------------OUTPUT:
long int:
31
-
2147483648
2147483647
int:
31
-
2147483648
2147483647
float:
24
1.17549e-038
3.40282e+038
long double:
64
0
1.#INF
-1
Premere un tasto per continuare...
/////////////////////////////////////////////////////////////
Ho anche fatto una prova inizializzando un intero a 214748364 e poi 
incrementandolo di uno, ed effetivamente mi va all'opposto cioè - 
214......ecc.
Qualcuno mi sa dire il perchè?
Grazie, Checco.

 Qualcuno mi sa dire il perchč?
perche' se hai studiato saprai che il processore puo' fare solo operazioni
elementari (- + * \ , e i logici) e solo su numeri interi ( non linciatemi
subito ;-) ) per riuscire ad usare numeri interi negativi e non dover
inserire nuove componenti per calcolo di numeri negativi nel processore, si
e' pensato di rappresentare i numeri negativi in base 2 (che al confronto
dell'altro circuito richiedono solo pochi transistor per essere trasformati)
quindi ora avendo numeri in base 2 ottieni che puoi fare sempre e solo i
calcoli base senza dover controllare il segno degli operandi ed il risultato
sara' cmq giusto (moltiplicazioni e divisioni veranno cmq trattate in
un'altro modo particolare).
ora se hai compreso questo e sai fare complementi a 2 e trasformazione da
base 10 a base 2 prova a fare:
2147483647
+
         1=
-----------
2147483648
questo vale solo in base 10 ... se proviamo a fare lo stesso calcolo in base
2 (lo abbrevio in base 16 seno' mi sparo dallo scrivere 1 ...) avremo:
7fffffff+
00000001=
---------
80000000
ed ora ? bhe semplicemente se stavi usando numeri senza segno avresti il
risultato giusto che ti aspettavi il canonico : 
2147483648
ma se invece usavi numeri in base 2 trovi magicamente un errore di calcolo
che la tua cpu dovrebbe cmq segnalarti perche' il controllo interno dovrebbe
darti un int di errore (pero' e' ignorabile se non sei tu a controllarlo)
ed il risultato e' quello che hai trovato, cioe' : -
2147483648
ciao

> Qualcuno mi sa dire il perchè?
Grazie per la spiegazione. :)
Ciao, Checco.

 ed il risultato e' quello che hai trovato, cioe' : -
2147483648
Non e' un errore, tipicamente un processore ha un flag di "overflow" che
segnala appunto gli "sforamenti" di valore.
In assembler e' testabile facilmente, in "C" ci si dovrebbe appoggiare a del
codice assembler "inline" o a qualche libreria esterna e/o estensione del
compilatore.

 compilatore.
si volevo scrivere delle estensioni dei compilatori ma non volevo fare
ancora piu' casino in testa ad uno che non ha ancora capito la matematica di
base del calcolatore ;-) (per me sarebbe stata troppa carne al fuoco se poi
avesse chiesto pure dei compilatori ne uscivano altre 2 paginate di
spiegazione ...)
ciao e grazie per l'erratac. ho veramente cannato alla grande ...

 ed il risultato e' quello che hai trovato, cioe' : -
2147483648
Non mi risulta ci sia un errore di calcolo e nemmeno di overflow. Dove lo
vedi? In questo caso la CPU non ti segnala nulla, perché dovrebbe?
Il fatto è che si usa il primo bit per indicare il segno, se lavori con
segno. Quindi tutti i numeri superiori a 0x80000000 sono negativi. Se lavori
senza segno sono tutti positivi. Sto ovviamente parlando di un processore
con word a 32bit. Il discorso si applica facilemente ad altre misure (8, 16
bit).
Enrico

 bit).
se fai somme e sottrazioni con segno (in architettura x86 sono 2 diversi
comandi asm segno e non) e percaso nella somma succede di modificare il
segno dell'operazione fuori dai parametri del comando il processore lo
segnala con una flag, che poi in programmazione c non si vada a fare il
controllo delle flag del processore poco importa, lui lo segnala !!!
(segnala se la somma di due positivi diventa un negativo e se la somma di
due negativi diventa positiva, almeno questi sono i controlli minimi ...)
ora non ho sotto mano tutti i miei appunti di calcolatori, se vuoi pero'
tutte le definizioni ecc, posso vedere se ti riesco a trovare un link per
leggere il tutto di come si fanno i calcoli ed i controlli all'interno di un
processore ... (x86 ... ho solo quelli ...)