从基类模板虚拟方法而不是使用重载

Question

I got strange code and have to extend it. But instead of copy paste many many times i decided to create a template. But get caught by a terrible rock.

Here is an example code:

template<typename T>
class anyClass {};

template<typename T>
class Outer : public anyClass<T>
{
public:
   using value_t = T;
   class Inner
   {
      virtual void foo(value_t);
   };
};

class specializer : protected Outer::Inner
{
   virtual void foo(int) override {}
}

I have to extend virtual void foo(value_t) in specializer.

Example:

class specializer : protected Outer::Inner
{
   virtual void foo(int) override {}
   virtual void foo(float) override {}
   virtual void foo(string) override {}
   virtual void foo(bar) override {}
   // And so on...
 }

Question 1: Why works the example, although class specializer : protected Outer::Inner miss a param?

All overloadings do nearly the same. I created already the function.

template<typename anyType>
void meow( anyType )
{
/***/
}

My problem is here:

virtual void foo(anytype value) //<< replace anytype with what?
{
   meow<anytype>( value );
}

I need the type Outer::value_T but i don't know how to get it.

Question 2: How can i use meow by calling foo ?

Feel free to ask for more information.

UPDATE

I looked again in the origin code and realised, that i've overlooked an important using/typedef. The working code looks like:

class specializer : protected Outer<int, float, string, bar>::Inner //Yes a variadic-template
{
   virtual void foo(int) override {}
   virtual void foo(float) override {}
   virtual void foo(string) override {}
   virtual void foo(bar) override {}
   // And so on...
 }

So Question 1 is solved .

Answer 1

Why works the example, although class specializer : protected Outer::Inner miss a param?

The example does not work . It does not work because Outer is not a type. Also, you override multiple overloads of foo even though inner has only one foo . There are several syntax errors too. If it appears to work, then the compiler is doing something non-standard.

About your second question:

virtual void foo(anytype value) //<< replace anytype with what?

You replace it with the type whose overload you intend to override. For example, if you intend to override foo(int) , then replace anytype with int .

Question 2: How can i use meow by calling foo ?

Simply call meow in foo .

Answer 2

You would have to make specializer a template class.

#include <iostream>

template<typename T> void meow(T x) 
{
    std::cout << x << std::endl;
}

template<typename T>
class anyClass {};

template<typename T>
class Outer : public anyClass<T>
{
public:
   using value_t = T;
   class Inner
   {
      virtual void foo(Outer<T>::value_t);
   };
};

template<typename T>
class specializer : protected Outer<T>::Inner
{
   virtual void foo(T x) override 
   {
       meow(x);
   }
};

I wonder how this would help you to change the behavior in Outer or anyClass because you have not shown code which shows where and how Inner is actually used. Without that, it's just guessing.

I have the feeling that what you are actually trying to achieve is to pass a function (or Strategy?) to you Outer class, represented by Inner in your code. That would be better done by passing it as a template argument.

template<typename T>
class anyClass {};

template<typename T, typename Inner = meow<T>>
class Outer : public anyClass<T>
{
public:
   using value_t = T;

   // somewhere in your code
   Inner i;
   i.meow( any_value );
};

You can also pass a std::function to the constructor. template class anyClass {};

template<typename T>
class Outer : public anyClass<T>
{
public:
   using value_t = T;

   Outer( std::function<void (value_t)> inner);

   // somewhere in your code
   i.meow( any_value );

   std::function<void (value_t)> i;
};

Answer 3

Originally I simplyfied a little bit to much. Here is the compileable example of my problem: http://ideone.com/9U7J1a I removed all unconducive code. I know the design is horrible but i have no influence on it.

class bar {};
class string {};

template<typename _T>
class ModelContainer 
{
    public:
    using value_type = _T;

   class Delegate {
     public:
       virtual void foo( value_type value);
   }; 
};

template< typename... _Ts >
class ModelManager__AbstractBase : protected ModelContainer< _Ts >...
{
public:
  class Delegate : public ModelContainer< _Ts >::Delegate... {
  public:
    virtual ~Delegate( ) = default;
  };
};


using ModelManager__Base = ModelManager__AbstractBase<
    int,
    float,
    string,
    bar
>;

class ModelManager : public ModelManager__Base {
    /* Some functions */
};

class spezializer : ModelManager::Delegate
{
    public:
    virtual ~spezializer() = default;
        //Uncommend to see my error  
       // virtual void foo( value_type value) override // << value_type unknown
       // {/* Calling everytime the same method, no matter which value_type*/}
};