Специализации, которые структурно идентичны

Question

Рассмотрим два частичных специализаций ниже:

#include <iostream> 
#include <vector> 
#include <type_traits> 

template <typename, typename...> struct A; 

template <typename... Ts> 
struct A<int, Ts...> { 
    void foo (int a) const {std::cout << a << '\n';} 
    void operator()(const std::vector<int>& v) const {std::cout << v.size() << '\n';} 
}; 

template <typename... Ts> 
struct A<char, Ts...> { 
    void foo (char a) const {std::cout << a << '\n';} 
    void operator()(const std::vector<char>& v) const {std::cout << v.size() << '\n';} 
}; 

int main() { 
    A<int, long, double> a; 
    A<char, float, bool, short> b; 
    a.foo(5); // 5 
    b.foo('!'); // ! 
    a({1,2,3}); // 3 
    b({1,2,3}); // 3 
} 

Как написать два специализаций только один раз?

template <typename T, typename... Ts> 
struct A<T, Ts...> { 
    static_assert (std::is_same<T,int>::value || std::is_same<T,char>::value, "Error"); 
    void foo (T a) const {std::cout << a << '\n';} 
    void operator()(const std::vector<T>& v) const {std::cout << v.size() << '\n';} 
}; 

не работает, потому что ничего не специализироваться, и я не могу поставить class = std::enable_if<std::is_same<T,int>::value || std::is_same<T,char>::value, T>::type в любом месте, потому что по умолчанию аргумент а не может пойти после обновления. Вышеупомянутые специализации должны быть только для int и char. Любой другой тип будет некоторым другим общим определением для класса.

Answer 1

Я думаю, что это лучше.

template <typename T> struct B 
{ 
    void foo (T a) const 
    { 
     std::cout << a << '\n'; 
    } 
    void operator()(const std::vector<T>& v) const 
    { 
     std::cout << v.size() << '\n'; 
    } 

}; 

template <typename T, typename... Ts> 
struct A {}; 

template <typename... Ts> 
struct A<int,Ts...> :public B<int> 
    {}; 
template <typename... Ts> 
struct A<char,Ts...> :public B<char> 
    {}; 


int main() 
{ 
    A<int, long, double> a; 
    A<char, float, bool, short> b; 
    a.foo(5); // 5 
    b.foo('!'); // ! 
    a({1,2,3}); // 3 
    b({1,2,3}); // 3 
} 

Этот способ более прост и чист.

Answer 2

Спасибо, к Агар Т.С., как всегда:

#include <iostream> 
#include <vector> 
#include <type_traits> 

template <typename, typename...> struct A; 

template <typename T, typename... Ts> 
struct B { 
    void foo (T a) const {std::cout << a << '\n';} 
    void operator()(const std::vector<T>& v) const {std::cout << v.size() << '\n';} 
}; 

template <typename... Ts> 
struct A<int, Ts...> : B<int, Ts...> {}; 

template <typename... Ts> 
struct A<char, Ts...> : B<char, Ts...> {}; 


int main() { 
    A<int, long, double> a; 
    A<char, float, bool, short> b; 
    a.foo(5); // 5 
    b.foo('!'); // ! 
    a({1,2,3}); // 3 
    b({1,2,3}); // 3 
}