Justification de l'application de certains opérateurs à des membres

Question

Il existe 4 opérateurs en C++ qui peuvent être surchargés mais ne peuvent pas être surchargés en tant que fonctions indépendantes (alias non-membre, autonome). Ces opérateurs sont:

• operator =
• operator()
• operator ->
• operator []

This thread explique parfaitement la raison d'être interdisant operator = être une fonction non-membre. Des idées sur les trois autres?

Answer 1

Les quatre opérateurs mentionnés dans le message original, =, (), -> et [], doivent en effet être mis en oeuvre en tant que fonctions membres non statiques (par respectivement 98 §13.5.3/1 C++, §13.5.4/1, §13.5.5/1 et §13.5.6/1). Si je me souviens bien des précédents débats sur le sujet, Bjarne Stroustrup a eu raison de garder une certaine lucidité dans la langue, c'est-à-dire d'avoir au moins des choses sur lesquelles on peut compter, quel que soit le problème. opérateurs membres pour les classes existantes.

Je ne suis pas sûr que je suis entièrement d'accord que la restriction aide vraiment à cela, mais. : J'ai consulté Bjarne Stroustrup à ce sujet (il est toujours utile) mais il semble que les incohérences apparentes des règles ne sont rien de plus qu'un accident historique figé. Il note que "Cela semble pire maintenant qu'à l'époque parce que nos règles pour les valeurs et les références ont changé depuis que les règles de surcharge ont été formulées.J'ai essayé de réexaminer cette question il y a quelques années, mais j'ai manqué de temps avant de produire un compléter la proposition. "

Vive & HTH,

PS:. « La conception et l'évolution de C++ » livre est idéal pour ce genre de question, mais malheureusement, je ne l'ai pas.

Answer 2

Cette thread sur comp.std.C++ traite de la question.

Francis Glassborow, qui était membre du comité, a déclaré:

Les concepteurs de langue ne veulent pas soutenir les conversions et promotions sur l'opérande gauche de l'opérateur =, ni comme l'opérande de() et [].

Essayer d'éviter la situation où:

class A {}; 

class B { B(A& a) {} }; 

int operator()(B const& b) { return 0; } 


int main(void) 
{ 
    A a; 

    // This works even though A doesn't have a() operator 
    // It creates a temporary B and calls operator()(B& b) 
    return a();     
}