Bypass implicit operator conversion

**Sujit15** · 14-05-2009

I have a class "A":

Code:

  class A 
  {
  public: 
     A (B* pB): m_pB (pB) () 
     Operator B* () 
     { 
         m_pB return; 
     }
  private: 
     B* m_pB; 
  }

Which class "C" derives:

Code:

  class C: public A 
  { 
  }

My problem is that I can not implicitly convert C to B:

Code:

  C* pC = [...]; 
  A* pA = pC; // Works 
  B* pB = pA; // works (using the implicit conversion) 

  // But 
  C* pC = [...]; 
  B* pB = pC; // Error: Can not convert (error C2440)

Is this normal?

Code:

  C* pC = [...]; 
  B* pB = pC-> GetB ();

**opaper** · 14-05-2009

Code:

  C* pC = [...]; 
  A* pA = pC; // Works 
  B* pB = pA // Do not work 
  B* pB = *pA; // Should work 

  // But 
  C* pC = [...]; 
  B* pB = *pC;  // Should work

**XSI** · 14-05-2009

What you have done is not the best programming. If you really want to keep your conversion of an A to B*, I advise you to do so explicitly like this:

Code:

B *pb = static_cast<B*> (*pc) ;

**opaper** · 14-05-2009

Apart from inheriting from B, no it is impossible to overload operators on simple pointers.

Otherwise, you can create your pointer class, in which case you can override it for one operator to have a B*.