Is this standard-conforming?

I'm trying to find this in C++ standard (ISO/IEC 14882) but unfortunately I can't.

Code:

// external functions (in DLL if this matters at all)
extern "C" int Set(void* Ptr);
extern "C" int Get(void** Ptr);

// ...

UserClass* a;
Set(a);

// ...

UserClass* ptr;
Get(reinterpret_cast<void**>(&ptr));

Is this standard conforming? Will it result in undefined behaviour? I am SURE that Get() will return pointer to UserClass not to something else.

I have my doubts because there is a hidden conversion from UserClass* to void* (I know I can solve this using a temporary variable).

>> Is this standard conforming?
Yes. Any pointer type can be safely cast to a void* and then back again to the original pointer type. The only exception is that member [function] pointers do not have a guaranteed round-trip though a void*.

gg

If a is uninitialised, then accessing its value in the call "Set(a)" gives undefined behaviour.

Beyond that, after the call to Get(), ptr is not guaranteed to contain the value of a (the pointer provided to Get()) unless you judiciously use reinterpret_cast inside the Get() function. Which is unlikely to be happening, if Get() is written in C and not written with knowledge of what UserClass is.

You would be better off having Get() of the form

Code:

extern "C" void *Get();

A simple static_cast<> on the return value of that will retrieve the address of the original object.

Thanks for the replies.

I forgot to initialize, but this is only a sample, illustrating the reinterpret_cast<> problem. I know that any pointer can be casted to void*, but the problem is, this cast is "hidden" here. In fact, this conversion does not take place at all (I was wondering if pointer representation is guaranteed to be the same for all types)

I know that I can return this pointer, but the return variable is reserved for error codes.

Originally Posted by Codeplug

The only exception is that member [function] pointers do not have a guaranteed round-trip though a void*.

Good to know this.

Originally Posted by kmdv

I know that any pointer can be casted to void*, but the problem is, this cast is "hidden" here.

Your problem is with having two levels of indirection, not one (i.e. converting a pointer to pointer into a pointer to pointer to void). That's why you need the reinterpret cast.

A pointer to pointer to X is not implicitly convertible to a pointer to pointer to void for a reason.

Originally Posted by kmdv

In fact, this conversion does not take place at all (I was wondering if pointer representation is guaranteed to be the same for all types)

I assume you mean the conversion is not changing value for your compiler.

The standard guarantees that conversion of a pointer into a void pointer, and back, yields the original pointer. That is not quite the same as saying that all pointers (other than to member functions) must have the same representation although, obviously, that is a common way to achieve it.