没有重复定义的 C++ 模板匹配类型

Question

我正在围绕 std::function 创建一个模板包装器。为了匹配返回 void 的函数，我将 std::monostate 作为我的 Unit 类型。我一直在尝试为我的函数包装类型创建两个可变参数模板，一个

template<Unit, Args...>

还有一个

template<T, Args...> where T != Unit.

这是我使用 enable_if 得到的最接近的结果。

#include <functional>
#include <variant>

namespace func {
    // Declare unit type
    typedef std::monostate Unit;

    // Empty type, maybe use this instead of monostate
    template<typename ... ts>
    struct Term {};

    // Variables
    template<typename T>
    struct Term<T>
    {
        T val;
        // Constructor
        Term(T in): val(in) {}

        // Call op just returns the value
        T operator() () const {
            return this->val;
        }
    };

    // Functions that return void
    template <typename T,
                typename ... Args,
                typename = std::enable_if_t<std::is_same<T, Unit>::value>>
    struct Term<Args...>
    {
        // Void returning function
        const std::function<void(Args...)> body;

        // Void returning constructor
        Term(std::function<void(Args...)> func): body(func) {}

        // Void function Caller
        void operator() (const Args&& ...a) const {
            this->body(std::forward<Args>(a)...);
        }
    };

    // Functions that return T
    template <typename T,
                typename ... Args,
                typename = std::enable_if_t<!std::is_same<T, Unit>::value>>
    struct Term<T, Args...>
    {
        // T returning function
        const std::function<T(Args...)> body;

        // T returning constructor
        Term(std::function<T(Args...)> func): body(func) {}

        // T returning function Caller
        T operator() (const Args&& ...a) const {
            return this->body(std::forward<Args>(a)...);
        }
    };

}

但是，在第一种情况下，我遇到了关于不可演绎参数 T 的错误。但是，我已经通过我的enable_if 模板参数知道该参数将是Unit 类型。如何让编译器同时接受这两个定义？

错误：

$ clang++ -std=c++17 terms.hpp -pedantic
terms.hpp:29:18: error: default template argument in a class template partial specialization
                                typename = std::enable_if_t<std::is_same<T, Unit>::value>>
                                           ^
terms.hpp:30:9: error: class template partial specialization contains template parameters that cannot be deduced; this partial specialization will never be used [-Wunusable-partial-specialization]
        struct Term<Args...>
               ^~~~~~~~~~~~~
terms.hpp:27:21: note: non-deducible template parameter 'T'
        template <typename T,
                           ^
terms.hpp:29:7: note: non-deducible template parameter (anonymous)
                                typename = std::enable_if_t<std::is_same<T, Unit>::value>>
                                ^
terms.hpp:47:18: error: default template argument in a class template partial specialization
                                typename = std::enable_if_t<!std::is_same<T, Unit>::value>>
                                           ^
terms.hpp:48:9: error: class template partial specialization contains a template parameter that cannot be deduced; this partial specialization will never be used [-Wunusable-partial-specialization]
        struct Term<T, Args...>
               ^~~~~~~~~~~~~~~~
terms.hpp:47:7: note: non-deducible template parameter (anonymous)
                                typename = std::enable_if_t<!std::is_same<T, Unit>::value>>
                                ^
4 errors generated.

编辑：应该这样使用

auto c = Term<int>(42);
auto fun = Term<int, int, int>([](int a, int b) { return a + b; });

std::cout << c() << std::endl;
std::cout << fun(3,4) << std::endl;

Answer 1

您目前的模板专业化问题是struct Term<Args...> 和struct Term<T, Args...> 不是互斥的，可以匹配相同的东西。所以我建议你把这两种情况合二为一，SFINAE 上的重载调用算子。

这种方法当然有一些限制，但这些限制只是继承自您的原始方法。例如，不可能包装一个不接受参数但返回一个值（即与标量不明确）的函数。

#include <functional>
#include <iostream>
#include <variant>

namespace func {
    // Declare unit type
    typedef std::monostate Unit;

    // Empty type, maybe use this instead of monostate
    template<typename...>
    struct Term;

    // Variables
    template<typename T>
    struct Term<T>
    {
        T val;
        // Constructor
        Term(T in): val(in) {}

        // Call op just returns the value
        T operator() () const {
            return this->val;
        }
    };

    // Functions that return void
    template <typename T, typename ... Args>
    struct Term<T, Args...>
    {
        using R = typename std::conditional<std::is_same<T, Unit>::value,void,T>::type;
        // Void returning function
        const std::function<R(Args...)> body;

        // Void returning constructor
        Term(std::function<R(Args...)> func): body(func) {}

        // Void function Caller
        template <typename U = R>
        typename std::enable_if<std::is_same<U, Unit>::value,void>::type
        operator() (Args&& ...a) const {
            this->body(std::forward<Args>(a)...);
        }

        // T returning function Caller
        template <typename U = R>
        typename std::enable_if<!std::is_same<U, Unit>::value,T>::type
        operator() (Args&& ...a) const {
            return this->body(std::forward<Args>(a)...);
        }

    };
}

int main() {
    auto c = func::Term<int>(42);
    auto fun = func::Term<int, int, int>([](int a, int b) { return a + b; });

    std::cout << c() << std::endl;
    std::cout << fun(3,4) << std::endl;
}

Live example