Question

How do I determine the type of a class that is related to another class at runtime?

I have figured out a solution, the only problem is that I ended up having to use a define that has to be used in all of the derived classes.

Is there a simpler way to do this that doesn’t need the define or a copy paste?

Things to note: both the class and the related class will always have their respective base class, the different classes can share a related class, and as in the example I would like the control class to own the view.

#include <iostream>
#include <string>

class model;

class view {
public:
  view( model *m ) {}
  virtual std::string display() {
    return "view";
  }
};

#define RELATED_CLASS(RELATED)\
typedef RELATED relatedType;\
virtual relatedType*createRelated(){\
return new relatedType(this);}

class model {
public:
  RELATED_CLASS(view)
  model() {}
};

class otherView : public view {
public:
  otherView( model *m ) : view(m) {}
  std::string display() {
    return "otherView";
  }
};

class otherModel : public model {
public:
  RELATED_CLASS(otherView)
  otherModel() {}
};

class control {
public:
  control( model *m ) : m_(m),
      v_( m->createRelated() ) {}
  ~control() { delete v_; }
  std::string display() {
    return v_->display();
  }
  model *m_;
  view  *v_;
};

int main( void ) {
  model m;
  otherModel om;

  model *pm = &om;

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

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

Answer 1

You could use templates instead to avoid #defines, but, either way, note that you’re essentially overloading on return type with otherModel’s createRelated method.

There’s probably a better way to do what you’re trying to do.

#include <iostream>
#include <string>

class model;

class view {
public:
  view( model *m ) {}
  virtual std::string display() {
    return "view";
  }
};

class model {
public:
  virtual view* createRelated() {  return new view (this); }
  model() {}
};


template <class Related>
class relatedModel : public model
{
  public:
    relatedModel() : model() {}
    virtual view* createRelated() { return new Related(this);}
} ;


class otherView : public view {
public:
  otherView( model *m ) : view(m) {}
  std::string display() {
    return "otherView";
  }
};

class control {
public:
  control( model *m ) : m_(m),
      v_( m->createRelated() ) {}
  ~control() { delete v_; }
  std::string display() {
    return v_->display();
  }
  model *m_;
  view  *v_;
};

int main( void ) {
  relatedModel<view> m;
  relatedModel<otherView> om;

  model *pm = &om;

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

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