distinguishing wheter void* ptr points to class A or class B?

[jacek.dziedzic]

Hello!

I have some legacy C code which expects a pointer to a function to
be evaluated at one point.
Because of the pointer-to-function vs. pointer-to-member
incompatibility, this needs to be a
global function. To aid the passing of some extra data to the
function, it takes an extra
parameter of type void* which is passed uninterpreted to it.

I am in a situation where this void* pointer can point either to
class A or to a class B,
which are not related. Is there a way to perform a reliable cast in
the function or otherwise
distinguish which the void* pointer actually points to? This is
compiled as C++.
I can static_cast<to whatever, but, obviously, if I get the class
wrong, this segfaults
at the first dereference of a member. dynamic_cast<does not work on
void*.

Is there a way out? I can modify classes A and B at will and the
function in question,
but its signature must remain intact.

TIA,
- J.

[Daniel Kraft]

I have some legacy C code which expects a pointer to a function to

be evaluated at one point.
Because of the pointer-to-function vs. pointer-to-member
incompatibility, this needs to be a
global function. To aid the passing of some extra data to the
function, it takes an extra
parameter of type void* which is passed uninterpreted to it.

I am in a situation where this void* pointer can point either to
class A or to a class B,
which are not related. Is there a way to perform a reliable cast in
the function or otherwise
distinguish which the void* pointer actually points to? This is
compiled as C++.
I can static_cast<to whatever, but, obviously, if I get the class
wrong, this segfaults
at the first dereference of a member. dynamic_cast<does not work on
void*.

Is there a way out? I can modify classes A and B at will and the
function in question,
but its signature must remain intact.

I'm not really sure whether this is valid, but I would try to define
some class C as:

class C
{
public:
virtual int getType() =0;
};

And have A and B inherit from C; then, cast your void* to C* (this is
what I'm not sure about whether it is valid to do), query for the type,
and proceed accordingly.

cheers,
Daniel
--
Got two Dear-Daniel-Instant Messages
by MSN, associate ICQ with stress--so
please use good, old E-MAIL!

[Ron Natalie]

Daniel Kraft wrote:

class C
{
public:
virtual int getType() =0;
};

And have A and B inherit from C; then, cast your void* to C* (this is
what I'm not sure about whether it is valid to do), query for the type,
and proceed accordingly.

Once you have a common polymorphic ancestor you can also use
dynamic_cast or typeid.

[Justin.SpahrSummers]

On Sep 22, 6:27 am, [e-mail] wrote:

I have some legacy C code which expects a pointer to a function to
be evaluated at one point.
Because of the pointer-to-function vs. pointer-to-member
incompatibility, this needs to be a
global function. To aid the passing of some extra data to the
function, it takes an extra
parameter of type void* which is passed uninterpreted to it.

I am in a situation where this void* pointer can point either to
class A or to a class B,
which are not related. Is there a way to perform a reliable cast in
the function or otherwise
distinguish which the void* pointer actually points to? This is
compiled as C++.
I can static_cast<to whatever, but, obviously, if I get the class
wrong, this segfaults
at the first dereference of a member. dynamic_cast<does not work on
void*.

You could simple define a small structure with a type tag and a
pointer:

struct C {
int type;
void *ptr; // to either an object of class A or class B
}

When you create the structure, modify the type field accordingly so
that it can be read back once you have to determine what class the
objects belong to. After that, it's just a simple static_cast<of the
'ptr' member.

[Justin.SpahrSummers]

On Sep 22, 11:48 am, "Alf P. Steinbach" <[e-mail]:

* [e-mail]:

On Sep 22, 6:27 am, [e-mail] wrote:

I have some legacy C code which expects a pointer to a function to
be evaluated at one point.
Because of the pointer-to-function vs. pointer-to-member
incompatibility, this needs to be a
global function. To aid the passing of some extra data to the
function, it takes an extra
parameter of type void* which is passed uninterpreted to it.

I am in a situation where this void* pointer can point either to
class A or to a class B,
which are not related. Is there a way to perform a reliable cast in
the function or otherwise
distinguish which the void* pointer actually points to? This is
compiled as C++.
I can static_cast<to whatever, but, obviously, if I get the class
wrong, this segfaults
at the first dereference of a member. dynamic_cast<does not work on
void*.

You could simple define a small structure with a type tag and a
pointer:

struct C {
int type;
void *ptr; // to either an object of class A or class B
}

When you create the structure, modify the type field accordingly so
that it can be read back once you have to determine what class the
objects belong to. After that, it's just a simple static_cast<of the
'ptr' member.

Uhm, well.

In C++ it's usually ungood to explicitly discriminate on type, when a
virtual function can do that type-discrimination.

Here's one way to Do Things (off the cuff, not compiled):

typedef void (*CCallbackFunc)( void* );
typedef void (*CFuncThatCallsBack)( CCallbackFunc, void* );
void generalCallback( void* );

struct AbstractCallbackHandler
{
virtual void onCallback() = 0;
void* pointer() { return this; }
invoke( CFuncThatCallsBack f ) { f( generalCallback, pointer(); }

Seems like you forgot a paren here.

};

CCallBackFunc generalCallBack( void* arg )

I think you meant "void", not "CCallBackFunc".

{
static_cast<AbstractCallbackHandler*>( arg )->onCallback();
}

template< class T void callbackFor( T& o );

template< class T >
struct CallbackHandler
{
T* p;
CallbackHandler( T& o ): p( &o ) {}
virtual void onCallback() { callbackFor( *p ); }
}

// ... code specific to using classes A and B:

template<callbackFor<A>( A& aha ) { ... }
template<callbackFor<B>( B& boo ) { ... }

extern "C" void someCFunc( CCallBackFunc callBackFunc, void* arg );

struct A {};
struct B {};

void doThingsTo( A& a )
{
CallbackHandler<A>( a ).invoke( someCFunc );
}

All of the code you gave took me a hell of a long time to parse... I
personally would opt for the simple and transparent structure. That
said, I couldn't have come up with the code you gave in a million
years... it's very clever.

[Kai-Uwe Bux]

Ron Natalie wrote:

Daniel Kraft wrote:

>class C
{
public:
virtual int getType() =0;
};

And have A and B inherit from C; then, cast your void* to C* (this is
what I'm not sure about whether it is valid to do), query for the type,
and proceed accordingly.

Once you have a common polymorphic ancestor you can also use
dynamic_cast or typeid.

You could use dynamic_cast on A* and B*. But you cannot use dynamic_cast to
get from void* to C*.
Best

Kai-Uwe Bux

[Heinz Ozwirk]

"Daniel Kraft" <[e-mail] im Newsbeitrag
news:fd**********@newsreader2.utanet.at...

> I have some legacy C code which expects a pointer to a function to
be evaluated at one point.
Because of the pointer-to-function vs. pointer-to-member
incompatibility, this needs to be a
global function. To aid the passing of some extra data to the
function, it takes an extra
parameter of type void* which is passed uninterpreted to it.

I am in a situation where this void* pointer can point either to
class A or to a class B,
which are not related. Is there a way to perform a reliable cast in
the function or otherwise
distinguish which the void* pointer actually points to? This is
compiled as C++.
I can static_cast<to whatever, but, obviously, if I get the class
wrong, this segfaults
at the first dereference of a member. dynamic_cast<does not work on
void*.

Is there a way out? I can modify classes A and B at will and the
function in question,
but its signature must remain intact.

I'm not really sure whether this is valid, but I would try to define some
class C as:

class C
{
public:
virtual int getType() =0;
};

And have A and B inherit from C; then, cast your void* to C* (this is what
I'm not sure about whether it is valid to do), query for the type, and
proceed accordingly.

In practice it probably works, but the original pointer, either to an
instance of A or B, must be cast to C* before the result of this cast is
converted to void*. Otherwise problems might occure when multiple
inheritance is used.

Heinz