Re: Weird V-table issue
harsh.murari@gmail.com wrote in news:54675b4d-190f-472f-83b9-
5e9d4778511e@i24g2000prf.googlegroups.com:
By an large you don't need this kind of complexity in C++, but assuming for
the moment that you did....
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;
You don't really need to mention this again. It will be inherited from
IBase.
};
/* Another interface */
class INetworkB: public IBase
{
public:
virtual int NB() = 0;
};
/* 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;}
this will reflect the type of the interface used to call the function. So,
you will always return the same interface which which you called the
QueryInterface() method.
int QueryInterface2 (void **ppOut) {*ppOut = (INetworkB *) this;
return 0;}
For both this method and the previous, you should use dynamic_cast to cast
the pointer to the appropriate type. dynamic_cast will return 0 if the
interface isn't supported,so you can have your return value actually mean
something as well. So, you might have:
int QueryInterface(void **ppOut) { *ppOut = dyanamic_cast<INetworkA *>
(this); return *ppOut == 0; }
int QueryInterface2(void **ppOut) { *ppOut = dyanamic_cast<INetworkB *>
(this); return *ppOut == 0; }
};
I haven't actually compiled the above, but it should work.
The way you have this implemented you don't really accomplish much. It is
much easier to just use static_cast or dynamic_cast directly to get the
interface you want. If the idea as to restrict access to interfaces, then
you need to use private inheritance instead of public and provide methods
to get you going. For example,
class IBase
{ public:
virtual int QueryInteface(void **ppOut) = 0;
virtual int QueryInterface2(void **ppOut) = 0;
};
class INetworkA
{
public:
virtual int NA() = 0;
virtual int QueryInterface2(void **ppOut) = 0;
};
class INetworkB
{
public:
virtual int NB() = 0;
virtual int QueryInterface(void **ppOut) = 0;
};
class Network : public IBase, private INetworkA, private INetworkB
{
public:
int F1() { printf("Network::F1()\n"); }
int QueryInterface(void **ppOut) { *ppOut = dyanamic_cast<INetworkA *>
(this); return *ppOut == 0; }
int QueryInterface2(void **ppOut) { *ppOut = dyanamic_cast<INetworkB *>
(this); return *ppOut == 0; }
private:
int NA() { printf("Network::NA()\n"); }
int NB() { printf("Network::NB()\n"); }
};
int main()
{
Network *netObj = new Network();
// INetworkA *pINetA = netObj; now fails
// INetworkB *pINetB = netObj; now fails
// pINetA->NA();
// pINetB->NB();
INetworkA * pINetA;
INetworkB * pINetB;
/* Get the INetworkA interface using QueryInterface() */
netObj->QueryInterface ((void **) &pINetA);
pINetA->NA();
/* Get the INetworkB interface using QueryInterface2() */
pINetA->QueryInterface2 ((void **) &pINetB);
pINetB->NB();
// Now complete the circuit
INetworkA * pNetA2;
pINetB->QueryInterface((void **) &pINetA2);
pINetA2->NA();
return 0;
}
The above restricts the interfaces so that you have to use one of your
QueryInterfacex() methods and allows movement back and forth via those
methods. The only thing that IBase does for you is makes both the
QueryInterface() methods available from the Network object. I don't know
if that is what you were after, but I hope it helps some anyway.
joe