子模板中的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解决方案

让我们从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;

这样，您可以执行以下操作：

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

希望这会像魅力一样工作;）