Thread: CreateInstance

Hello everyone,


In the book "Inside COM", there is an interesting code segment like this,

Code:

IUnknown* CreateInstance()
{
    IUnknown* pI = static_cast <IX*> (new CA);
    pI -> AddRef();
    return pI;
}

// IX an interface is derived from IUnkown, IY is an interface derived from
// IUnknown and CA is a class directly derived from both IX and IY.

My question is, why static_cast <IX*> to result in IUnknown*? Why not static_cast <IUnknown*> to result in IUnknown* to be more straightforward (even if I think using IX* and IUnknown* have the same effect)? Are there any reasons or advantages if we use IX* other than IUnknown*?


thanks in advance,
George

Thanks CornedBee,


I have written some code to reproduce this issue -- error C2594: 'initializing' : ambiguous conversions from 'Final *' to 'Base *'.

But I am confused why there is ambiguity issue. In my knowledge, class instance is different by the data members, but common (share) in executable code.

In my sample, IUnknown, IX and IY are all classes which do not have data members, they should share the common executable code. Could you explain in more details why compiler complaint ambiguity issue and what blocks compiler from type conversion?

Code:

#include <iostream>

using namespace std;

class Base {
public:
	int foo() {cout << "Base" << endl;}
};

class Derived1: public Base
{
public:
	int foo() {cout << "Derived1" << endl;}
};

class Derived2: public Base
{
public:
	int foo() {cout << "Derived2" << endl;}
};

class Final: public Derived1, public Derived2 {
public:
	int foo() {cout << "Final" << endl;}
};

int main()
{
	Final f;
	Final* p = &f;
	Base* pb = p; //error C2594: 'initializing' : ambiguous conversions from 'Final *' to 'Base *'
	return 0;
}

Originally Posted by CornedBee

Just how many different topics at once do you tackle? Perhaps you would be able to properly understand what you're reading if you only read one topic at a time.

You could also simply try what happens when you cast directly to IUnknown. Keep in mind that downcasts implicit and thus the static_cast would not be necessary at all.

regards,
George

Thanks Mario,

Originally Posted by Mario F.

See the Diamond of Death for an explanation of this problem.

I have read through that before. So, Diamond pattern could also apply even if there are no data members?


regards,
George

Thanks Mats,


My question is answered.

Originally Posted by matsp

Sure, it's got nothing to do with data members, only with inherited behaviour.

--
Mats

regards,
George

Thanks CornedBee,


My question is answered.

Originally Posted by CornedBee

Basically, there's two paths to reach two IUnkowns, so the compiler doesn't know which one to take unless you help it along.

regards,
George