C++ C++；子模板中的模板专门化

在json.h中，我有：

模板
Json:：Value write_Json（const T&object）；

在json.cpp中：

模板
Json:：Value write_Json（const bool和object）{
Json：：值输出；
输出=对象；
返回输出；
};
模板
Json:：Value write_Json（const int&object）{
Json：：值输出；
输出=对象；
返回输出；
};
模板
Json:：Value write_Json（const std:：vector&v）{
Json：：值输出；
对于（autoit=v.begin（）；it！=v.end（）；++it）{output.append（*it）；}；
返回输出；
};
模板
Json:：Value write_Json（const std:：vector&v）{
Json：：值输出；
对于（autoit=v.begin（）；it！=v.end（）；++it）{output.append（*it）；}；
返回输出；
};

< C++ > C++中有没有一种方法可以在一个“子模板”上实现基本类型和容器？ 让我们从trait开始检查您是否获得了容器：

template<class ...>
using void_t = void;    

template<class T, class = void>
struct is_container : std::false_type{};

template<class T>
struct is_container<T, void_t<decltype(std::begin(std::declval<T>())), decltype(std::end(std::declval<T>()))>> : std::true_type{};

template<class T>
constexpr auto is_container_v = is_containter<T>::value;

---

希望这会像一个符咒一样起作用；）

请参考这个类似的问题。@ZMJ另一个问题确实是类似的。那里的回答是关于可以使用部分专门化的类如何通过容器进行范围迭代？你的意思是“如果你需要明确的C++11，它就不能完成”，对吗？@Pierre不，我的意思是可以完成，只是稍微复杂一点way@bartop不幸的是，我需要明确的C++11@Medicalphysicist好啊你写这篇文章让我汗流浃背，但我希望工作已经完成；）

template <>
Json::Value write_json(const bool& object) {
    Json::Value output;
    output = object;
    return output;
};

template <>
Json::Value write_json(const int& object) {
    Json::Value output;
    output = object;
    return output;
};

template <>
Json::Value write_json(const std::vector<bool>& v) {
    Json::Value output;
    for (auto it = v.begin(); it != v.end(); ++it) { output.append(*it); };
    return output;
};

template <>
Json::Value write_json(const std::vector<int>& v) {
    Json::Value output;
    for (auto it = v.begin(); it != v.end(); ++it) { output.append(*it); };
    return output;
};

template<class ...>
using void_t = void;    

template<class T, class = void>
struct is_container : std::false_type{};

template<class T>
struct is_container<T, void_t<decltype(std::begin(std::declval<T>())), decltype(std::end(std::declval<T>()))>> : std::true_type{};

template<class T>
constexpr auto is_container_v = is_containter<T>::value;

template <class T>
Json::Value write_json_primitive(const T& object) {
    static_assert(!is_container_v<T>);
    Json::Value output;
    output = object;
    return output;
};

template <class T>
Json::Value write_json_container(const T& v) {
    static_assert(is_container_v<T>);
    Json::Value output;
    for (const auto& val : v) { output.append(val); };
    return output;
};

template <class T>
Json::Value write_json(const T& object) {
    if constexpr (is_container_v<T>)
        return write_json_container(object);
    else
        return write_json_primitive(object);
}

template<typename... Ts> struct make_void { typedef void type;};
template<typename... Ts> using void_t = typename make_void<Ts...>::type;

    
template<class T, class = void>
struct is_container : std::false_type{};
    
template<class T>
struct is_container<T, void_t<decltype(std::begin(std::declval<T>())), decltype(std::end(std::declval<T>()))>> : std::true_type{};

template <class T>
Json::Value write_json_primitive(const T& object) {
    Json::Value output;
    output = object;
    return output;
};

template <class T>
Json::Value write_json_container(const T& v) {
    Json::Value output;
    for (const auto& val : v) { output.append(val); };
    return output;
};


template<class T>
using json_function = std::conditional<
        is_container<T>::value,
            std::integral_constant<decltype(&write_json_container<T>), &write_json_container<T>>,
            std::integral_constant<decltype(&write_json_primitive<T>), &write_json_primitive<T>>>;

template <class T>
Json::Value write_json(const T& object) {
    return json_function<T>::type::value(object);
}