C模板特化的类型推导在ulus参数上失败

Question

我创建了一个模板类，其中构造函数采用std：：function对象。第一个模板参数指示该函数的返回值。第二个参数定义该函数的参数类型。

#include <functional>

//Base
template<class R, class Arg>
class Executor {
    public:      
        Executor(std::function<R(Arg)> function) 
            : mFunction(function)  
        {}

    private:
        std::function<R(Arg)> mFunction;
};

//Specialization1
template<class Arg>
class Executor<void, Arg> {
    public:      
        Executor(std::function<void(Arg)> function) 
            : mFunction(function)  
        {}

    private:
        std::function<void(Arg)> mFunction;
};

//Specialization2
template<class R>
class Executor<R, void> {
    public:      
        Executor(std::function<R()> function) 
            : mFunction(function)  
        {}

    private:
        std::function<R()> mFunction;
};

int testBase(float value) {
    return 5;
}

void testSpecialization1(float value) {}

int testSpecialization2() {
    return 22;
}

int main() {
    Executor executorBase{std::function(testBase)};
    
    Executor executorSpecialization1{std::function(testSpecialization1)};
    
    //Executor<int, void> executorSpecialization2{std::function(testSpecialization2)}; // Compiles
    Executor executorSpecialization2{std::function(testSpecialization2)}; // Doesn't compile. Uses Base. template<class R, class Arg>
}

关于使用函数std：：function

main.cpp: In function 'int main()':
main.cpp:55:72: error: class template argument deduction failed:
   55 |     Executor executorSpecialization2{std::function(testSpecialization2)}; // Doesn't compile. Uses Base. template<class R, class Arg>
      |                                                                        ^
main.cpp:55:72: error: no matching function for call to 'Executor(std::function<int()>)'
main.cpp:7:9: note: candidate: 'template<class R, class Arg> Executor(std::function<R(Arg)>)-> Executor<R, Arg>'
    7 |         Executor(std::function<R(Arg)> function)
      |         ^~~~~~~~
main.cpp:7:9: note:   template argument deduction/substitution failed:
main.cpp:55:72: note:   candidate expects 1 argument, 0 provided
   55 |     Executor executorSpecialization2{std::function(testSpecialization2)}; // Doesn't compile. Uses Base. template<class R, class Arg>
      |                                                                        ^
main.cpp:5:7: note: candidate: 'template<class R, class Arg> Executor(Executor<R, Arg>)-> Executor<R, Arg>'
    5 | class Executor {
      |       ^~~~~~~~
main.cpp:5:7: note:   template argument deduction/substitution failed:
main.cpp:55:72: note:   'std::function<int()>' is not derived from 'Executor<R, Arg>'
   55 |     Executor executorSpecialization2{std::function(testSpecialization2)}; // Doesn't compile. Uses Base. template<class R, class Arg>
      |

它尝试使用基本版本。但第二个参数当然丢失了。如果我指定它编译的模板参数。

那么，为什么选择基本模板作为executorSpecialization2呢？甚至可以在这里对void使用类型推断，而不需要传递模板参数吗？

谢啦

Answer 1

int（val）仅在狭窄的情况下可用作int（）。

像这样改变它：

template<class R, class... Args>
class Executor

并将参数替换为参数 。

NixR， val专业化。

如果需要类执行器

您的代码现在将编译一个作品。

（产生错误的原因：隐式生成的扣除指南仅基于主要专门化。std：：function（testSpecialization2）是std：：function

Answer 2

当您使用名称Executor时，没有像Executor中那样的显式模板参数

主模板具有构造函数Execitor（std::function

但是看到std::f

但您可以通过编写“扣除指南”来协助CTAD：

template <class R>
Executor(std::function<R()>) -> Executor<R, void>;

除主模板的构造函数外，还使用扣除指南。现在是一个类型为std：：function的参数

看看它对coliru的作用。