如何動態創建相關類型？

Question

如何動態確定與另一個類相關的類的類型？

我已經找到了解決方案，唯一的問題是我最終不得不使用必須在所有派生類中使用的定義。

有沒有更簡單的方法可以做到這一點，而無需為所添加的類進行任何維護？

注意事項：該類和相關類都將始終具有各自的基類，不同的類可以共享一個相關類，並且在示例中，我希望控件類擁有視圖。

這就是我現在所擁有的。 我唯一需要維護的是開關，但是我想擁有它，因此只需要添加回溯和更改它的代碼即可。

#include <iostream>
#include <string>

class model 
{
public:
  model( int id ) : id(id) {}

  int id;
};

class view 
{
public:
  view( model *m ) {}

  virtual std::string display() 
  {
     return "view";
  }
};

class otherView : public view 
{
public:
  otherView( model *m ) : view(m) {}

  std::string display() 
  {
     return "otherView";
  }
};


class control 
{
public:
  control( model *m ) : m_(m), v_( createRelated() ) {}

  ~control() 
  { 
     delete v_; 
  }
  std::string display() 
  {
     if ( v_ )
        return v_->display();
     return "No view";
  }

  view *createRelated() 
  {
     switch( m_->id )  
     {
     case 0:
       return new view( m_ );
     case 1:
       return new otherView( m_ );
     default:
       return NULL;
     }
  }

  model *m_;
  view  *v_;
};

int main( void ) {
  model m(0);
  model om(1);
  model nm(2);

  control c1( &m );
  control c2( &om );
  control c3( &nm );

  std::cout << c1.display() << std::endl;
  std::cout << c2.display() << std::endl;
  std::cout << c3.display() << std::endl;
}

Answer 1

一個可能的解決方案是更改模型以接受指向創建相關類的函數的指針，而不是傳遞“ id”：

typedef view* (*make_function)(model*);

class model
{
public:
    model(make_function a_make) : make_(a_make) {}
    view* make() const { return make_(this); }
...
private:
    make_function make_;
};

每個view類都提供一個靜態方法來創建其自身的實例：

class view
{
public:
    static view* make(model* m) {  return new view(m); }
};

class otherView: public view
{
public:
    static view* make(model* m) {  return new otherView(m); }
};

然后，“ createRelated（）”將變為：

view* control::createRelated()
{
    return m_->make();
}

使用示例：

model m1(&view::make);
model m2(&otherView::make);

希望能有所幫助。

Answer 2

您基本上是在尋找一種稱為Virtual Constructor的技術。

Answer 3

您是否正在尋找工廠設計模式 ？

Answer 4

您可能需要一些虛擬功能。 即使您傳遞了從A類型派生的B類型對象：

void f(A &objA) {
  objA.f();
}

int main() {
  B objB;
  f(objB);
  return 0;
}

如果將A :: f（）定義為虛擬的，則將調用B :: f（）。 因此，您無需知道objA是objB。