Re: Weird V-table issue
On Jul 24, 10:05 pm, harsh.mur...@gmail.com wrote:
In the example below, a single object (Network) is
implementing 2 interfaces (INetworkA and INetworkB). Both of
these interfaces derive from the IBase interface (similar to
the IUnknown interface of the COM world). Network object also
implements the QueryInterface methods from IBase interface.
In the main function, I am doing a QueryInterface on the
INetworkA interface. It returns me the pointer to the second
interface INetworkB. On this pointer, if I perform a function
of the INetworkB, the control is jumping into one of
INetworkA's functions.
Can anyone tell me why this is happening? The problem goes
away if I am doing a cast when I am returning the interface
pointer. But I am still not convinced that this is the correct
behavior by the compiler. How does casting affect a V-table
of a object pointer?
The below program compiles and runs fine on a GNU C++ compiler.
#include <stdio.h>
/* Base Interface */
class IBase
{
public:
virtual int F1() = 0;
virtual int QueryInterface (void **ppOut) = 0;
virtual int QueryInterface2 (void **ppOut) = 0;
};
/* Some interface */
class INetworkA: public IBase
{
public:
virtual int NA() = 0;
virtual int QueryInterface (void **ppOut) = 0;
};
/* Another interface */
class INetworkB: public IBase
{
public:
virtual int NB() = 0;
};
One quick question: do you really want two independent instances
of IBase in your hierarchy? Since IBase doesn't contain any
data, it may not matter, but depending on which one you get,
there's no INetworkA or no INetworkB which derives from the
IBase. Almost always, in such cases, you should be deriving
virtually.
/* This object implements both interfaces */
class Network : public INetworkA,
public INetworkB
{
public:
int F1() { printf("Network::F1()\n"); }
int NA() { printf("Network::NA()\n"); }
int NB() { printf("Network::NB()\n"); }
int QueryInterface (void **ppOut) {*ppOut = this; return 0;}
int QueryInterface2 (void **ppOut) {*ppOut = (INetworkB *) this;
return 0;}
};
int main()
{
Network *netObj = new Network();
INetworkA *pINetA = netObj;
INetworkB *pINetB = netObj;
pINetA->NA();
pINetB->NB();
/* Weirdness happens here */
/* Get the INetworkB interface using QueryInterface() with no
casting */
pINetA->QueryInterface ((void **) &pINetB);
And what is the (void**) supposed to be doing.
What it actually does is introduce undefined behavior. Anything
can and will happen. (Note that there's not even a guarantee
that a void* has the same size and representation as an
INetworkB*; I've actually used a machine where a void* was
bigger than a pointer to a class. Which means that when the
code in the function assigns through the dereferenced void**,
it's going to overwrite memory beyond the end of the
INetworkB*.)
=46rom here on out, of course, anything can happen. (In a typical
implementation on a modern architecture, you'll get a pointer to
the complete object in pINetB, and not a pointer to the
INetworkB subclass of the complete object. And since most
compilers will lay out the base classes in the order they
appear, that means a pointer to Network, which will also work
like a pointer to the INetworkA subobject, i.e. the initial part
of the Network vtable is identical to that of INetworkA. But of
course, that's just an artifact of the way it happens to be
implemented; it's not at all guaranteed.)
The only way to do this correctly is to have the interface take
a pointer to the correct type of pointer. Once you pass through
void*, the compiler looses all information concerning the
inheritance hierarchy, and anything can happen.
pINetB->NB();
/* Get the INetworkB interface using QueryInterface2() which does
casting*/
pINetA->QueryInterface2 ((void **) &pINetB);
Same problem as above. In this case, however, since you have
the correct corresponding cast in the function, the only problem
is that you're type punning between an INetworkB* and a void*.
(Which means that it will work *IF* the two have the same size
and representation, which is the case on most modern machines.)
pINetB->NB();
return 0;
}
Drop all of your C style casts. In such cases (navigating in a
hierarchy), you should be using only dynamic_cast. And the
places where the dynamic_cast won't compile are the places where
the C style casts do the wrong thing.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34