Newsgroup: it.comp.lang.c++
Titolo: Limiti ???

scusate la domanda ma mi sto tirando scemo a cercare come risolvere un caso 
particolare ... ma se io definisco una var come :
unsigned long a = numeric_limits<unsigned long>.max();
e poi faccio a++;
mi dite come faccio a sapere di aver superato il limite maggiore cosi' da 
generare un caso particolare nella mia applicazione e rimettere a posto alcuni 
altri parametri prima di tornare alla normale esecuzione ???
ciao e grazie ...
ps: come mai questo caso non e' trattato in nessun manuale che ho letto fin'ora ???

 altri parametri prima di tornare alla normale esecuzione ???
[cut]
al posto di a++;
if (!++a) { ....... }
--------
Sergio Bianchi

 if (!++a) { ....... }
ma non ci sono modalita' standard per testare l'evenienza se non controllare che 
il valore abbia fatto un round nell'incremento ...
l'esempio era banale ... ma se sommo una certa quantita' non posso testare lo 0 
... dovrei salvarmi il valore precedente e controllare se in particolari 
situazioni il valore ha superato le barriere di controllo (ma anche questo 
richiede troppi controlli e non e' sicuro ...)
un modo di avere dalla cpu il valore dell'overflow ??? cosi' da aggiustarmi le 
cose ??? non esiste una modalita' standard senza usare ASM, magari un lancio di 
un'eccezione o altro ...
ciao

 un'eccezione o altro ...
Se tu stesso sei preoccupato di dover fare troppi controlli, come puoi
aspettarti che vengano *sempre* fatti? Tra parentesi lanciare
un'eccezione ad ogni overflow avrebbe un costo pazzesco.
Ciao,
Nicola

 // tutto a posto
si ma questo controllo se fossero dati float, long long, double, avrebbe un peso 
rilevante nell'esecuzione ...
io mi chiedo come mai avendo (lo hanno tutti ???) un bit di overflow di 
controllo che segnala gia' di suo questo evento, non poterlo utilizzare in modo 
molto rapido ? (un jump su un controllo flag e' 3000 volte piu' rapido che non 
fare un'altra sottrazione su quei dati)
quindi mi chiedevo come mai nello standard non hanno inserito tale controllo o 
feature ??? o se la hanno inserita come si usa ???
ciao

 ha scritto nel messaggio
news:bme2jg$q4r$1...@news.ngi.it...

Ho indicato "if (!++a)" perchè si tratta appunto di un operazione che può
essere eseguita in un registro del processore e che utilizza il flag di zero
del processore.
Equivalente quindi ad un incremento e un jmp on not zero. Direi che si fa
fatica a far di meno.
Nel caso  di somma di valori maggiori di 1 occorre notare che  il
compilatore interpone uno strato di astrazione tra il size dei registri del
processore e il tipo di dato.
Tu puoi fare la somma di due char o short in un registro a 32 bit e non
attivare il flag di carry. O magari sommare degli int64 con dei registri a
16 bit tramite una funzione di libreria. Essendovi svariate architetture di
processori diventa quindi arduo utilizzare caratteristiche di basso livello
all' interno del linguaggio.
--------
Sergio Bianchi

 all' interno del linguaggio.
ok ho bello che capito che e' meglio non prevedere piu' in la per fare qualcosa 
di totalmente sicuro ma farlo ed al massimo dopo chiudere i buchi dove serve ???
questa cosa mi e' saltata in mente perche' stavo usando i timer che essendo dei 
Ulong e contando i milli sec dallo start dell'applicazione arrivano a 40+ giorni 
e poi partono da capo ... ma cosi' facendo i controlli che uso per timizzare il 
tutto saltano peraria tenendomi poi in sleep le applicazioni per il resto 
dell'eternita' ...
quindi almeno li ho ovviato con un test posticipato (controllo usando il delta 
cosi' facendo se ho che il tempo salvato e' superiore di quello di ora mi esegue 
un controllo particolare che mi promuove il dato salvato in longlong e sottrae 
il fondo scala del Ulong ... almeno cosi' facendo ho sempre il delta giusto ... 
solo che cmq faccio un test in piu' su una funzione ad alta velocita' ed ad alto 
numero di chiamate ... :-p lo so che sono troppo paranoico ... ok torno a 
scrivere le altre parti almeno non ci penso piu' ...)
ciao

 del processore.
Peccato pero' che non funzioni, perche' per interi a n bit 2^n non e'
la rappresentazione di zero in nessuna delle rappresentazioni
comunemente utilizzate.
Ciao,
Nicola

"Nicola Musatti" <Nicola....@ObjectWay.it> ha scritto nel messaggio
news:a327cf48.03101...@posting.google.com...

Sarà strano il mio compilatore:
   numeric_limits<unsigned long> info;
   unsigned long a = info.max();
   if (!++a) { a = 10; }
   a = 20;
mi compila come :
call _STL:: ...........
mov[ebp-0x40], eax
inc dword ptr [ebp-0x40]
jnz +0x07
mov[ebp-0x40], 0x0000000a
mov[ebp-0x40], 0x00000014
--------
Sergio Bianchi

...

Non contesto il modo di tradurre il tuo frammento di codice quanto il
fatto che l'espressione ! ++a e' falsa per qualsiasi a diversa da -1.
Ciao,
Nicola