C / C++ / MFC

class DummyBase { virtual ~DummyBase() {} };

template <'class abc'>
class Base{
public:
      abc func1();
};

class B : public Base`<datatype1`>, DummyBase{
   virtual ~B() {}
      // Class Definitions
};
class C : public Base`<datatype2`>, DummyBase{
   virtual ~C() {}
      // Class Definitions
};

class A: public Base`<datatype3`>, DummyBase{
public:
      B obj1;
      C obj2;
      DummyBase* search(int condition)  //What do I specify return type???
      {
            if(condition==1)
                  return &obj1;
            if(condition==2)
                  return &obj2;
            if(condition==3)
                  return this;
      }
};

void main()
{
      DummyBase *ptr;
      A objA;
      int n;
      cin>>n;
      ptr = objA.search(n);
      if (B* bPtr = dynamic_cast<B*>(ptr))
      { bPtr->func1(); }
      if (C* bPtr = dynamic_cast<C*>(ptr))
      { bPtr->func1(); }
}

Stuart Dootson wrote:

Yeah, it sucks because you're taking so many decisions.

Stuart Dootson wrote:

But I've not really put sufficient thought into it to think of a better one.

Stuart Dootson wrote:

Possibly something like Boost.Variant or Boost.Any might make things nicer.

#include <iostream>
#include <boost/variant.hpp>

template <class abc>
class Base{
public:
   abc func1();
};

class B : public Base<int>{
public:
   virtual ~B() {}
      // Class Definitions
};
class C : public Base<float>{
public:
   virtual ~C() {}
      // Class Definitions
};

class A: public Base<char>{
public:
   B obj1;
   C obj2;
   boost::variant<A*, B*, C*> search(int condition)  //What do I specify return type???
   {
      if(condition==1)
         return &obj1;
      if(condition==2)
         return &obj2;
      if(condition==3)
         return this;
   }
};

int main(int, char**)
{
   A objA;
   int n;
   std::cin>>n;
   boost::variant<A*, B*, C*> v = objA.search(n);
   if (B* b = boost::get<B*>(v))
   {
      b->func1();
   }
   else if (C* c = boost::get<C*>(v))
   {
      c->func1();
   }
   return 0;
}

NeoAks007 wrote:

Is there no way to reduce coding at caller side??

Stuart Dootson wrote:

If you want to handle them n the same way, then why not make them the same?

CString m_s = _T("1949");
int i = _tstoi(m_s);

CBitmap bitmap;
bitmap.LoadBitmap(IDB_WHATEVER);
CDC MemDC;
MemDC.CreateCompatibleDC(&dc_of_view);
CBitmap *originalBitmap = MemDC.SelectObject(&bitmap);
BITMAP bitmapInfo;
bitmap.GetBitmap(&bitmapInfo);
CRect Rect;
GetClientRect(&Rect)
dc.BitBlt(Rect.CenterPoint().x - bitmapInfo.bmWidth / 2, 
          Rect.CenterPoint().y - bitmapInfo.bmHeight / 2, 
          bitmapInfo.bmWidth, 
          bitmapInfo.bmHeight, 
          &MemDC, 
          0, 
          0, 
          SRCCOPY);
MemDC.SelectObject(originalBitmap);

AfxGetMainWnd()->SendMessage(WM_DISP, 0, (LPARAM)recv_data);