Passing a constant by reference

[Bob Altman]

Hi all,

I want to call a function that takes a void* argument and pass it the address of
a constant. Is there a way to do this without explicitly defining the constant
and then passing the address of the constant? In other words, what I *don't*
want to do is this:

const int myInt = 5;
MyFunc(&myInt);

I want to do something more like this:

MyFunct(&(int)5);

TIA - Bob

[Jeroen Mostert]

Bob Altman wrote:

I want to call a function that takes a void* argument and pass it the address of
a constant. Is there a way to do this without explicitly defining the constant
and then passing the address of the constant? In other words, what I *don't*
want to do is this:

const int myInt = 5;
MyFunc(&myInt);

I want to do something more like this:

MyFunct(&(int)5);

A constant expression has no address; what you're asking for is meaningless.
It's like asking where the number 5 is stored in the computer. It's not
stored anywhere, it just *is*. Storage locations produce addresses, not
constant values. Aren't you accidentally confusing this with a literal
address, i.e.

MyFunc((void*) 5);

This will convert the integer 5 to a memory location and pass that as a
pointer. This will then most likely produce an access violation upon access,
since "5" is rarely a valid address, but if the "void*" is meant to merely
hold a pointer-sized value rather than an actual pointer, this might have
some meaning.

--
J.
http://symbolsprose.blogspot.com

[Ben Voigt [C++ MVP]]

Bob Altman wrote:

Hi all,

I want to call a function that takes a void* argument and pass it the
address of a constant. Is there a way to do this without explicitly
defining the constant and then passing the address of the constant? In
other words, what I *don't* want to do is this:

const int myInt = 5;
MyFunc(&myInt);

That won't work. Does your function actually accept a "const void *"
instead of a "void *"?

>
I want to do something more like this:

MyFunct(&(int)5);

TIA - Bob

[Bob Altman]

>Hi all,

>>
I want to call a function that takes a void* argument and pass it the
address of a constant. Is there a way to do this without explicitly
defining the constant and then passing the address of the constant? In other
words, what I *don't* want to do is this:

const int myInt = 5;
MyFunc(&myInt);

That won't work. Does your function actually accept a "const void *" instead
of a "void *"?

Yes, my function takes a "const void*"

[Bob Altman]

That won't work. Does your function actually accept a "const void *" instead

of a "void *"?

Actually, it turns out that I left the "const" off of the "void *" in my
function declaration. But I don't see how that affects my original question,
which was how to avoid explicitly declaring the constant and passing its
address.

[Jeroen Mostert]

Bob Altman wrote:

>That won't work. Does your function actually accept a "const void *" instead
of a "void *"?

Actually, it turns out that I left the "const" off of the "void *" in my
function declaration. But I don't see how that affects my original question,
which was how to avoid explicitly declaring the constant and passing its
address.

By taking its address. Let's get a few things straight here. This is a constant:

const int a = 5;

This is *not* a constant, but a constant expression:

5

Expressions (whether constant or not) do not *have* addresses. No storage is
allocated to them. If you want an address, you need a storage location. As I
mentioned, you can do this:

(const void*) 5

This is "the address with numerical value 5". It's not "the address of the
constant 5" because there's no such thing.

Why not take a step back and tell us what you're trying to ultimately
achieve, instead of insisting on the impossible?

--
J.

[Ben Voigt [C++ MVP]]

Bob Altman wrote:

>That won't work. Does your function actually accept a "const void
*" instead of a "void *"?

Actually, it turns out that I left the "const" off of the "void *" in
my function declaration. But I don't see how that affects my
original question, which was how to avoid explicitly declaring the
constant and passing its address.

Once you add the "const" your problem should disappear:

int(5); // creates a temporary of type int
MyFunct(&(int(5))); // takes the address of this temporary, references
can be bound to temporaries only if the reference is const

[Jeroen Mostert]

Ben Voigt [C++ MVP] wrote:

Bob Altman wrote:

>>That won't work. Does your function actually accept a "const void
*" instead of a "void *"?

Actually, it turns out that I left the "const" off of the "void *" in
my function declaration. But I don't see how that affects my
original question, which was how to avoid explicitly declaring the
constant and passing its address.

Once you add the "const" your problem should disappear:

int(5); // creates a temporary of type int
MyFunct(&(int(5))); // takes the address of this temporary, references
can be bound to temporaries only if the reference is const

This does not compile. We're talking pointers here, not references, and
there's no such thing as a void&.

--
J.

[Bob Altman]

That's just not in the language(s).

Thanks. That's the answer I was afraid I'd get. I'm stuck with passing
pointers 'cause I need to expose stuff using C bindings from a library that's
callable from other languages (Ada, FORTRAN, etc.).

[David Lowndes]

>Once you add the "const" your problem should disappear:

>>
int(5); // creates a temporary of type int
MyFunct(&(int(5))); // takes the address of this temporary, references
can be bound to temporaries only if the reference is const

This does not compile. We're talking pointers here, not references, and
there's no such thing as a void&.

Here's one that compiles (with VC2008):

void fn1( void * p )
{
int x = *static_cast<int*>(p);
}

fn1( const_cast<int *>( &static_cast<const int &>(5) ) );

.... but I think it stinks! :)

Dave

[Jeroen Mostert]

David Lowndes wrote:

>>Once you add the "const" your problem should disappear:

int(5); // creates a temporary of type int
MyFunct(&(int(5))); // takes the address of this temporary, references
can be bound to temporaries only if the reference is const

This does not compile. We're talking pointers here, not references, and
there's no such thing as a void&.

Here's one that compiles (with VC2008):

void fn1( void * p )
{
int x = *static_cast<int*>(p);
}

fn1( const_cast<int *>( &static_cast<const int &>(5) ) );

... but I think it stinks! :)

Oh, right... Ben's solution actually *does* work, with a slight modification
-- a cast to a reference forces generation of a bound temporary. The trick
is that the reference has to be const. Recall that the OP actually did want
to use a const void* after all, so no further casting is necessary:

MyFunct(&static_cast<const int&>(5));

Of course, this is still unsafe. MyFunct() better not store that pointer
anywhere for later use. It does meet the original requirement of not needing
to declare a separate variable, for whatever that's worth.

--
J.
http://symbolsprose.blogspot.com

[David Lowndes]

>void fn1( void * p )

>{
int x = *static_cast<int*>(p);
}

fn1( const_cast<int *>( &static_cast<const int &>(5) ) );

... but I think it stinks! :)

Oh, right... Ben's solution actually *does* work, with a slight modification
-- a cast to a reference forces generation of a bound temporary. The trick
is that the reference has to be const. Recall that the OP actually did want
to use a const void* after all, so no further casting is necessary:

Ah, I'd forgot he'd mentioned const later on in the thread.

>Of course, this is still unsafe. MyFunct() better not store that pointer
anywhere for later use.

I think that statement would apply to any local variable though.

>It does meet the original requirement of not needing
to declare a separate variable, for whatever that's worth.

Yes, it's just a way of achieving the same as the more clear way of
defining a local variable - the generated code will be pretty much
identical.

Dave

[Jeroen Mostert]

David Lowndes wrote:

>>void fn1( void * p )
{
int x = *static_cast<int*>(p);
}

fn1( const_cast<int *>( &static_cast<const int &>(5) ) );

... but I think it stinks! :)

Oh, right... Ben's solution actually *does* work, with a slight modification
-- a cast to a reference forces generation of a bound temporary. The trick
is that the reference has to be const. Recall that the OP actually did want
to use a const void* after all, so no further casting is necessary:

Ah, I'd forgot he'd mentioned const later on in the thread.

>Of course, this is still unsafe. MyFunct() better not store that pointer
anywhere for later use.

I think that statement would apply to any local variable though.

True, but the scope of a temporary is even smaller than that of a local
variable, and taking the address of one is even less common (so it might not
throw up a warning flag when it really should).

--
J.
http://symbolsprose.blogspot.com