Is there any keyword to redefine "all" methods of templated base class in a templated derived class?

Question

I know this looks like a silly question, but using object oriented stuff with templates in C++ is really troublesome. For example, Foo is the base class:

template <typename T>
class Foo {
  public:
    virtual void Method1() { }
    virtual void Method1(int a) { }
    virtual void Method2() { }
    virtual void Method2(int a) { }
    //... lots of other methods
};

Is there something like:

template <typename T>
class Bar : public Foo<T> {
  public:
    using Foo<T>::*; //redefine all inherited methods from Foo
    virtual void Method1(int a) { }
    virtual void Method2(int a) { }
    //other methods overloading..
};

Instead of:

template <typename T>
class Bar : public Foo<T> {
  public:
    using Foo<T>::Method1
    using Foo<T>::Method2
    //... lots of other methods

    virtual void Method1(int a) { }
    virtual void Method2(int a) { }
    //other methods overloading..
};

So we can do:

int main() {
  Bar<int> b;
  b.Method1();
  b.Method2();
  //... lots of other methods

  //This obviously works without the 'using' keyword:
  Foo<int>* f = &b;
  f->Method1();
  f->Method2();
  //etc
  return 0;
}

Answer 1

No, there is no functionality like that but it usually isn't needed. What you intend to do with using is already provided by the basic inheritance mechanism.

You need to use using if overloads in the deriving class hide methods from the base class or if you want to change the access mode, but not in general:

class A {
    void f() {}
public:
    void g(int) {}
    void h(int) {}
};

struct B : A {
    using A::f; // make f public
    void g(double) {}
    using A::g; // otherwise A::g is hidden by the overload
    // using A::h isn't needed
};

Note that you can still call A::h() through a B instance because nothing hides it.

Answer 2

No. Template specializations are separate types that do not inherit from or otherwise relate to the general template. It's up to you to make sure they have the same implicit interface, and C++ does not make this particularly easy.

See also this recent question, which could very well be what you're looking for. http://stackoverflow.com/questions/2263856/subclass-as-specialization-ie-adding-a-method-in-the-specialization

Answer 3

1. What Hiding is

I am afraid there is something wrong with your little example, and I suspect that your problems lies in Hiding.

Let's illustrate what Hiding is first:

struct Base { void foo(int) { std::cout << "Base" << std::endl; } };

struct Derived: Base { void foo(float) { std::cout << "Derived" << std::endl; } };

int main(int, char* argv[])
{
  Derived d;
  int integer = 1;
  float floating = 2;
  d.foo(floating);     // outputs "Derived" as expected
  d.foo(integer);      // outputs "Derived" too UhOh ?
}

The problem is referred to as Hiding, it's an issue with name resolution at compilation time. The issue is that before applying the overloading rules to select the "right" method, the compiler needs first to compile the set of methods to consider. To do so it's going to look at the most specialized scope, and then spread outwards one scope at a time until it finds the name it's looking for. Unfortunately (for efficiency reasons I guess), it stops as soon as it has found functions with the name.

So what happens here is:

1. Look for methods named foo in Derived: { void Derived::foo(float) }

And stop... therefore when trying to resolve foo for an int argument, it selects the only method it has seen so far, which might be a bit surprising.

You are correct that you can trump this with the using keyword, which brings names from another scope so that the compiler consider them. If I add using Base::foo; in Derived definition, the compiler will do:

1. Look for methods named foo in Derived: { void Derived::foo(float) } + using
2. Add methods named foo in Base: { void Derived::foo(float), void Base::foo(int) }

And therefore you obtain what you wished.

2. How to redefine a method

Now that you know what Hiding is, and how to circumvent it, I'd like to take the opportunity to address your example flaws.

You should not redefine the methods like this:

struct Base { void foo(int) const { std::cout << "Base" << std::endl; } };
struct Derived: Base { void foo(int) const { std::cout << "Derived" << std::endl; } };

The problem here is that it's merely Hiding and that can be surprising.

void fooize(const Base& b) { b.foo(); }

int main(int argc, char* argv[])
{
  Derived d;
  d.foo();          // output "Derived"
  fooize(d);        // output "Base"
}

If you wish to redefine you need the virtual keyword. And then you'll correct your classes this way:

struct Base
{
  virtual ~Base() {}       // Polymorphism means virtual destructor
  virtual foo(int) const { std::cout << "Base" << std::endl; }
};

struct Derived: Base
{
  virtual ~Derived() {}    // Not necessary, but sweet reminder
  virtual foo(int) const;  // virtual not necessary, but a sweet reminder again :)
};

And then it will work as expected.

3. Polymorphism cook book

• You should not redefine a method that is not virtual
• Polymorphism thus means virtual Destructor (because it will be redefined anyway)
• Inheritance introduces Polymorphism, use Composition if you don't want it

It is unfortunate (for Composition) that there is no "delegation" concept in C++, but we have to deal with the cards we've been given.

A final note: if the class has a lot of methods... it may be it could benefit from a redesign (see std::string for an example of what not to do).