Thread: virtual functions and templates

Code:

template<typename T>
T* clone(const T& t) {
  return new T(t);
}

//...

class Base {  //this is an abstract base class
  virtual Base* new_object() const =0;
}
class Derived : public Base {
  virtual Base* new_object() const;
}
class Derived2 : public Derived {
  virtual Base* new_object() const;
}
Base* Derived::new_object() const {
  return clone(*this);
}

Both Derived class new_object functions call clone. (They look exactly the same.)
I've got 3 questions
1) If I did not repeat the definition or the declaration for Derived2, it would call Derived's function. *this would be a const Derived&, not a const Derived2& which I want. Is this correct?
2) What if I just declared a virtual function in the header file for Derived2, but left the definition to Derived?
3) What if I declared new_object in Base? (Of course, I would take away the '=0' part of it).

Basically, I'm looking to see if there's a way to let the right typename be chosen so that clone() doesn't slice the object.

Hmm, it seems like you'd really rather do this; it makes more sense anyhow to have a covariant return:

Code:

class Base {  //this is an abstract base class
  virtual Base* new_object() const =0;
}
class Derived : public Base {
  virtual Derived* new_object() const;
}
class Derived2 : public Derived {
  virtual Derived2* new_object() const;
}
Derived* Derived::new_object() const {
  return clone(*this);
}

And you will have to explicity create each class's new_object(), because, as you said, Derived's is not adequate for Derived2's needs.

Originally posted by Cat
Hmm, it seems like you'd really rather do this; it makes more sense anyhow to have a covariant return:

Code:

class Base {  //this is an abstract base class
  virtual Base* new_object() const =0;
}
class Derived : public Base {
  virtual Derived* new_object() const;
}
class Derived2 : public Derived {
  virtual Derived2* new_object() const;
}
Derived* Derived::new_object() const {
  return clone(*this);
}

And you will have to explicity create each class's new_object(), because, as you said, Derived's is not adequate for Derived2's needs.

The problem with that way is that in non-overloaded classes, the return types must be the same.

So, if a function is Derived's, and it is called from a Derived2 object, *this would be Derived&?

The problem with that way is that in non-overloaded classes, the return types must be the same.

Not sure what you mean... this is legal C++ BTW:

Code:

class B{
public:
  virtual B* F();
};

class D : public B{
public:
  D* F();
};

And they're polymorphic just as you'd expect:

B theObj = new D();
theObj->F(); // calls D::F() not B::F()

So, if a function is Derived's, and it is called from a Derived2 object, *this would be Derived&?

Yes. That is why you need to implement this factory function in every class.

Cat is totally corrent.....lookup "covariant return" - it's a relaxation on the return type as long as there's an inheritance between the returned types....Stroustrup discusses it breifly in The C++ Programming Language

Huh... didn't know that. Why was it implemented that way?