模板类可以用作模板函数特化的参数吗？

Question

我有以下模板函数：

template <class T>
inline T ParseValueFromJson(const JSONValue& jsonValue);

在其他模板函数中依次使用，例如：

template <class T>
bool TryGetValueFromJson(
    const JSONValue& jsonValue,
    const String& name,
    T& variable)
{
    if (!jsonValue.Contains(name))
    {
        return false;
    }

    variable = ParseValueFromJson<T>(jsonValue[name]);
    return true;
}

现在我想将 ParseValueFromJson 专门用于许多不同的类型，其中之一是模板类（Vector）。然而，使用典型的特化意味着 Vector 的类型参数将是未定义的：

template <>
inline Vector<T> ParseValueFromJson<Vector<T>>(const JSONValue& jsonValue)

除此之外，在函数实现中我需要 T 的类型，因为我将使用 ParseValueFromJson 的 T 类型版本来解析单个项目。

当然，如果我在特化中使用模板 T，它是一个不同的函数，会导致模棱两可的调用：

    template <typename T>
inline Vector<T> ParseValueFromJson<Vector<T>>(const JSONValue& jsonValue)

那么这可能吗，还是我需要选择一个单独的 TryGetContainerFromJson（或类似）函数，将模板化集合类型作为第二个模板参数？

Answer 1

我会选择处理序列化的实现serializer 模板结构（并且可以很容易地部分专门化），如template function specialization can be troublesome。

// Default serializer implementation.
namespace impl
{
    template <typename T>
    struct serializer 
    {
        T from_json(const JSONValue& jv)
        { 
            // default implementation...
        }
    };
}

// Convenient interface function.
template <class T>
inline T ParseValueFromJson(const JSONValue& jsonValue)
{
    return impl::serializer<T>{}.from_json(jsonValue);
}

// "Special" serializer implementations.
namespace impl
{            
    template <typename T>
    struct serializer<Vector<T>>
    {
        Vector<T> from_json(const JSONValue& jv)
        { 
            Vector<T> result;
            for(auto c : jv.children()) 
            {
                result.add(ParseValueFromJson<T>(c));
            }
            return result;
        }
    };
}

Answer 2

您不能部分特化函数模板 (obligatory link to Herb Sutter)，但您始终可以重载函数模板。沿着你的主要前进，将类型作为标签参数传递：

template <class > struct tag { };

template <class T>
inline T ParseValueFromJson(const JSONValue& jsonValue) {
    return impl::ParseValueFromJson(jsonValue, tag<T>{});
}

然后提供一堆重载：

namespace impl {    
    template <class T>
    inline T ParseValueFromJson(const JSONValue& jsonValue, tag<T> ) {
        // generic, if that makes sense
    }

    template <class T>
    inline T ParseValueFromJson(const JSONValue& jsonValue, tag<std::vector<T>> ) {
        // vector version
    }

    // etc.
}

Answer 3

你不能部分特化一个函数，但是你当然可以重载它，包括使用另一个模板化函数。这有效：

template <typename T>
void func(const T& arg)
{
    std::cout << "General" << std::endl;
}

template <typename T>
void func(const std::vector<T>& vec)
{
    std::cout << "Vector overload" << std::endl;
}

int main()
{
    func(1);                   //outputs "General"
    func(std::vector<int>{1}); //outputs "Vector overload"

    return 0;
}   

在您的情况下，如果您愿意通过输出参数返回，您可以调整此解决方案，因此您有 2 个这样的函数：

template <class T>
inline void ParseValueFromJson(const JSONValue& jsonValue, T& output);

template <class T>
inline void ParseValueFromJson(const JSONValue& jsonValue, std::vector<T>& output);

这实际上适用于您的代码，因为您最终已经通过输出参数返回了答案。因此，在您的呼叫站点，您只需更改线路

variable = ParseValueFromJson<T>(jsonValue[name]);

到

ParseValueFromJson<T>(jsonValue[name], variable);