Re: 64 bit C++ and OS defined types
On May 2, 10:48 pm, blargg....@gishpuppy.com (blargg) wrote:
"Bo Persson" <b...@gmb.dk> wrote:
Tony wrote:
James Kanze wrote:
On Apr 29, 8:51 am, "Tony" <t...@my.net> wrote:
Alf P. Steinbach wrote:
Why do you want a signed type to indicate a quantity, which
can't be negative? Aren't you wasting half its potential values?
No, there's no waste except for the case of a single byte
array that's more than half the size of addressable memory,
which on a modern system you simply will not ever have.
There's no waste because that extra range isn't used, and
cannot be used (except for the single now purely
hypothetical case mentioned).
Would you ever use a signed integer to represent a memory address?
Would you ever use an integral type to represent a memory address?
I use an unsigned integer type, via preprocessor define,
that is the appropriate width for the target platform.
But the question remains: Why is there such a wide demand
for storing adresses in integral type variables? What is
wrong with pointers and references?
This is slightly useful in a C-style interfaces which call a
user function and allow the user to pass some data along
unchanged. Rather than using a union:
union Data {
void* p;
int i;
};
void library( void (*user_func)( Data ), Data d )
{
// ...
user_func( d );
}
which involves some inconvenience on the part of the user,
they instead accept an intptr_t (or equivalent if you don't
have stdint.h):
void library( void (*user_func)( intptr_t ), intptr_t d )
{
// ...
user_func( d );
}
This allows the user to pass a plain integer without any work,
or pass a pointer via a cast at the call site and a cast
inside user_func.
If you're talking about things like the argument to
pthread_create, this isn't so much a question of storing a
pointer as an int, as of storing an int as a pointer; the system
passes a void*, with the idea that this can point to anything.
If all you need is a small integral value, of course, converting
it to a pointer to be passed, then converting it back in the
callback, avoids many of the lifetime of object issues involved
if you pass the address of an int, and dereference. Of course,
it also involves a lot of undefined behavior, but in practice,
it will probably work on most Unix machines (and if you're
invoking pthread_create, you're under Unix); the portability
risk may be deamed less a problem than the added complexity of
managing the lifetime of the int designated by the pointer if
you use a real pointer.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34