C++ 带有bind和make_对的未解决重载

我试图使用

std:：for_each和boost:：bind将
map
的所有键复制到另一个

我听到一个编译错误说

 error: no matching function for call to 
 ‘bind(<unresolved overloaded function type>, boost::arg<1>&, boost::arg<1>&)’

错误：没有用于调用的匹配函数
'绑定（，boost:：arg&，boost:：arg&）'

下面是我的代码

 using namespace boost;
 map<string,int32_t> A;

 typedef map<string,string>  BType;
 BType B;

 std::for_each(A.begin(), A.end(), 
         bind(&BType::insert,&B,bind(&std::make_pair,_1,_1)));

使用名称空间boost；
地图A；
typedef映射b类型；
B型；
std：：对于每个（A.begin（），A.end（），
绑定（&B类型：：insert，&B，绑定（&std：：make_pair，_1，_1））；

你知道怎么回事吗？
关键问题是你不能获取重载集的地址：
std:：make\u pair
是一个函数模板，你甚至没有说明你在谈论什么样的实例化。同样地，
std:：map:：insert
也是重载的，例如，一个版本包含一个元素，而一个版本包含一个范围

即使您可以以某种形式获取重载函数的地址，但如果您能够帮助它，您实际上并不想这样做！原因是通过函数指针或成员函数指针调用要比调用
内联
函数昂贵得多，而通过函数指针调用要内联得多：编译器必须证明特定的[member]函数指针始终引用同一个[member]函数

这两个问题的解决方案都是为
bind（）
提供一个带有模板化函数调用操作符的函数对象，该操作符只需委托给相应的函数。例如：

struct make_a_pair {
    template <typename T0, typename T1>
    std::pair<T0, T1> operator()(T0&& t0, T1&& t1) {
        return std::make_pair(std::forward<T0>(t0), std::forward<T1>(t1));
    }
};

有了这两个函数对象，您可以使用
bind（）
表达式：

std::for_each(A.begin(), A.end(),
    boost::bind(inserter(), &B, boost::bind(make_a_pair(), _1, _1)));

现在我不能很容易地测试这一点，但是沿着这些思路应该可以工作，假设需要成对的
\u1
和
\u1
。看起来，您确实希望创建从键到键的映射，在这种情况下，您需要适当地投影原始映射的键，例如，使用另一个函数对象：

struct project1st {
    template <typename T0, typename T1>
    typename std::remove_const<T0>::type
    operator()(std::pair<T0, T1> const& p) const {
        return p.first;
    }
};

关键问题是您不能获取重载集的地址：
std:：make_-pair
是一个函数模板，您甚至没有说明您正在谈论的实例化。同样地，
std:：map:：insert
也是重载的，例如，一个版本包含一个元素，而一个版本包含一个范围

即使您可以以某种形式获取重载函数的地址，但如果您能够帮助它，您实际上并不想这样做！原因是通过函数指针或成员函数指针调用要比调用
内联
函数昂贵得多，而通过函数指针调用要内联得多：编译器必须证明特定的[member]函数指针始终引用同一个[member]函数

这两个问题的解决方案都是为
bind（）
提供一个带有模板化函数调用操作符的函数对象，该操作符只需委托给相应的函数。例如：

struct make_a_pair {
    template <typename T0, typename T1>
    std::pair<T0, T1> operator()(T0&& t0, T1&& t1) {
        return std::make_pair(std::forward<T0>(t0), std::forward<T1>(t1));
    }
};

有了这两个函数对象，您可以使用
bind（）
表达式：

std::for_each(A.begin(), A.end(),
    boost::bind(inserter(), &B, boost::bind(make_a_pair(), _1, _1)));

现在我不能很容易地测试这一点，但是沿着这些思路应该可以工作，假设需要成对的
\u1
和
\u1
。看起来，您确实希望创建从键到键的映射，在这种情况下，您需要适当地投影原始映射的键，例如，使用另一个函数对象：

struct project1st {
    template <typename T0, typename T1>
    typename std::remove_const<T0>::type
    operator()(std::pair<T0, T1> const& p) const {
        return p.first;
    }
};

关键问题是您不能获取重载集的地址：
std:：make_-pair
是一个函数模板，您甚至没有说明您正在谈论的实例化。同样地，
std:：map:：insert
也是重载的，例如，一个版本包含一个元素，而一个版本包含一个范围

即使您可以以某种形式获取重载函数的地址，但如果您能够帮助它，您实际上并不想这样做！原因是通过函数指针或成员函数指针调用要比调用
内联
函数昂贵得多，而通过函数指针调用要内联得多：编译器必须证明特定的[member]函数指针始终引用同一个[member]函数

这两个问题的解决方案都是为
bind（）
提供一个带有模板化函数调用操作符的函数对象，该操作符只需委托给相应的函数。例如：

struct make_a_pair {
    template <typename T0, typename T1>
    std::pair<T0, T1> operator()(T0&& t0, T1&& t1) {
        return std::make_pair(std::forward<T0>(t0), std::forward<T1>(t1));
    }
};

有了这两个函数对象，您可以使用
bind（）
表达式：

std::for_each(A.begin(), A.end(),
    boost::bind(inserter(), &B, boost::bind(make_a_pair(), _1, _1)));

现在我不能很容易地测试这一点，但是沿着这些思路应该可以工作，假设需要成对的
\u1
和
\u1
。看起来，您确实希望创建从键到键的映射，在这种情况下，您需要适当地投影原始映射的键，例如，使用另一个函数对象：

struct project1st {
    template <typename T0, typename T1>
    typename std::remove_const<T0>::type
    operator()(std::pair<T0, T1> const& p) const {
        return p.first;
    }
};

关键问题是您不能获取重载集的地址：
std:：make_-pair
是一个函数模板，您甚至没有说明您正在谈论的实例化。同样地，
std:：map:：insert
也是重载的，例如，一个版本包含一个元素，而一个版本包含一个范围

即使您可以以某种形式获取重载函数的地址，但如果您能够帮助它，您实际上并不想这样做！原因是通过函数指针或成员函数指针调用要比调用
内联
函数昂贵得多，而通过函数指针调用要内联得多：编译器必须证明特定的[member]函数指针始终引用同一个[member]函数

这两个问题的解决方案都是为
bind（）
提供一个带有模板化函数调用操作符的函数对象，该操作符只需委托给相应的函数。例如：

struct make_a_pair {
    template <typename T0, typename T1>
    std::pair<T0, T1> operator()(T0&& t0, T1&& t1) {
        return std::make_pair(std::forward<T0>(t0), std::forward<T1>(t1));
    }
};

有了这两个函数对象，您可以使用
bind（）
表达式：

std::for_each(A.begin(), A.end(),
    boost::bind(inserter(), &B, boost::bind(make_a_pair(), _1, _1)));

现在我不能很容易地测试这一点，但沿着这些李