C++ 使用类内构造函数时lambda不进行隐式转换

我正在尝试对

std:：function

下面的代码使用显式转换的函数指针和lambda

template<typename funct>
class functor {
private:
    funct *function;
public:
    functor() = default;
    functor(funct *func) : function(func) {};

    template<typename T>
    T operator()(T a, T b){
        return function(a, b);
    }
};

int add(int a, int b) {
    return a + b;
}
int main(int argc, char **argv) {
    std::map<std::string, functor<int(int,int)>> maps = { {"+", add} };
    maps.insert({ "%", {[](int i, int j)->int { return i * j; } } } );
    auto temp = maps["%"](5,6);
    std::cout << temp << std::endl;
    system("PAUSE");
    return 0;
 }

上述代码不起作用，但以下代码起作用：

maps.insert({ "%", {[](int i, int j)->int { return i * j; } } } );

---

但是

std:：function

可以与

{}

一起工作，也可以不与之一起工作。

正如@KerrekSB在评论中提到的，只需给你的

functor一个模板构造函数，如下所示：

template<class F>
functor(F f) : function(f) {}

模板
函子（F）：函数（F）{}

现在，您可以在初始化映射时忽略大括号：

#include <map>
#include <iostream>

template<typename funct>
class functor {
private:
    funct *function;
public:
    functor() = default;

    template<class F>
    functor(F f) : function(f) {}

    template<typename T>
    T operator()(T a, T b){
        return function(a, b);
    }
};

int add(int a, int b) {
    return a + b;
}

int main(int argc, char **argv) {
    std::map<std::string, functor<int(int,int)>> maps = { {"+", add} };
    maps.insert({ "%", [](int i, int j)->int { return i * j; } }  );
    auto temp = maps["%"](5,6);
    std::cout << temp << std::endl;
 }

#包括
#包括
模板
类函子{
私人：
funct*函数；
公众：
函子（）=默认值；
模板
函子（F）：函数（F）{}
模板
T运算符（）（T a，T b）{
返回函数（a，b）；
}
};
整数相加（整数a，整数b）{
返回a+b；
}
int main（int argc，字符**argv）{
映射映射={{“+”，add}；
插入（{“%”，[]（inti，intj）->int{returni*j；}}）；
自动温度=映射[“%”（5,6）；
Std::Cudio>代码> STD:：函数有模板的构造函数。@ KeRekSB讲智慧……模板化的构造函数可以让你做你想做的事情……我不知道如何>代码> STD:：函数< /代码>实现相同的目标。另一个要考虑的事情是lambda不是函数对象。你可以转换lambda int。o函数对象，但它们不同，这也可能是没有隐式转换的故意原因。另请参见Try
maps.emplace（“%”，[]（int i，int j）->int{return i*j；}；
。
#include <map>
#include <iostream>

template<typename funct>
class functor {
private:
    funct *function;
public:
    functor() = default;

    template<class F>
    functor(F f) : function(f) {}

    template<typename T>
    T operator()(T a, T b){
        return function(a, b);
    }
};

int add(int a, int b) {
    return a + b;
}

int main(int argc, char **argv) {
    std::map<std::string, functor<int(int,int)>> maps = { {"+", add} };
    maps.insert({ "%", [](int i, int j)->int { return i * j; } }  );
    auto temp = maps["%"](5,6);
    std::cout << temp << std::endl;
 }