Thread: Design problem

Code:

Term::Term(const Term& t) {
  std::vector<Factor*> x = t.factors;
  if (x.empty()) return;
  Factor* f;
  for (std::vector<Factor*>::iterator i = x.begin();i != x.end();++i) {
    if ((*i)->who_am_i() == Factor::FLOATING) {
      f = new Float(*((Float*)(*i)));
      factors.push_back(f);
    }
    if ((*i)->who_am_i() == Factor::FACTOR_EXPRESSION) {
      f = new Factor_Expression(*((Factor_Expression*)*i));
      factors.push_back(f);
    }
    if ((*i)->who_am_i() == Factor::FUNCTION) {
      f = new Function(*((Function*)*i));
      factors.push_back(f);
    }
    if ((*i)->who_am_i() == Factor::VARIABLE) {
      f = new Variable(*((Variable*)*i));
      factors.push_back(f);
    }
  }
}

Four classes (Variable, Function, Factor_Expression, and Float) derive from the class Factor.

The goal of this constructor is to create new objects as you can see and put them into a vector array. I'm sure there's a simpler way to do this, something more OOP friendly, but I can't think of it.

Do you know and understand object factories?

No... I haven't heard the term before.

The purpose of this function is to create a new object for each object pointer in the vector array 'factors'.

I think there should be a way to simplify this. Right now, the function checks each pointer to determine its object type, then creates a new appropriate object, and puts it into the vector array 'factors'.

So my question is, is there a way to let the object itself decide the new type of object to be produced?

I'm thinking of something like this:

Code:

Factor* Variable::new_object() {
  return new Factor(*this);
}

And doing it for each class. But I'm not sure if that's the right way to do it.

//edit: thanks, sang, i'll look into it