C / C++ / MFC

George_George wrote:

My question is, why static_cast to result in IUnknown*? Why not static_cast 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*?

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;
	Base* pb = &f; //error C2594: 'initializing' : ambiguous conversions from 'Final *' to 'Base *'
	return 0;
}

Base* pb = (Derived1 *)&f; 

IUnknown* pI = static_cast<iunknown*>(static_cast <ix*> (new CA));
</ix*></iunknown*>

George_George wrote:

We can discuss in the situation of class other than interface.

George_George wrote:

Ambiguity means more than one different values could be selected. The different values in class is data members, not functions.

CPallini wrote:

know that. But, as I suggested before, since C++ syntax has no special syntax to designate interfaces (i.e. abstract classes) then probably the compiler cannot make assumptions on them and remains stuck to the more general case, thus finding (inexisting) ambiguities on the derivation path.

CPallini wrote:

how can the compiler resolve between IX::AddRef or IY::AddRef if it cannot make assumptions on the abstract nature of IX and IY classes?

George_George wrote:

No matter whether they contain data member, right?

George_George wrote:

I do not quite understand your statement above. Could you show some pseudo code please?

class IX: public IUnknown
{
...
virtual ULONG AddRef(){ return ++m_nRef;}
...
};

class IY: public IUnknown
{
...
virtual ULONG AddRef(){ return 1;}
...
};


void main()
{
  IUnknown *pUnk = new CA;

  int n = pUnk->AddRef();
}

George_George wrote:

My question is answered. You are so knowledgeable.

followait wrote:

is there an more efficient way?

Mark Salsbery
Microsoft MVP - Visual C++

IStream *pStm=NULL;
::CreateStreamOnHGlobal(NULL,TRUE,&pStm);
ULARGE_INTEGER ui;
ui.LowPart=lDataSize+1;
ui.HighPart=0;
HRESULT hr=pStm->SetSize(ui);
HGLOBAL hGlobal=NULL;
::GetHGlobalFromStream(pStm,&hGlobal);
BYTE *pBuf=(BYTE*)::GlobalLock(hGlobal);
::SafeArrayAccessData(varBLOB.parray,(void**)&pBuf);
::SafeArrayUnaccessData (varBLOB.parray);
BOOL b=::GlobalUnlock(hGlobal);//b==FALSE (even without <code>SafeArrayAccessData</code> and <code>SafeArrayUnaccessData </code>)
DWORD dw=::GetLastError();//dw==0:confused: