Templates `std:：函数`模板参数推断/替换失败

这基本上就是我想做的，但失败了：

#include <functional>


class MyClass
{
public:
    template <typename T>
    MyClass(const std::function<void (const T& )>& )
    {
    }

};

void function(const int& i)
{

}

int main()
{
    MyClass t( &function );
    // ^ main.cpp: In function ‘int main()’:
    //   main.cpp:20:26: error: no matching function for call to
    //   ‘MyClass::MyClass(void (*)(const int&))’
    //        MyClass t( &function );
    //                             ^
    //   main.cpp:7:5: note: candidate: 
    //   template<class T> MyClass::MyClass(const std::function<void(const T&)>&)
    //        MyClass(const std::function<void (const T& )>& )
    //        ^
    //   main.cpp:7:5: note:   template argument deduction/substitution failed:
    //   main.cpp:20:26: note:   mismatched types 
    //   ‘const std::function<void(const T&)>’ and ‘void (*)(const int&)’
    //        MyClass t( &function );
    //                             ^
    //   main.cpp:4:7: note: candidate: constexpr MyClass::MyClass(const MyClass&)
    //    class MyClass
    //          ^
    //   main.cpp:4:7: note:   no known conversion for argument 1 from 
    //   ‘void (*)(const int&)’ to ‘const MyClass&’
    //   main.cpp:4:7: note: candidate: constexpr MyClass::MyClass(MyClass&&)
    //   main.cpp:4:7: note:   no known conversion for argument 1 from 
    //   ‘void (*)(const int&)’ to ‘MyClass&&’


}

#包括
类MyClass
{
公众：
模板
MyClass（const std:：function&）
{
}
};
空函数（常数int&i）
{
}
int main（）
{
myt类（函数和函数）；
//^main.cpp:在函数“int main（）”中：
//main.cpp:20:26:错误：没有用于调用的匹配函数
//'MyClass:：MyClass（void（*）（const int&）'
//myt类（函数和函数）；
//                             ^
//main.cpp:7:5：注：候选人：
//模板MyClass:：MyClass（常量std:：函数&）
//MyClass（const std:：function&）
//        ^
//main.cpp:7:5:注意：模板参数扣除/替换失败：
//main.cpp:20:26:注意：类型不匹配
//“const std:：function”和“void（*）（const int&）”
//myt类（函数和函数）；
//                             ^
//main.cpp:4:7:注：候选：constexpr MyClass:：MyClass（const MyClass&）
//类MyClass
//          ^
//main.cpp:4:7:注意：参数1从
//“void（*）（const int&）”到“const MyClass&”
//main.cpp:4:7:注：候选：constexpr MyClass:：MyClass（MyClass&&）
//main.cpp:4:7:注意：参数1从
//“void（*）（const int&）”到“MyClass&&”
}

普通函数不会转换为

std:：function

，而是编译器尝试复制或移动构造函数，这显然是失败的。我不知道为什么会这样。有什么好办法可以让20号线正常工作吗

编辑：MyClass的构造函数

public

问题是： 编译器需要一些

std:：function

作为参数，以便推断类型

T

。这里，您给出了编译器不可能的情况：首先将

&function

隐式转换为

std:：function

，然后将

T

推断为

int

。编译器不知道怎么做。它不能隐式地将指针转换为function int std:：function并推断模板类型

其次，构造函数是私有的

现在，我们如何解决它

备选案文1： 将函数指针包装在std:：function中：

MyClass t( std::function<void(const int&)>(function) );

MyClass t（std:：function（function））；

备选案文2： 将构造函数重载为获取函数指针的构造函数

template <class T> 
    MyClass(void (*p)(const T& ))
    {
    }

模板
MyClass（无效（*p）（常数T&）
{
}

备选案文3： 将构造函数重载为某些可调用的值：

template <class Callable>
Myclass (Callable c){}

模板
Myclass（可调用c）{}

很抱歉，构造函数是私有的，这不是我的本意。但问题是一样的。好啊为了制作一个简单的示例，我删除了实现细节。但是类型

T

必须在构造函数内部已知，因此不能使用选项3。选项1与第20行不同。方案2运作良好。我以为我可以只使用一个Ctor，但你解释了编译器是如何推理的。非常感谢。