Question

I have a model view architecture. I want to create a view object from a model object.
Here is a basic example.

How do i specify the type of my model objects: enums (but then they are not extendable), ints (but then easy to get messed up) …

class ModelA
{
    ModelA(int a);
}

class ModelB : public ModelA
{
    ModelB(int a,int b);
}

class ViewModelA
{
    ViewModelA(ModelA* ma);
}

class ViewModelB : public ViewModelA
{
    ViewModelB(ModelB* mb);
}

class ViewFactory
{
     ModelA * createFromModel(ModelA *ma)
     {
          // Now what is the best way to store type ???
          // Used an integer and overload a static method getType()
          // Or use an enum?
          switch(ma.type)
          {

          }
     }
}


int main(int argc, char *argv[])
{
    ModelA *ma = new ModelA(10);
    ModelA *mb = new ModelB(10,11); 
    ViewFactory myFactory;
    ViewModelA *va = myFactory.createFromModel(ma);
    ViewModelB *vb = myFactory.createFromModel(mb);
    //va should be a model of ViewModelA and vb a model of ViewModelB
}

Answer 1

IMHO, from your question and comment on other answer, you can also use Visitor pattern here.
Read about it here or here

So, the model hierarchy would be visited by the Visitor.
The responsibility of the Visitor will be to create appropriate View object for the visited Model type.

Then you do not need to store/declare model type.

Working code: Also live here: http://ideone.com/9A5bJ

#include <iostream>



class Visitor{
public:
    virtual ~Visitor(){}
    virtual void visitModelA(class ModelA*) = 0;
    virtual void visitModelB(class ModelB*) = 0;
    //add visit functions for later defined models

};





class View{
public:
    virtual ~View(){}
};

class ViewA : public View{
public:
    ViewA(){
        std::cout << "Created ViewA\n"; 
    }
};


class ViewB : public View{
public:
    ViewB(){
        std::cout << "Created ViewB\n"; 
    }
};








class Model{
public:
    virtual ~Model(){}

    virtual void Accept(Visitor* visitor) = 0;

};

class ModelA:public Model{
public:

    virtual void Accept(Visitor* visitor){
        visitor->visitModelA(this);
    }
};

class ModelB:public Model{
public:
    virtual void Accept(Visitor* visitor){
        visitor->visitModelB(this);
    }
};






// ViewCreator can be made a private class of ViewFactory
class ViewCreator : public Visitor{
public:
    virtual void visitModelA(class ModelA*) {
        _view = new ViewA();
    }
    virtual void visitModelB(class ModelB*) {
        _view = new ViewB();
    }

    //add visit functions for later defined models

    View* GetView(){
        return _view;
    }   

private:
    View* _view;
};


class ViewFactory{
public:
    static View* CreateViewFor( Model* model){
        ViewCreator viewCreator;
        model->Accept(&viewCreator);
        return viewCreator.GetView();
    }

};


int main(){

    ModelA modelA;
    View* viewA = ViewFactory::CreateViewFor(&modelA);


    ModelB modelB;
    View* viewB = ViewFactory::CreateViewFor(&modelB);



}