2011-11-22 88 views
0

如何确定与其他类动态相关的类的类型?如何动态创建相关类型?

我已经想出了一个解决方案,唯一的问题是我最终不得不使用必须在所有派生类中使用的定义。

有没有更简单的方法来做到这一点,不需要保养永远增加的类?

注意事项:类和相关类将始终具有其各自的基类,不同的类可以共享相关的类,并且如示例中我希望控件类拥有该视图。

这就是我现在拥有的。我唯一需要维护的就是交换机,但是我想拥有它,所以我只需要添加代码就可以返回并更改它。

#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; 
} 

回答

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); 

希望有帮助。

0

您可能需要一些虚拟功能。即使通过从类型A衍生B型的一个目的:

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

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

如果A :: f()是定义为虚拟的,则B :: F()将被调用。所以你不需要知道objA是一个objB。