Sind freie Betreiber->* überlastungen böse?

Das beste Beispiel, das ich mir bewusst bin, ist Boost.Phoenix, die überlastungen dieser operator zu implementieren faul member-Zugang.

Für diejenigen, die nicht mit Phoenix, es ist eine höchst raffinierte Bibliothek für das erstellen von Schauspieler (oder function-Objekte), die Aussehen wie normale Ausdrücke:

( arg1 % 2 == 1 )     //this expression evaluates to an actor
                 (3); //returns true since 3 % 2 == 1

//these actors can also be passed to standard algorithms:
std::find_if(c.begin(), c.end(), arg1 % 2 == 1);
//returns iterator to the first odd element of c

Erreicht der oben durch überlastung operator% und operator==. angewendet werden, um die Schauspieler arg1 diese Operatoren Rückkehr ein anderer Schauspieler. Die Palette der Ausdrücke, die gebaut werden können auf diese Weise extrem:

//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"
    ]
  ]
);

Nachdem Sie wurden mit Phoenix für eine kurze Zeit (nicht, dass Sie jemals wieder gehen) wird man versuchen, so etwas wie dieses:

typedef std::vector<MyObj> 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;

Was fehlschlägt, weil der Kurs von Phoenix Akteure, die nicht Mitglied ValidStateBit. Phoenix bekommt um diese durch überlastung 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->*'s Argumente sind:

• LHS: Schauspieler Rückkehr MyObj *
• RHS: - Adresse eines Mitglieds

Gibt es einen Schauspieler, der die Auswertung der LHS und sucht das angegebene Element in ihm. (NB: hat Sie wirklich, wirklich wollen, stellen Sie sicher, dass arg1 zurück MyObj * - Sie haben nicht gesehen, eine riesige Vorlage Fehler, bis Sie etwas falsch in Phoenix. Dieses kleine Programm generiert 76,738 Zeichen von Schmerzen (Boost 1.54, gcc 4.6):

#include <boost/phoenix.hpp>
using boost::phoenix::placeholders::arg1;

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

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

Googeln Sie ein bisschen herum, fand ich mehrere Instanzen von Leuten gefragt, ob operator->* überhaupt benutzt wird, als tatsächliche Vorschläge.

Ein paar Orte vorschlagen T &A::operator->*( T B::* ). Nicht sicher, ob dies spiegelt designer ' s Absicht oder ein misimpression, dass T &A::operator->*( T A::* ) ist ein builtin. Nicht wirklich in Bezug auf meine Frage, aber gibt eine Vorstellung von der Tiefe fand ich in der online-Diskussion & Literatur.

Gab es eine Erwähnung der "D&E 11.5.4", die ich vermute, ist das Design und Evolution von C++. Vielleicht enthält einen entsprechenden Hinweis. Ansonsten, ich bin nur gonna schließen, es ist ein bisschen nutzlos, Hässlichkeit, dass übersehen wurde, die Standardisierung und die meisten anderen auch.

Bearbeiten Siehe unten für eine paste, die D&E Angebot.

Diese quantitativ ->* ist die engste Bindung operator können überladen werden, indem eine Kostenlose Funktion. Alle postfix-Ausdruck und unäre Operatoren überlastungen erfordern eine nichtstatische member-Funktion Unterschriften. Nächste Priorität nach unären Operatoren im C-Stil-casts, die gesagt werden könnte, zu entsprechen Konvertierungsfunktionen (operator type()), die man auch nicht Kostenlose Funktionen. Dann kommt ->*, dann die Multiplikation. ->* hätte wie [] oder wie % Sie gegangen sein könnte oder so, und Sie entschied sich für den Weg der EEEEEEVIL.