c++ - "group"模板特例是否可能？

Question

例如，我有一个用于在 vector 中迭代 vector 的模板函数:

template<class T>
void test(T t){
    for(auto tt : t){
        test(tt);
    }
}

以 pair 作为特例，pair 类型可以是 double,float,int,string,...:

pair<double,double>
pair<double,float>
pair<double,int>
pair<double,string>
pair<float,double>
pair<float,float>
pair<float,int>
pair<float,string>
pair<int,double>
pair<int,float>
pair<int,int>
pair<int,string>
pair<string,double>
pair<string,float>
pair<string,int>
pair<string,string>

模板可能会做一些 pair.first 独立于 pair.second 的工作(可能是添加元素到 json，写入文件，......现在用 printf 来表示):

template<>
void test(pair<double,double> p){
    printf("%f,",p.first);
    printf("%f\n",p.second);
}

template<>
void test(pair<double,float> p){
    printf("%f,",p.first);
    printf("%f\n",p.second);
}
.
.
.

代码有效，但是模板函数的数量太可怕了，因为它需要 16 个模板，是否可以将模板特殊情况分离和分组为第一个和第二个，这样它只需要 8 个模板，如下所示:

pair<double,T>
pair<float,T>
pair<int,T>
pair<string,T>
pair<T,double>
pair<T,float>
pair<T,int>
pair<T,string>

我尝试了以下但无法编译:

template<class SECOND>
void test(pair<double,SECOND> p){
    printf("%f,",p.first);
    test<double,SECOND>(p);
}

template<class SECOND>
void test(pair<float,SECOND> p){
    printf("%f,",p.first);
    test<double,SECOND>(p);
}
.
.
.
template<class FIRST>
void test(pair<FIRST,int> p){
    printf("%d\n",p.second);
}

template<class FIRST>
void test(pair<FIRST,string> p){
    printf("%s\n",p.second.c_str());
}

是否可以这样重写模板？

Answer 1

namespace details {
    template<class T>
    using is_wanted_type =
             std::integral_constant<bool, std::is_same<int, T>{}
                                       || std::is_same<float, T>{}
                                       || std::is_same<double, T>{} 
                                       || std::is_same<std::string, T>{}>;

    void process_first(int) { /* ... */ }
    void process_first(float) { /* ... */ }
    void process_first(double) { /* ... */ }
    void process_first(const std::string &) { /* ... */ }

    void process_second(int) { /* ... */ }
    void process_second(float) { /* ... */ }
    void process_second(double) { /* ... */ }
    void process_second(const std::string &) { /* ... */ }
}

template<class T1, class T2>
std::enable_if_t<details::is_wanted_type<T1>{} && details::is_wanted_type<T2>{}>
test(const std::pair<T1, T2> &p) {
    details::process_first(p.first);
    details::process_second(p.second);
}