是自由运营商 - >*超载邪恶？

它通过重载operator%和实现上述目标operator==.- 应用于actor arg1这些运算符返回另一个actor.可以以这种方式构建的表达式范围极端:

// print each element in c, noting its value relative to 5:
std::for_each(c.begin(), c.end(),
  if_(arg1 > 5)
  [
    cout << arg1 << " > 5\n"
  ]
  .else_
  [
    if_(arg1 == 5)
    [
      cout << arg1 << " == 5\n"
    ]
    .else_
    [
      cout << arg1 << " < 5\n"
    ]
  ]
);

在你使用Phoenix一段时间后(不是你曾经回去过),你会尝试这样的事情:

typedef std::vector container;
container c;
//...
container::iterator inv = std::find_if(c.begin(), c.end(), arg1.ValidStateBit);
std::cout << "A MyObj was invalid: " << inv->Id() << std::endl;

哪个会失败,因为凤凰城的演员当然没有会员ValidStateBit.凤凰城通过超载解决这个问题operator->*:

(arg1 ->* &MyObj::ValidStateBit)              // evaluates to an actor
                                (validMyObj); // returns true 

// used in your algorithm:
container::iterator inv = std::find_if(c.begin(), c.end(), 
      (arg1 ->* &MyObj::ValidStateBit)    );

operator->*的论点是:

LHS:演员回归MyObj *

RHS:会员的地址

它返回一个actor,它评估LHS并在其中查找指定的成员.(注意:你真的,真的想确保arg1返回MyObj *- 你没有看到一个大规模的模板错误,直到你在凤凰城出了问题.这个小程序产生了76,738个字符的痛苦(Boost 1.54,gcc 4.6):

#include 
using boost::phoenix::placeholders::arg1;

struct C { int m; };
struct D { int n; };

int main() {
  ( arg1  ->*  &D::n ) (new C);
  return 0;
}

我同意你的看法标准是不一致的,它不允许operator[]使用非成员函数进行重载并允许它operator->*.我的观点operator[]是数组和operator->*结构/类(一个getter).使用索引选择数组的成员.使用成员指针选择结构的成员.

最糟糕的是我们可以尝试使用->*而不是operator[]像元素一样获取数组

int& operator->*(Array& lhs, int i);

Array a;

a ->* 2 = 10;

还有另一种可能的不连贯性.我们可以使用非成员函数来重载operator+=和表单的所有运算符@=),我们不能这样做operator=.

我真的不知道使下列法律合法化的理由是什么

struct X {
    int val;
    explicit X(int i) : val(i) {}
};
struct Z {
    int val;
    explicit Z(int i) : val(i) {}
};
Z& operator+=(Z& lhs, const X& rhs) {
    lhs.val+=rhs.val;
    return lhs;
}

Z z(2);
X x(3);
z += x;

并且禁止

Z& operator=(Z& lhs, const X& rhs) {
    lhs.val=i;
    return lhs;
}

z = x;

很抱歉没有回答你的问题,但增加了更多的困惑.