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<in t*>(p);
}

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

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

Dave