Can we emplace small object on void*? - c++

Question

Suppose there's API like below:
typedef void callback_t(void* data);
void addCallback(handle_t h, callback_t callback, void* data);
I'd like to wrap this API to a higher order C++ interface:
template<class F, bool emplace = IsEmplaceable<F>::value>
struct MakeCallback;
class Handle
{
template<class F>
void addCallback(F f)
{
::addCallback(_h, MakeCallback<F>::f, MakeCallback<F>::create(f));
}
handle_t _h;
};
so that the user can pass any callable object (e.g. lambda function).
I'd like to apply small object optimization to avoid dynamic alloc (e.g. for empty lambdas), the trait IsEmplaceable<F> decides whether F can be emplaced in a void*.
For F that is not emplaceable, MakeCallback can be implemented like below:
template<class F>
struct MakeCallback<F, false>
{
static void f(void* data)
{
auto f = static_cast<F*>(data);
(*f)(status);
delete f;
}
static void* create(F& f)
{
return new F(std::move(f));
}
};
For F that is emplaceable, how could I properly implement the following?
template<class F>
struct MakeCallback<F, true>
{
static void f(void* data)
{
// from void* to F
}
static void* create(F& f)
{
// form F to void*
}
};
More basically, can a void* hold a non-address value if we don't use it as a pointer? will it be UB?

Answer 1

A very big warning should be mentioned before even attempting the code shown in this answer. Doing this is most likely very very undefined and not portable behavior. I would highly suggest not doing this as it could very well break a long time into the future and you will have a very hard time finding out why.
That being said, it appears to work on at least my compiler. Results may vary for other compilers. I use a union to convert between a class instance and a void *, don't know of any other clean way to do this. This should work as long as sizeof( Class ) <= sizeof( void * ), but I make no guarantees on behavior with different compilers or even with the exact same compiler I used on my exact same setup.
#include <iostream>
using namespace std;
class Small {
public:
int i;
};
void *castToVoid( Small& s ) {
union {
Small s;
void *p;
} un;
un.s = s;
return un.p;
}
Small castToSmall( void *p ) {
union {
Small s;
void *p;
} un;
un.p = p;
return un.s;
}
int main( ) {
Small s;
s.i = 100;
void *p = castToVoid( s );
s.i = 200;
cout << p << endl; // Prints 0x64
Small s2 = castToSmall( p );
cout << s2.i << endl; // Prints 100
}
or this example for converting to/from a void *
void *castToVoid( Small& s ) {
void **p = reinterpret_cast< void ** >( &s );
return *p;
}
Small castToSmall( void *p ) {
Small *s = reinterpret_cast< Small * >( &p );
return *s;
}

Answer 2

It's implementation-defined behavior according to the C++ standard (draft N3797).
§ 3.7.4.2/p4
Indirection through an invalid pointer value and passing an invalid
pointer value to a deallocation function have undefined behavior. Any
other use of an invalid pointer value has implementation-defined
behavior.
footnote 38:
Some implementations might define that copying an invalid pointer
value causes a system-generated runtime fault
§ 3.7.4.3/p4
An implementation may have relaxed pointer safety, in which case the
validity of a pointer value does not depend on whether it is a
safely-derived pointer value. Alternatively, an implementation may
have strict pointer safety, in which case a pointer value referring to
an object with dynamic storage duration that is not a safely-derived
pointer value is an invalid pointer value unless the referenced
complete object has previously been declared reachable (20.7.4) [...] It is implementation
defined whether an implementation has relaxed or strict pointer safety.
(emphasis mine)
So it is safe if the implementation has relaxed pointer safety, and we can use the union trick as shown in the answer from #Smith_61 to avoid strict aliasing.