Полиморфизм времени компиляции C++

Похоже, вы используете перечисление для передачи информации о типе от пользователя. Я бы посоветовал вам не делать этого.

В самом простом случае, если f1 и f2 переименовать в f, то можно вообще удалить if и просто вызвать его. Компилятор вызовет для вас соответствующую перегрузку.

Если вы не можете или не хотите переименовывать шаблоны функций, вы можете написать вспомогательный шаблон, который будет выполнять отправку за вас (шаблон базового класса не определен, специализации для A и B отправляются в соответствующую статическую функцию)

Если перечисление используется для чего-то другого (которое компилятор не может разрешить за вас), вы все равно можете передать его и переписать помощник для отправки перечисления, а не типа аргумента, и вам придется переписать код, чтобы иметь значение перечисления как константа времени компиляции (самый простой: передать его как аргумент шаблона в algo). В этом случае вы можете написать специализации функций вместо классов, если хотите, так как они будут полными специализациями. Но учтите, что если вы сможете избежать его передачи, вы устраните целое семейство ошибок: передачу неправильного значения перечисления.

// Remove the enum and rename the functions to be overloads:
//
struct C {  // If everything is static, you might want to consider using a
            // namespace rather than a class to bind the functions together...
            // it will make life easier

   template <typename T>
   static void f( A<T> & ) { /* implement A version */ }

   template <typename T>
   static void f( B<T> & ) { /* implement B version */ }

   template <typename T> // This T is either A<U> or B<U> for a given type U
   static void algo( T & arg ) {
      // common code
      f( arg ); // compiler will pick up the appropriate template from above
   } 
};

Для других альтернатив проще, если охватывающая область является пространством имен, но идея будет той же (только, возможно, потребуется немного сложнее бороться с синтаксисом:

template <typename T>
struct dispatcher;

template <typename T>
struct dispatcher< A<T> > {
   static void f( A<T>& arg ) {
      C::f1( arg );
   }
};
template <typename T>
struct dispatcher< B<T> > {
   static void f( B<T>& arg ) {
      C::f2( arg );
   }
};

template <typename T>
void C::algo( T & arg ) {
   // common code
   dispatcher<T>::f( arg );
}

Опять же, заставить это работать с классом может быть немного сложнее, поскольку для этого, вероятно, потребуется пара предварительных объявлений, и у меня нет под рукой компилятора, но набросок должен привести вас в правильном направлении.

Достаточно обычной перегрузки функций:

template <typename T> 
static void f1 ( A <T> &a) {} 

template <typename T> 
static void f2 ( B <T> &b) {} 

template <typename T> 
static void algo (A<T>& u) {
    f1(u);
} 

template <typename T> 
static void algo (B<T>& u) {
    f2(u);
} 

А потом:

A<int> a;
Foo::algo(a);

Хотя непонятно, что вы выиграете от такой договоренности.

Если вам действительно нужно сделать это в одной функции, вы можете использовать typetraits:

 template<typename T, T Val>
 struct value_type { static const T Value = Val; };

 struct true_type   : public value_type<bool, true>{};
 struct false_type  : public value_type<bool, false>{};


 template<class T>
 struct isClassA : public false_type{};

 template<>
 struct isClassA<A> : public true_type{};


 template < typename T >
 void Algo( T& rcT )
 {
    if ( true == isClassA<T>::Value )
    {
        // Class A algorithm
    }
    else
    {
        // Other algorithm
    }
 };

значение параметра m неизвестно до времени выполнения, поэтому компилятор должен генерировать код для ветвей if (m == ma) и else при специализации функции. Затем он жалуется, так как не может понять, что ему делать, если вы позвоните C::algo(a,mb) или тому подобное.

Как предложил Джон, перегрузка должна исправить ваш случай, попробуйте использовать этот код:

template<typename U>
static void f12(A<U>&u) { f1(u); }

template<typename U>
static void f12(B<U>&u) { f2(u); }

template<typename U>
static void algo(U& u, M m)
{
    /* long algorithm here
      ...
    */
    //use overloading to switch over U type instead of M value
    f12(u);
}

Также вы можете использовать указатели функций с функциями шаблона, если вы укажете параметры шаблона:

template<typename U>
static void algo(U& u, M m, void(*)(U&) func)
{
    /* ... */
    (*func)(u);
}

int main()
{
    A <double> a;
    C::algo (a, ma, &C::f1<double> );
}