C++, используя шаблон функции в шаблоне класса

Question

template <int C> class MyClass; 

...  


template <int C> 
double trans(MyClass<C> &a) 
{ 
    //return some double 
} 

//this is supposed to be function template 
template <int C> 
double func(MyClass<2> &a) 
{ 
    //return some double 
} 

template <int C> 
MyClass<C-1> func(MyClass<C> &a) 
{ 
    MyClass<C-1> ret; 
    return ret; 
} 

template <int C> 
double otherFunc(MyClass<C> &a) 
{ 
    double result; 
    if(C == SOME_CONSTANT) 
     result = func(a); 
    else 
     result = trans(func(a)); 

} 

Что моя проблема, я хочу, чтобы проверить аргумент шаблона C в параметре otherFunc шаблона функции вызова func (вернуться дважды) вместо функции члена шаблона класса func (возврат MyClass). Но почему-то компилятор попытки func, который возвращает MyClass в

 if(C == SOME_CONSTANT) 
     result = func(a); 

эту часть, так что я получил ошибку компиляции (потому что двойной = MyClass не является жизнеспособным). Как мне исправить эту проблему?

Answer 1

Трудно уточнить в комментарии, поэтому я отправлю ответ. Напомним, что я сказал в комментариях:

• вы не можете иметь в otherFunc в if/else, что не будет законно собрать для конкретного экземпляра MyClass,
• вы может использовать такой же подход специализации шаблона для создания альтернативы otherFunc определение для обработки MyClass<2> s.

Пример кода:

#include <iostream> 

template <int C> 
class MyClass 
{ }; 

template <int C> 
double trans(const MyClass<C> &a) 
{ 
    return C + 700; 
} 

template <int C> 
MyClass<C-1> func(MyClass<C> &a) 
{ 
    MyClass<C-1> ret; 
    return ret; 
} 


double func(MyClass<2>& a) 
{ 
    return 200.0; 
} 

template <int C> 
double otherFunc(MyClass<C> &a) 
{ 
    return trans(func<C>(a)); 
} 

template <> 
double otherFunc<2>(MyClass<2>& a) 
{ 
    return func(a); 
} 


int main() 
{ 
    MyClass<2> a; 
    std::cout << otherFunc(a) << '\n'; 

    MyClass<4> b; 
    std::cout << otherFunc(b) << '\n'; 
} 

Выход:

200 
703 

Answer 2

Я думаю, причина в том, что:

if(C == SOME_CONSTANT) 
    result = func(a); 
else 
    result = trans(func(a)); 

проверяется во время выполнения, в то время как шаблон специализаций и проверка типов производится во время компиляции. Эти 2 функций:

template <int C> 
double func(MyClass<2> &a) 
{ 
    //return some double 
} 

template <int C> 
MyClass<C-1> func(MyClass<C> &a) 
{ 
    MyClass<C-1> ret; 
    return ret; 
} 

имеют почти те же подписи - единственное отличие состоит в том, что для C==2 используется один возвращающийся double, в противном случае используется один возвращающийся MyClass<2>. Так что вы получаете:

// for C==2 
if(C == SOME_CONSTANT) 
    result = func<2>(a); // returns double - just like you wanted 
else 
    result = trans<2>(func<2>(a)); // pass double into trans<?>(MyClass<?>), so the parameter cannot be resolved unless you specified some implicit constructor/explicit conversion operator 

// for e.g. C==3 
if(C == SOME_CONSTANT) 
    result = func<3>(a); // returns MyClass<2> while result is double 
else 
    result = trans<2>(func<3>(a)); // pass MyClass<2> into trans<?>(MyClass<>) - like you wanted 

поэтому в основном ваш код имеет неверный тип для специализации в первом или втором случае. Вы можете сделать что-то вроде этого, вместо:

template <> 
MyClass<2> func<2>(MyClass<2> &a) 
{ 
    return a; 
} 

template <int C> 
MyClass<C-1> func(MyClass<C> &a) 
{ 
    return MyClass<C-1>; 
} 

держать тип шаблонов последовательно, а затем:

if(C == SOME_CONSTANT) 
    result = trans(a); 
else 
    result = trans(func(a)); 

Это просто пример того, как справиться с этим. Все должно быть проще, если вы избегаете возиться с другим возвратом, напечатанным для разных специализированных шаблонов.