Требуется ли шаблонная специализация шаблона <> синтаксиса?

Question

У меня есть класс посетителя, напоминающее это:

struct Visitor 
{ 
    template <typename T> 
    void operator()(T t) 
    { 
     ... 
    } 

    void operator()(bool b) 
    { 
     ... 
    } 
}; 

Очевидно, что operator()(bool b) предназначен быть конкретизацией предыдущей функции шаблона.

Однако у него нет синтаксиса template<>, который я привык видеть перед ним, объявив это как специализацию шаблона. Но он компилируется.

Безопасно ли это? Это верно?

Answer 1

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

class Visitor 
{ 
public: // corrected as pointed by stefanB, thanks 
    template <typename T> 
    void operator()(T data) { 
     std::cout << "generic template" << std::endl; 
    } 
    void operator()(bool data) { 
     std::cout << "regular member function" << std::endl; 
    } 
}; 
template <> // Corrected: specialization is a new definition, not a declaration, thanks again stefanB 
void Visitor::operator()(int data) { 
    std::cout << "specialization" << std::endl; 
} 
int main() 
{ 
    Visitor v; 
    v(5); // specialization 
    v(true); // regular member function 
    v.operator()<bool>(true); // generic template even if there is a non-templated overload 
    // operator() must be specified there (signature of the method) for the compiler to 
    // detect what part is a template. You cannot use <> right after a variable name 
} 

В вашем код есть не большая разница, но если ваш код должен передать тип параметра шаблона он будет получать смешнее:

template <typename T> 
T g() { 
    return T(); 
} 
template <> 
int g() { 
    return 0; 
} 
int g() { 
    return 1; 
} 
int main() 
{ 
    g<double>(); // return 0.0 
    g<int>(); // return 0 
    g(); // return 1 -- non-templated functions take precedence over templated ones 
} 

Answer 2

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

Это безопасно и на самом деле вероятно, что вы хотите. Шаблон посетителя обычно реализуется путем перегрузки. Специализированные шаблоны функций isn't really a good idea anyway.

Answer 3

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

P.S. Трудно сказать, правильно это или нет, не зная, чего вы пытаетесь достичь. Имейте в виду, что независимо от того, является ли это шаблонной или перегруженной функцией, ваш оператор будет выбран во время компиляции. Если вам нужна диспетчеризация во время выполнения, вам нужен полиморфизм, а не перегрузка. Ну, вы, наверное, знаете это; на всякий случай.

Answer 4

Что вы имеете здесь, это перегрузка функции; для получения шаблонной специализации вам действительно нужен синтаксис template <>. Однако вы должны знать, что эти два подхода, даже если они могут казаться идентичными, немного отличаются друг от друга, и даже компилятор может потеряться при выборе правильной функции для вызова. Список всех возможных случаев будет слишком длинным для ответа, но вы можете проверить Herb Sutter GoTW #49 на эту тему.

Answer 5

Вы

• void operator()(bool b), что не шаблонного функция
• template< typename T > void operator()(T t), который представляет собой отдельный шаблон база, которая перегружает выше

Вы могли бы иметь полную специализацию второго, как в template<> void operator(int i), который будет рассматриваться только тогда, когда void operator()(bool b) не совпадает.

Специализация базового шаблона используется для выбора метода базового шаблона для вызова.Однако в вашем случае у вас есть не шаблонный метод, который будет рассмотрен первым.

Статья Why Not Specialize Function Templates? дает довольно хорошее объяснение способа выбора метода.

В sumary:

1. Номер функций шаблонных считаются первыми (это ваш обычный оператора() (Его) выше)
2. Функции базовых шаблонов провериться второго (это ваш шаблонный функция), выбирается наиболее специализированный базовый шаблон, а затем, если он имеет специализацию для точных типов, в которых используется специализация, базовый шаблон используется с «правильными» типами (см. объяснение в статье)

Пример:

#include <iostream> 
using namespace std; 

struct doh 
{ 
    void operator()(bool b) 
    { 
     cout << "operator()(bool b)" << endl; 
    } 

    template< typename T > void operator()(T t) 
    { 
     cout << "template <typename T> void operator()(T t)" << endl; 
    } 
}; 
// note can't specialize inline, have to declare outside of the class body 
template<> void doh::operator()<>(int i) 
{ 
    cout << "template <> void operator()<>(int i)" << endl; 
} 
template<> void doh::operator()<>(bool b) 
{ 
    cout << "template <> void operator()<>(bool b)" << endl; 
} 

int main() 
{ 
    doh d; 
    int i; 
    bool b; 
    d(b); 
    d(i); 
} 

Вы получаете звонки в:

operator()(bool b)  <-- first non template method that matches 
template <> void operator()(int i)  <-- the most specialized specialization of templated function is called