inc unsigned (whatever) beyond limit.

[.rhavin grobert]

when i do a.....
________________________________________________
unsigned int iTest; // lets asume 'int' = 32bit
iTest = 0xFFFFFFFF;
iTest++;
________________________________________________

does the std say something what shall happen now?
May i safely assume iTest is now 0 or is it CPU or sys-dependent?
TIA, ~.rhavin;)

[Zeppe]

..rhavin grobert wrote:

when i do a.....
________________________________________________
unsigned int iTest; // lets asume 'int' = 32bit
iTest = 0xFFFFFFFF;
iTest++;
________________________________________________

does the std say something what shall happen now?
May i safely assume iTest is now 0 or is it CPU or sys-dependent?
TIA, ~.rhavin;)

the second one.

best, zeppe

[.rhavin grobert]

On 21 Okt., 17:57, Zeppe <[e-mail]>
wrote:

.rhavin grobert wrote:

when i do a.....
________________________________________________
unsigned int iTest; * *// lets asume 'int' = 32bit
iTest = 0xFFFFFFFF;
iTest++;
________________________________________________

does the std say something what shall happen now?
May i safely assume iTest is now 0 or is it CPU or sys-dependent?

TIA, ~.rhavin;)

the second one.

best, zeppe

CPU-dependent? damn, that's the worst case!

[REH]

On Oct 21, 11:57*am, Zeppe
<[e-mail] e:

.rhavin grobert wrote:

when i do a.....
________________________________________________
unsigned int iTest; * *// lets asume 'int' = 32bit
iTest = 0xFFFFFFFF;
iTest++;
________________________________________________

does the std say something what shall happen now?
May i safely assume iTest is now 0 or is it CPU or sys-dependent?

TIA, ~.rhavin;)

the second one.

best, zeppe

That is incorrect. Assuming unsigned int is 32-bits, result will
always be 0.

REH

[Maxim Yegorushkin]

On Oct 21, 4:57*pm, Zeppe
<[e-mail] e:

.rhavin grobert wrote:

when i do a.....
________________________________________________
unsigned int iTest; * *// lets asume 'int' = 32bit
iTest = 0xFFFFFFFF;
iTest++;
________________________________________________

does the std say something what shall happen now?
May i safely assume iTest is now 0 or is it CPU or sys-dependent?

TIA, ~.rhavin;)

the second one.

Wrong answer.

The C and C++ standards guarantee the wrapping for unsigned integer
types.

Here is a relevant quote from C99 6.2.5:

A computation involving unsigned operands can never overflow, because
a result that cannot be represented by the resulting unsigned integer
type is reduced modulo the number that is one greater than the largest
value that can be represented by the resulting type.

--
Max

[Victor Bazarov]

Maxim Yegorushkin wrote:

[..]
The C and C++ standards guarantee the wrapping for unsigned integer
types.

Here is a relevant quote from C99 6.2.5:
[..]

Why C99? C++ has its own Standard, does it not?

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Obnoxious User]

On Tue, 21 Oct 2008 09:27:47 -0700, Maxim Yegorushkin wrote:

>.rhavin grobert wrote:

when i do a.....
________________________________________________
unsigned int iTest; Â* Â*// lets asume 'int' = 32bit
iTest = 0xFFFFFFFF;
iTest++;
________________________________________________

does the std say something what shall happen now?
May i safely assume iTest is now 0 or is it CPU or sys-dependent?

TIA, ~.rhavin;)

the second one.

Wrong answer.

The C and C++ standards guarantee the wrapping for unsigned integer
types.

Here is a relevant quote from C99 6.2.5:

A computation involving unsigned operands can never overflow, because
a result that cannot be represented by the resulting unsigned integer
type is reduced modulo the number that is one greater than the largest
value that can be represented by the resulting type.

Sure C++ has a C legacy, but quoting the C standard
in a C++ context just looks wrong, even if the actual
text is almost the same.

--
OU
Remember 18th of June 2008, Democracy died that afternoon.
http://frapedia.se/wiki/Information_in_English

[=?UTF-8?B?RXJpayBXaWtzdHLDtm0=?=]

On 2008-10-21 18:49, Victor Bazarov wrote:

Maxim Yegorushkin wrote:

>[..]
The C and C++ standards guarantee the wrapping for unsigned integer
types.

Here is a relevant quote from C99 6.2.5:
[..]

Why C99? C++ has its own Standard, does it not?

For your pleasure:

3.9.1/4:
"Unsigned integers, declared unsigned, shall obey the laws of arithmetic
modulo 2^n where n is the number of bits in the value representation of
that particular size of integer."

--
Erik Wikström

[Zeppe]

Maxim Yegorushkin wrote:

>>______________________________________________ __
unsigned int iTest; // lets asume 'int' = 32bit
iTest = 0xFFFFFFFF;
iTest++;
______________________________________________ __
does the std say something what shall happen now?
May i safely assume iTest is now 0 or is it CPU or sys-dependent?
TIA, ~.rhavin;)

the second one.

Wrong answer.

The C and C++ standards guarantee the wrapping for unsigned integer
types.

My bad. Actually, I know that piece, I just ignored the comment as a
compiler would do. So, the result IS sys-dependent, BUT if you assume
that all the systems in which that code will be compiled are going to be
32bit, then is safe to assume that iTest is going to be zero after the
increment.

Sorry about that.

Best wishes,

Zeppe

[blargg]

In article <gd**********@aioe.org>, Zeppe
<ze***@remove.all.this.long.comment.yahoo.itwrot e:

Maxim Yegorushkin wrote:

>_______________________________________________ _
unsigned int iTest; // lets asume 'int' = 32bit
iTest = 0xFFFFFFFF;
iTest++;
_______________________________________________ _
does the std say something what shall happen now?
May i safely assume iTest is now 0 or is it CPU or sys-dependent?
TIA, ~.rhavin;)
the second one.

Wrong answer.

The C and C++ standards guarantee the wrapping for unsigned integer
types.

My bad. Actually, I know that piece, I just ignored the comment as a
compiler would do. So, the result IS sys-dependent, BUT if you assume
that all the systems in which that code will be compiled are going to be
32bit, then is safe to assume that iTest is going to be zero after the
increment.

How about this:

unsigned i = UINT_MAX;
i++;
assert( i == 0 );

[.rhavin grobert]

On 21 Okt., 20:23, [e-mail] (blargg) wrote:

In article <gdl4cv$[e-mail]>, Zeppe

<[e-mail] e:

Maxim Yegorushkin wrote:

>>______________________________________________ __
>>unsigned int iTest; * *// lets asume 'int' = 32bit
>>iTest = 0xFFFFFFFF;
>>iTest++;
>>______________________________________________ __
>>does the std say something what shall happen now?
>>May i safely assume iTest is now 0 or is it CPU or sys-dependent?
>>TIA, ~.rhavin;)
>the second one.

Wrong answer.

The C and C++ standards guarantee the wrapping for unsigned integer
types.

My bad. Actually, I know that piece, I just ignored the comment as a
compiler would do. So, the result IS sys-dependent, BUT if you assume
that all the systems in which that code will be compiled are going to be
32bit, then is safe to assume that iTest is going to be zero after the
increment.

How about this:

* * unsigned i = UINT_MAX;
* * i++;
* * assert( i == 0 );

Actually it's that one:
________________________________

typedef unsigned __int64 QUAD;

class foo {
foo(): m_qSel(0) {};
public:
inline QUAD NextSelector() {return m_qSel++;};
private:
QUAD m_qSel;
};

[Paavo Helde]

".rhavin grobert" <cl***@yahoo.dekirjutas:

On 21 Okt., 20:23, [e-mail] (blargg) wrote:

[...]

>How about this:

* * unsigned i = UINT_MAX;
* * i++;
* * assert( i == 0 );

Actually it's that one:
________________________________

typedef unsigned __int64 QUAD;

class foo {
foo(): m_qSel(0) {};
public:
inline QUAD NextSelector() {return m_qSel++;};
private:
QUAD m_qSel;
};

And you are wondering what happens when this wraps over? Let's see,
assuming for example million increments in a second(*), this happens ...
in approx. 9000 years! It's really reassuring to know the behavior will
be well-defined!

Paavo

(*) and assuming unsigned __int64 is an implementation-defined unsigned
64-bit integer type following the same rules as standard types.

[Michael]

..rhavin grobert wrote:

when i do a.....
________________________________________________
unsigned int iTest; // lets asume 'int' = 32bit
iTest = 0xFFFFFFFF;
iTest++;
________________________________________________

does the std say something what shall happen now?
May i safely assume iTest is now 0 or is it CPU or sys-dependent?
TIA, ~.rhavin;)

It is now 0 because it is unsigned and int is 32 bits.
Unsigned integer 'overflow' is always safe.

[.rhavin grobert]

On 22 Okt., 08:57, Paavo Helde <[e-mail]:

".rhavin grobert" <[e-mail]:

On 21 Okt., 20:23, [e-mail] (blargg) wrote:

[...]

How about this:

* * unsigned i = UINT_MAX;
* * i++;
* * assert( i == 0 );

Actually it's that one:
________________________________

typedef unsigned __int64 QUAD;

class foo {
* foo(): m_qSel(0) {};
public:
* inline QUAD NextSelector() {return m_qSel++;};
private:
* QUAD m_qSel;
};

And you are wondering what happens when this wraps over? Let's see,
assuming for example million increments in a second(*), this happens ...
in approx. 9000 years! It's really reassuring to know the behavior will
be well-defined!

Paavo

(*) and assuming unsigned __int64 is an implementation-defined unsigned
64-bit integer type following the same rules as standard types.

*sigh* humans!

;-)