Newsgroup: it.comp.lang.c++
Titolo: Conversione di tipo e gerarchia

 
Al link:
 
http://www.learncpp.com/cpp-tutorial/44-type-conversion-and-casting/
 
 
viene riportato l'interessante 'esempio:
 
5u - 10 == 4294967291
 
...se ho ben capito, per la precedenza gerarchica, 10, deve essere
promosso  ad unsigned, pero', i passaggi che vengono fatti non sono
riportati; deduco che, per ottenere quanto sopra, si dovrebbe avere:
 
5u - 10u + 4294967296 == 4294967291
 
...pero' non saprei se il ragionamento fatto e' giusto.
 
4294967296 e' il massimo valore rappresentabile per un unsigned
intero.
 
Ciao e grazie mille!

 Ciao e grazie mille!
 
 
-- 
1) Resistere, resistere, resistere.
2) Se tutti pagano le tasse, le tasse le pagano tutti
Soviet_Mario - (aka Gatto_Vizzato)
 

 intero.
 
p.s. il massimo valore rappresentabile di un unsigned di N 
bits è sempre dispari, ed è
2^N-1  oppure  2^(N-1) + 2^(N-2) + ... + 2^2 + 2^1 + 2^0


 2^N-1  oppure  2^(N-1) + 2^(N-2) + ... + 2^2 + 2^1 + 2^0
 
Dalla tabella al link:
 
http://www.learncpp.com/cpp-tutorial/24-integers/
 
 
viene riportato:
 
"4 byte unsigned	0 to 4.294.967.296"
 
e ho fatto riferimento, sbagliando, al predetto valore massimo nei
miei ragionamenti dell'esercizio, ma in realta' il massimo valore e':
 
4.294.967.295 == (2^32)-1
 
quindi nell'esercizio come si arriva a  5u - 10 == 4294967291 ?
 
Ciao e grazie mille!!!
 
 
 
 

 On 21 Apr, 17:55, Soviet_Mario <Soviet.Ma...@CCCP.MIR> wrote:
 
 
[cut]
 
 
Anche per questo es. non capisco come arriva al risultato:
 
====================================================
 
#include <iostream>
 
int main()
{
    using namespace std;
    unsigned short x = 0; // smallest 2-byte unsigned value possible
    cout << "x was: " << x << endl;
    x = x - 1; // We expect -1, we get overflow!
    cout << "x is now: " << x << endl;
}
 
==================================================
 
x was: 0
x is now: 65535
 
 
Ciao e grazie mille!!!
 

 
 
UINT_MAX, il massimo valore rappresentabile per un unsigned intero, è 
4294967295, su un normale sistema a 32bit.
 
 
Ciao  Manlio


x è un "unsigned short", quindi può essere rappresentato da un valore 
che va da 0 a 65535.
Vedi std::numeric_limits<unsigned short>::min() e 
std::numeric_limits<unsigned short>::max().
L'espressione
x = (unsigned short)(-1)
equivale a
x = (unsigned short)(65536 - 1)
che equivale a
x = (unsigned short)(65535)
In C++ i tipi nativi non vanno mai in overflow, o meglio l'overflow è 
gestito come un buffer circolare, per cui, nel caso di unsigned short:
65535 + 1 = 65536 % 65536 = 0
0 - 1 = 65536 - 1 = 65535
65500 + 100 = 65600 % 65536 = 64
1 - 3 = 65536 + 1 - 3 = 65534
In pratica è come la lancetta dei minuti in un orologio: se si trova sui 
59 minuti, il prossimo scatto porta la lancetta a 0 minuti.
Lo stesso per tutti gli altri tipi, anche quelli signed, solo che quelli 
signed hanno il min() negativo.
 

 1 - 3 = 65536 + 1 - 3 = 65534
 
1+(-3)== 1+(0-3)==1+(0-3)==1+(65536 -3u)==65534u
 
cioe' sostituisco 0 con 65536 che e' pari al (max_unsigned_short + 1)
 
con max_unsigned_short == 65535.
 
Ciao e grazie mille!!

 4294967295, su un normale sistema a 32bit.
 
Ciao e grazie mille!
 


 
Sto cercando (senza riuscirci) per esercizio, di trovare una formula
generale, per risolvere il riferimento circolare di uno short int:
 
cioe' se scrivo :
 
short int n= (32767 + 1) ottengo: -32768;
 
short int n=(32767+32769) ottengo:0;
 
short int n=(32767+32770) ottengo:1;
 
essendo il range di valori per un  intero:
 
-32768 to 32767
 
...magari trovando la formula generale si potrebbe scrivere un
programma che mi calcola il valore di short int nel caso si esca dai
limiti del relativo intervallo.
 
Ciao e grazie milleeeeee!!!


Perchè reinventare la ruota
se il tuo numero sta in un int basta usare climits.
 
 
#include <climits>
int n=...;
if (n > SHRT_MAX || n < SHRT_MIN) {
	// fuori dai limiti
}
 
 
 


Era un modo per cercare di allenarmi con gli algoritmi, ma purtroppo
non sono riuscito  a trovare una formula generale tipo quella che mi
era stata suggerita per gli unsigned integer.
 
Ciao e grazie mille!


Generale credo che sia impossibile o quasi senza usare climits
La dimensione di un short int non è detto che sia di 2 byte e il 
comportamento  in caso di overflow dipende dalla architettura
 
 
 


OK..ma supponiamo per ipotesi, e per puro spirito di esercitazione, di
avere sempre 2 byte di occupazione, sul mio pc (arch. a 32bit) noto:
 
 short int n= (32767 + 1) ottengo: -32768;
 
 short int n=(32767+32769) ottengo:0;
 
 short int n=(32767+32770) ottengo:1;
 
 short int n=32767+32770+32766 ottengo :32767;
 
...quindi si potrebbe trovare una formula risolutiva?
 
Ciao e grazie mille!
 
 
 


OK, l' architettura è il tuo PC e l' overflow si comporta in quel modo
Ma sul problema non so dirti molto; cosa significa 'una formula per 
trovare un riferimento circolare' ?
 
 


*Vedi risposta di Kan in questo thread per gli unsigned int...
 
Per gli unsigned int (intervallo 0 to max==65535),
 
se, ad es,. n=65600 > max si avra'
 
n= 65600 % 65536 == 64;
 
...quindi, se n *supera* il max per un unsigned, la formula che trova
n sara':
 
n%(max+1);
 
..credo che, la predetta formula, dovra' essere ciclata un certo
numero di volte fino ad ottenere un numero compreso tra "0 e
65535"..ma NON ho, al momento, il tempo di verificare se il
ragionamento fatto e' corretto.
 
Ciao e grazie milleeeeeee!
 
 
 
 
 
 
 
 
 
 
 
 


Scusa, intendevo unsigned short.
 
Ciao e grazie milleeee!
 
 

 wrote:

Una bozza di programma, per gli unsigned short,  potrebbe essere:
 
================================================
#include <iostream>
 
using namespace std;
 
int main()
{
 
    unsigned long  int uli_l;
    unsigned short int usi_n, usi_max=65535;
 
    //valore di prova per generare l'overflow per usi_n
    uli_l= usi_max*3;
 
    usi_n=uli_l;
 
  //verifico usi_n prima del while
    cout << usi_n << endl;
 
    while  (uli_l>usi_max) {
 
    uli_l=(uli_l)%(usi_max+1);
 
    }
 
   // verifico che uli_l dopo il while coincida con il valore di usi_n
   //prima del while
    cout << uli_l << endl;
 
    return 0;
}
 
=====================================================
 
 
...pare funzionare....cosa ne pensi?...chiaramente, il tutto, a solo
scopo di esercizio.
 
Ciao e grazie mille!
 
 
 
 

 Ciao e grazie milleeeeeee!


 [...]
 
 
Ciao  Manlio


Scusami, ma ho perso il filo...
Cosa stai cercando di fare con quel programma?
 
Inoltre, invece di 65535 dovresti scrivere USHRT_MAX, oppure 



Il risultato finale coincide con ' iniziale  ma, sono spiacente,non 
riesco a capire i termini del problema