Блог

У меня есть класс

 template <typename T, typename W>
class A {
    void foo(W);
    void foo(T);
    void foo(int);
}
 

Когда T=int , W=int , или W=T , этот класс не может скомпилироваться. Как я могу заставить методы иметь приоритет друг над другом?

Мне нужен приоритет W > T > int . Поэтому, если W=T , foo(T) игнорируется и foo(W) вызывается. Если T=int , foo(int) игнорируется и foo(T) вызывается.

Компилятор — VS2012, но у меня тоже есть Linux, и я также рассмотрю решения GCC / Clang. Все, что компилируется на любом основном компиляторе, идет, но только если вы укажете, на каких компиляторах оно работает.

Я бы отметил dispatch . Переопределение диспетчеризации легко понять и масштабируется.

Мы начинаем с идеальной пересылки:

 template<class U> void foo(Uamp;amp;u){
  foo( std::forward<U>(u), std::is_convertible<U, W>{}, std::is_convertible<U,T>{} );
}
 

он создает типы тегов, в данном случае типы true или false, для отправки.

Этот:

 void foo( W, std::true_type, ... );
 

улавливает все, что может быть преобразовано в W.

Далее мы блокируем этот:

 void foo( T, std::false_type, std::true_type );
 

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

Наконец, этот:

 void foo( int, std::false_type, std::false_type );
 

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

Возможны более причудливые типы тегов или выполнение отправки по одному за раз.

Извините за опечатки.

Я использую одну функцию C 11 — {} для создания объекта — выше. Если вашему компилятору не хватает поддержки этой функции C 11, просто обновите свой компилятор, это 2014 год, смирись с этим. В противном случае замените {} на () .

Используйте std::enable_if :

 #include <type_traits>

template <typename T, typename W>
struct A {
    void foo(W) {}
    template<typename XT=T> typename std::enable_if<std::is_same<XT,T>::value
      amp;amp; !std::is_same<T, W>::value, void>::type foo(T) {}
    template<typename XT=int> typename std::enable_if<std::is_same<XT,int>::value
      amp;amp; !std::is_same<int, T>::value
      amp;amp; !std::is_same<int, W>::value, void>::type foo(int) {}
};
 

Добавлено для тестирования:

 template struct A<short,char>;
template struct A<char,char>;
template struct A<char,int>;
template struct A<int,char>;
template struct A<int, int>;

struct S {};

int main() {
    A<S, int>{}.foo(S{});
}
 

Для соответствующей части вашего шаблона вы можете использовать спецификации:

 template <typename U, typename W>
struct Foo
{
    void f(U);
    void f(W);
};

template <typename T>
struct Foo<T, T>
{
    void f(T);
};
 

Для остальной части вашего класса или шаблона класса вы можете наследовать Foo<A, B> , чтобы исключить общий код из части, которая нуждается в специализации:

 template <typename A, typename B>
struct TheClass : Foo<A, B>
{
    // common code
};
 

Попробуйте специализации шаблонов:

 template <typename T, typename W>
class A {
    void foo(W);
    void foo(T);
    void foo(int);
};

template <typename T>
class A<T, T> {
    void foo(T);
    void foo(int);
};
template <>
class A<int, int> {
    void foo(int);
};
 

Вот решение без специализации A, но с двумя вспомогательными структурами в нескольких формах.

 #include <iostream>

template<typename T, typename W>
struct T_type { typedef T type; };
template<typename W>
struct T_type<W, W>  { typedef void* type; /*dummy type*/};

template<typename T, typename W>
struct int_type { typedef int type; };
template<typename W>
struct int_type<int, W> { typedef void** type; /*dummy type*/};
template<typename T>
struct int_type<T, int> { typedef void** type; /*dummy type*/};
template<>
struct int_type<int, int> { typedef void** type; /*dummy type*/};

template<typename T, typename W>
class A {
public:
    void foo(W w) {
        std::cout << "foo(W)" << std::endl;
    }
    void foo(typename T_type<T, W>::type t) {
        std::cout << "foo(T)" << std::endl;
    }
    void foo(typename int_type<T, W>::type i) {
        std::cout << "foo(int)" << std::endl;
    }
};

int main() {
    std::cout << "A<float, char>" << std::endl;
    A<float, char> a;
    a.foo(1.0f);
    a.foo('1');
    a.foo(1);

    std::cout << "A<float, float>" << std::endl;
    A<float, float> b;
    b.foo(1.0f);
    b.foo(1);

    std::cout << "A<int, int>" << std::endl;
    A<int, int> c;
    c.foo(1);

    return 0;
}