C++ 是否有可能防止；复制并粘贴类似模板“特殊情况”；这个代码？

我有一个递归读取向量的程序，如下所示：

#define ARRAYTOJSON(x) arrayToJson<decltype(x)>(#x,x)
template<class V>
inline void arrayToJson(const char* c,V& v){
    typedef typename V::value_type E;
    for(typename std::vector<E>::iterator it=v.begin();it!=v.end();++it){
        arrayToJson(c,*it);
    }
}

template<>
inline void arrayToJson(const char* c,int& v){
    printf("%s %d\n",c,v);
}

int main(){
    std::vector<int> v;
    v.push_back(5);
    ARRAYTOJSON(v);

    int i=0;
    ARRAYTOJSON(i);
    return 0;
}

我现在需要做的是复制特殊情况并将其放入代码中：

template<>
inline void arrayToJson(const char* c,A& v){
    v.test();
}

template<>
inline void arrayToJson(const char* c,B& v){
    v.test();
}

模板
内联void arrayToJson（常量字符*c，A&v）{
v、 test（）；
}
模板
内联void arrayToJson（常量字符*c、B&v）{
v、 test（）；
}

是否有任何语法强制特殊情况（如果不能使用其他特殊情况）使用通用模板特殊情况，如：

template<>
inline void arrayToJson(const char* c,B& v){
    v.test();
}

模板
内联void arrayToJson（常量字符*c、B&v）{
v、 test（）；
}

---

这样我就不需要为每个类复制和放置每个特殊情况了？

您可以编写两个非特殊版本，无论

V

是否具有名为

test

的成员函数，都会对其进行标记调度：

//you'll need void_t for this
template <typename T, typename=void>
struct has_test : std::false_type{};
template <typename T>
struct has_test<T, void_t<decltype(std::declval<T>().test())>> : std::true_type{};

//base case
template <typename V>
inline void arrayToJson(const char* c, V& v) {
    //tag dispatch
    arrayToJsonImpl(c,v,has_test<V>{});   
}

//int specialization
template <>
inline void arrayToJson(const char* c,int& v){
    printf("%s %d\n",c,v);
}

//V does not have test
template<class V>
inline void arrayToJsonImpl(const char* c,V& v,std::false_type){
    typedef typename V::value_type E;
    for(typename std::vector<E>::iterator it=v.begin();it!=v.end();++it){
        arrayToJson(c,*it);
    }
}

//V does have test
template <typename V>
void arrayToJsonImpl(const char* c,V& v, std::true_type)
{
    (void)c;
    v.test();        
}

//您需要使用void\t来执行此操作
模板
结构有_测试：std:：false _类型{}；
模板
结构有_测试：std:：true _类型{}；
//基本情况
模板
内联void arrayToJson（常量字符*c，V&V）{
//标签发送
arrayToJsonImpl（c，v，has_test{}）；
}
//整数特化
模板
内联void arrayToJson（常量字符*c，int&v）{
printf（“%s%d\n”，c，v）；
}
//V没有测试
模板
内联void arrayToJsonImpl（常量字符*c、V&V、标准：：false_类型）{
typedef typename V:：value_type E；
对于（typename std:：vector:：iterator it=v.begin（）；it！=v.end（）；++it）{
（c，*它）；
}
}
//V有测试
模板
void arrayToJsonImpl（常量字符*c、V&V、标准：：真值类型）
{
（c）无效；
v、 test（）；
}

---

您可以编写两个非专用版本，无论

V

是否具有名为

test

的成员函数，都会对其进行标记调度：

//you'll need void_t for this
template <typename T, typename=void>
struct has_test : std::false_type{};
template <typename T>
struct has_test<T, void_t<decltype(std::declval<T>().test())>> : std::true_type{};

//base case
template <typename V>
inline void arrayToJson(const char* c, V& v) {
    //tag dispatch
    arrayToJsonImpl(c,v,has_test<V>{});   
}

//int specialization
template <>
inline void arrayToJson(const char* c,int& v){
    printf("%s %d\n",c,v);
}

//V does not have test
template<class V>
inline void arrayToJsonImpl(const char* c,V& v,std::false_type){
    typedef typename V::value_type E;
    for(typename std::vector<E>::iterator it=v.begin();it!=v.end();++it){
        arrayToJson(c,*it);
    }
}

//V does have test
template <typename V>
void arrayToJsonImpl(const char* c,V& v, std::true_type)
{
    (void)c;
    v.test();        
}

//您需要使用void\t来执行此操作
模板
结构有_测试：std:：false _类型{}；
模板
结构有_测试：std:：true _类型{}；
//基本情况
模板
内联void arrayToJson（常量字符*c，V&V）{
//标签发送
arrayToJsonImpl（c，v，has_test{}）；
}
//整数特化
模板
内联void arrayToJson（常量字符*c，int&v）{
printf（“%s%d\n”，c，v）；
}
//V没有测试
模板
内联void arrayToJsonImpl（常量字符*c、V&V、标准：：false_类型）{
typedef typename V:：value_type E；
对于（typename std:：vector:：iterator it=v.begin（）；it！=v.end（）；++it）{
（c，*它）；
}
}
//V有测试
模板
void arrayToJsonImpl（常量字符*c、V&V、标准：：真值类型）
{
（c）无效；
v、 test（）；
}

---

为什么不尝试为所有特殊情况添加基类？当

V

具有名为

test

的成员函数时，是否希望启用

arrayToJson

版本？为什么不尝试为所有特殊情况添加基类？当

V

具有成员时，是否希望启用

arrayToJson

版本函数调用了

测试

？