Overflow Underflow

[JKop]

union SignedChoice{
long with_sign;
unsigned long without_sign;
};
int main()
{
SignedChoice data;

data.with_sign = -1;
//Right now, does the C++ Standard guarantee that
//data.without_si gn == MAX_ULONGINT?

//Similarly:

data.without_si gn = MAX_ULONGINT;

//Is data.with_sign now definitely == -1?

}
Is there any other interesting facts yous can give me?

-JKop

[Howard]

"JKop" <NU**@NULL.NULL > wrote in message
news:PF******** *********@news. indigo.ie...

union SignedChoice{
long with_sign;
unsigned long without_sign;
};
int main()
{
SignedChoice data;

data.with_sign = -1;
//Right now, does the C++ Standard guarantee that
//data.without_si gn == MAX_ULONGINT?

//Similarly:

data.without_si gn = MAX_ULONGINT;

//Is data.with_sign now definitely == -1?

}

I'm pretty sure that it doesn't. From what I understand, the standard does
not dictate the specific representation of a signed integer type (i.e,
whehter it's two's-complement, one's-complement, etc.). What is wel-defined
is the overflow/underflow behavior of an unsigned integer value, not its
direct equivelance to a signed integer value. So, adding x to a value to
casue an overflow can always be reversed by then subtracting x from that
result. Likewise, you can undo an underfolw by adding back the value
subtracted. But that doesn't neccessarily mean that s signed value of -1 is
the same bit representation as an unsigned value of max_whatever.

-Howard

[Howard]

Geez, how many typos can I make in one post??? I'll have to get my fingers
checked. :-)

-Howard

[tom_usenet]

On Mon, 28 Jun 2004 16:27:27 GMT, JKop <NU**@NULL.NULL > wrote:

union SignedChoice{
long with_sign;
unsigned long without_sign;
};
int main()
{
SignedChoice data;

data.with_sign = -1;
//Right now, does the C++ Standard guarantee that
//data.without_si gn == MAX_ULONGINT?
No, you can't write to one member of a union and read from another, at
least not like that (you can with structs with identical initial
sequences), so the point is moot.

If you are asking whether the bit pattern of -1 is guaranteed to be
all 1s, then the answer is no. 1's complement CPUs will give (for a
16-bit int):
111111111111111 0
Sign magnitude CPUs will give:
100000000000000 1

However, most CPUs these days do use 2s complement for signed numbers.
Is there any other interesting facts yous can give me?

Depending on your interests:
http://www.lingolex.com/ants.htm

Tom
--
C++ FAQ: http://www.parashift.com/c++-faq-lite/
C FAQ: http://www.eskimo.com/~scs/C-faq/top.html

[JKop]

Imagine a class that is absolutely massive in memory, maybe even a MB. You
want to swap two of these classes, and so obviously you don't want a
temporary. What do yous think of the following? I ain't got a compiler at
the moment so it's untested, and may be syntactically incorrect in places.
template<class Class> void Swap(Class& x, Class& y)
{
if ( (&x == &y) ) return;

unsigned char* const &pArrayX = reintepret_cast <unsigned char* const
&>(&x);
unsigned char* const &pArrayY = reinterpret_cas t<unsigned char*
const &>(&y);

for ( unsigned char i = 0 ; i < sizeof(Class); ++i)
{
pArrayX[i] += pArrayY[i];

pArrayY[i] = pArrayX[i] - pArrayY[i];

pArrayX[i] -= pArrayY[i];
}
};
The only reason I define those references is for enhanced readability.

-JKop

[Howard]

"JKop" <NU**@NULL.NULL > wrote in message
news:Jk******** *********@news. indigo.ie...

Imagine a class that is absolutely massive in memory, maybe even a MB. You
want to swap two of these classes, and so obviously you don't want a
temporary. What do yous think of the following? I ain't got a compiler at
the moment so it's untested, and may be syntactically incorrect in places.
template<class Class> void Swap(Class& x, Class& y)
{
if ( (&x == &y) ) return;

unsigned char* const &pArrayX = reintepret_cast <unsigned char* const &>(&x);
unsigned char* const &pArrayY = reinterpret_cas t<unsigned char*
const &>(&y);

for ( unsigned char i = 0 ; i < sizeof(Class); ++i)
{
pArrayX[i] += pArrayY[i];

pArrayY[i] = pArrayX[i] - pArrayY[i];

pArrayX[i] -= pArrayY[i];
}
};
The only reason I define those references is for enhanced readability.

-JKop

Without looking at the code close enough to check the details, I see what
you're trying to do, and it won't always work. You can't always treat a
class as an array of unsigned char. If it contains non-POD types, I think
you get undefined behavior when writing to the array.

-Howard

[Thomas Matthews]

JKop wrote:

Imagine a class that is absolutely massive in memory, maybe even a MB. You
want to swap two of these classes, and so obviously you don't want a
temporary. What do yous think of the following? I ain't got a compiler at
the moment so it's untested, and may be syntactically incorrect in places.

Generally, when classes, objects, instances or data is massive
in memory, you want to avoid swapping the beasts. Most programmers
use pointers to massive data and just swap the pointers.

If you don't want to use a temporary variable, then try swapping
individual members of the classes. One would say that less
memory is used swapping a class' member than the whole class.
This could even trickle down for aggregate and sub-classes.

Again, ask yourself why you are swapping the monstrosities
rather than pointers to them.

--
Thomas Matthews

C++ newsgroup welcome message:
http://www.slack.net/~shiva/welcome.txt
C++ Faq: http://www.parashift.com/c++-faq-lite
C Faq: http://www.eskimo.com/~scs/c-faq/top.html
alt.comp.lang.l earn.c-c++ faq:
http://www.raos.demon.uk/acllc-c++/faq.html
Other sites:
http://www.josuttis.com -- C++ STL Library book

[JKop]

Thomas Matthews posted:

JKop wrote:

Imagine a class that is absolutely massive in memory, maybe even a MB.
You want to swap two of these classes, and so obviously you don't want
a temporary. What do yous think of the following? I ain't got a
compiler at the moment so it's untested, and may be syntactically
incorrect in places.

Generally, when classes, objects, instances or data is massive
in memory, you want to avoid swapping the beasts. Most programmers
use pointers to massive data and just swap the pointers.

If you don't want to use a temporary variable, then try swapping
individual members of the classes. One would say that less
memory is used swapping a class' member than the whole class.
This could even trickle down for aggregate and sub-classes.

Again, ask yourself why you are swapping the monstrosities
rather than pointers to them.

Very good point, but I'm just doing this for fun. If I had to formulate a
bullshit reason for wanting to swap the values of variables I'd say
something like so:

A certain piece of hardware, Hardware A, is accessing a certain piece of
memory.

A certain piece of hardware, Hardware B, is accessing another certain piece
of memory.

You cannot change the address of the memory they're accessing so you've to
physically swap them around in memory.
-JKop

[Ioannis Vranos]

JKop wrote:

union SignedChoice{
long with_sign;
unsigned long without_sign;
};
int main()
{
SignedChoice data;

data.with_sign = -1;
//Right now, does the C++ Standard guarantee that
//data.without_si gn == MAX_ULONGINT?
No since long and unsigned long are different types and they can be of
different size. Also their representation implementation may be
different, for example for one type it may be from left to right and for
the other from right to left (my mind has stuck and I do not recall the
exact terminology right now).

//Similarly:

data.without_si gn = MAX_ULONGINT;

//Is data.with_sign now definitely == -1?

The same with what I told above.

}
Is there any other interesting facts yous can give me?

Have a slow thorough read of a good, up to date ISO C++ book like "The
C++ Programming Language" 3rd Edition or Special Edition by Bjarne
Stroustrup, the creator of C++.

However the last one is not for newcomers, and if you have not read any
other C++ introduction book *from cover to cover*, may be you had better
check "Accelerate d C++" by Andrew Koenig, Barbara Moo.


Regards,

Ioannis Vranos

[Ioannis Vranos]

JKop wrote:

Imagine a class that is absolutely massive in memory, maybe even a MB.

Types do not occupy space, objects do. For example:

class A
{
int array[512];
};

The above definition does not occupy any space. However

A a;
does.

Objects occupying massive amounts of memory usually mean that there is
very bad design.

If you have container objects for example, the object itself is a
representation and when you swap you do not copy everything, but
exchange the internal structures (e.g. pointer variables pointing to
sequences on the free store).

In any case, stick with std::swap and provide specialisations of it for
your classes, in case you *can* perform some hand-written optimisations.
Otherwise the default one will be used (usually implemented to use a
temporary object).


Regards,

Ioannis Vranos