template derivation from another class?

I could use some help with the following concept:
suppose i have a class that contains virtuals

Code:

---


class b {
  public:
        b(int n) : _num(n) {};
        virutal int do() = 0;
  private:
  int _num;
};


tempate <class  c >
class a {

      a ( int r)  {
            c_ = new c(r);
            c_.do();
      }
}

class d: class b {
        public:
            d(int n): b(n)  { } ;
}


//usage example
main () {
    a<d>    var( 5 ) ;
}

---

I would like to enforce that the template class c type be inherited from b... How can this be done using templates ?

thanks
Ken

If so, then why make a a class template? You might as well use runtime polymorphism by using a pointer/reference to b.

Quote:

---

Originally Posted by bean66

I would like to enforce that the template class c type be inherited from b... How can this be done using templates ?

---

I agree with Laserlight... But you could take advantage of type slicing to ensure that c derives from b. If you assign (by value) a "c" to a "b" it will result in a compiler error if "c" is not a subclass of "b".

I did that originally using runtime polymorphism. But since i create and store an array of elements of type "b" in class "a" it required a friend function/helper and an initializer template to create the class "d" derived types that are stored in "a".

So my thought was just to provide the class as a template parameter. That way the constructor for class "a" could construct the class "c" items...

I hope that makes sense...

Quote:

---

Originally Posted by brewbuck

I agree with Laserlight... But you could take advantage of type slicing to ensure that c derives from b. If you assign (by value) a "c" to a "b" it will result in a compiler error if "c" is not a subclass of "b".

---

so something like this:

Code:

---

template <class c>
  class a {
    public:
            a(int num) {
                  _b = new c(num);
            }
    private:
      class  b  *_b;
  };

---

I suppose that you want to derive "c" from "b" only to impose an implementation of the function "do". If so, then the new standard will probably offer you the concept of a "concept", with which you can impose functionality of template parameters.

Code:

---

concept B {
  int do_();
};

tempate <B c>
class A {
..
};

---

The subject is extremely interesting, here is an interesting paper on the subject :
http://www.research.att.com/~bs/popl06.pdf

and here is an un-understandable paper, just for completeness :
http://www.open-std.org/Jtc1/sc22/wg...2005/n1886.pdf

The concepts make compiler errors friendlier, but any call to a nonexistent method will cause the compile to fail. I suppose one way of creating a better message (with pre c++0x compilers) could be to create a method in b with a name that implies an error:

Code:

---

class b
{
    public:
    b(int n) ...
    virtual int do_() = 0;
    void template_param_not_derived_from_b_error() { }
};

template <class c>
class a
{
    public:
          a(int n) {
                b_ = new c(n);
                b_->template_param_not_derived_from_b_error();
                b_->do_();
          }
    .....
};

---

I assume that this is the main goal...