子模板中的 C++ 模板特化

Question

在json.h中我有:

template <class T>
Json::Value write_json(const T& object);

在json.cpp中:

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;
};

在C++中是否有任何方法可以在一个“子模板”上专门化基本类型，在另一个“子模板”上专门化容器？

Answer 1

C++17 解决方案

让我们从特征开始检查您是否正在获取容器:

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);
}

旁注:此代码需要 C++17 支持。如果您明确需要 C++11，可以这样做，但有点不同

C++ 11 解决方案

这里需要更多的元编程，并且 static_asserts 不能那么容易使用，但我仍然做到了:

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);
}

希望这会像魅力一样发挥作用；)