boost lambda:：绑定返回类型选择

我想通过lambda:：bind调用一个成员。不幸的是，我有两个成员的名字相同，但返回类型不同。 有没有办法帮助lambda:：bind推断成员函数调用的正确返回类型？（通过显式返回类型扣减，绑定工作正常）

#包括
#包括
#包括
#包括
#包括
#包括
使用名称空间std；
使用名称空间boost；
结构A
{
A（常量字符串和名称）：m_name（名称）{}
string&name（）{return m_name；}
const string&name（）const{return m_name；}
字符串m_name；
};
向量av；
int main（）
{
av.push_back（某个名字）；
//编撰精良
如果（av.begin（），av.end（），bind（&A:：name，_1）=“some name”），则查找；
//错误：重载的“bind（，const boost:：lambda:：lambda_functor&）”调用不明确
如果（av.begin（），av.end（），lambda:：bind（&A:：name，lambda:：_1）=“some name”），则查找；
返回0；
}

查看文档

由绑定表达式创建的lambda functor的返回类型可以作为显式指定的模板参数给出，如下例所示：

绑定（目标函数，绑定参数列表）”

因此，只需执行与boost相同的操作：绑定

  find_if(av.begin(), av.end(), lambda::bind<const string &>(&A::name, lambda::_1) == "some name");

find_if（av.begin（），av.end（），lambda:：bind（&A:：name，lambda:：_1）=“some name”）；

---

p.S.未经测试

不同的回报类型是一种误导。问题在于方法的const重载（即，无论相对返回类型是什么，您都会遇到相同的问题）。这是一个有文档记录的问题，并且使用指定的返回类型表单是（除了某些版本的MSVC外，大多数情况下都可以工作）

问题在于，获取重载成员函数（const重载或parameter重载）的地址是不明确的，因此需要一些额外的信息

解决方案是强制转换函数指针，它让编译器确切地知道您想要哪个重载函数，我发现最干净的方法是定义函数指针类型，否则代码行会变得有点糟糕。下面是一个代码示例（编译干净的gcc 4.3.4）：

#包括
#包括
#包括
#包括
#包括
#包括
使用名称空间std；
使用名称空间boost；
结构A
{
A（常量字符串和名称）：m_name（名称）{}
string&name（）{return m_name；}
const string&name（）const{return m_name；}
字符串m_name；
};
向量av；
//非常量版本的函数指针
typedef字符串&（A:：*NameFuncType）（无效）；
//常量版本的函数指针
typedef常量字符串&（A:：*NameConstFuncType）（void）常量；
int main（）
{
av.push_back（某个名字）；
//调用const version w/boost:：bind的“正确”方法
查找if（av.begin（），av.end（），
绑定（静态_cast（&A:：name），_1）=“某个名称”
);
//调用非常量版本w/boost:：lambda:：bind
查找if（av.begin（），av.end（），
lambda:：bind（static_cast（&A:：name），lambda:：_1）=“some name”
);
返回0；
}

您刚刚指出了真正的问题：）有一种方法可以覆盖lambda:：boost中的返回类型，但它只适用于lambda表达式，不适用于绑定。请参阅参考资料中的：lambda:：ret（e）。不幸的是，在目前的情况下，它是不适用的。。。

  find_if(av.begin(), av.end(), lambda::bind<const string &>(&A::name, lambda::_1) == "some name");

#include <vector>
#include <iostream>
#include <algorithm>
#include <boost/bind.hpp>
#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>

using namespace std;
using namespace boost;

struct A
{
  A (const string & name) : m_name(name) {}

  string &        name ()         { return m_name; }
  const string &  name () const   { return m_name; }

  string m_name;
};

vector<A> av;

//function pointer for non-const version
typedef string& (A::*NameFuncType)(void);

//function pointer for const version
typedef const string& (A::*NameConstFuncType)(void) const;

int main () 
{
  av.push_back (A ("some name"));

  //'correct' way to call const version w/ boost::bind
  find_if(av.begin(), av.end(), 
    bind(static_cast<NameConstFuncType>(&A::name), _1) == "some name"
  );

  //call for non-const version w/ boost::lambda::bind
  find_if(av.begin(), av.end(), 
     lambda::bind(static_cast<NameFuncType>(&A::name), lambda::_1) == "some name"
  );

  return 0;
}