il y a beaucoup de messages qui se plaignent de la surcharge de l'opérateur.

j'ai senti que je devais clarifier les concepts de" surcharge de l'opérateur", offrant un autre point de vue sur ce concept.

code brouillé?

cet argument est fallacieux.

L'obscurcissement est possible dans toutes les langues...

il est aussi facile d'obscurcir le code en C ou en Java par des fonctions/méthodes comme il est en C++ à travers les surcharges de l'opérateur:

// C++
T operator + (const T & a, const T & b) // add ?
{
   T c ;
   c.value = a.value - b.value ; // subtract !!!
   return c ;
}

// Java
static T add (T a, T b) // add ?
{
   T c = new T() ;
   c.value = a.value - b.value ; // subtract !!!
   return c ;
}

/* C */
T add (T a, T b) /* add ? */
{
   T c ;
   c.value = a.value - b.value ; /* subtract !!! */
   return c ;
}

...Même dans les interfaces standard de Java

pour un autre exemple, voyons le Cloneable interface en Java:

vous êtes censé cloner l'objet implémentant cette interface. Mais tu pourrais mentir. Et créer un objet différent. En fait, cette interface est si faible que vous pourriez retourner un autre type d'objet tout à fait, juste pour le plaisir:

class MySincereHandShake implements Cloneable
{
    public Object clone()
    {
       return new MyVengefulKickInYourHead() ;
    }
}

comme l'interface Cloneable peut être abusée/ brouillée, devrait-elle être bannie pour les mêmes raisons que la surcharge de l'opérateur C++ est supposée être?

nous pourrions surcharger la méthode toString() d'une classe MyComplexNumber pour lui rendre l'heure stringifiée de la journée. La surcharge toString() devrait-elle également être interdite? On pourrait saboter MyComplexNumber.equals pour qu'il renvoie une valeur aléatoire, modifier les opérandes... etc. etc. etc..

en Java, comme en C++, ou n'importe quel langage, le programmeur doit respecter un minimum de sémantique lors de l'écriture du code. Cela signifie mettre en œuvre une fonction add qui ajoute, et Cloneable méthode de mise en œuvre qui clone, et un opérateur ++ que les incréments.

Qu'est-ce qui est troublant de toute façon?

maintenant que nous savons que le code peut être saboté même à travers le Vierge Les méthodes Java, on peut se poser des questions sur l'utilisation réelle de la surcharge de l'opérateur en C++?

Notation claire et naturelle: méthodes vs. surcharge de l'opérateur?

nous allons comparer ci-dessous, pour différents cas, le" même " code en Java et C++, pour avoir une idée du type de style de codage qui est plus clair.

comparaisons naturelles:

// C++ comparison for built-ins and user-defined types
bool    isEqual          = A == B ;
bool    isNotEqual       = A != B ;
bool    isLesser         = A <  B ;
bool    isLesserOrEqual  = A <= B ;

// Java comparison for user-defined types
boolean isEqual          = A.equals(B) ;
boolean isNotEqual       = ! A.equals(B) ;
boolean isLesser         = A.comparesTo(B) < 0 ;
boolean isLesserOrEqual  = A.comparesTo(B) <= 0 ;

veuillez noter que A et B peuvent être de n'importe quel type en C++, aussi longtemps que les surcharges de l'opérateur sont fournies. En Java, quand A et B ne sont pas primitifs, le code peut devenir très confus, même pour les objets de type primitif (BigInteger, etc.)...

tableau Naturel/conteneur des accesseurs et des subscripting:

// C++ container accessors, more natural
value        = myArray[25] ;         // subscript operator
value        = myVector[25] ;        // subscript operator
value        = myString[25] ;        // subscript operator
value        = myMap["25"] ;         // subscript operator
myArray[25]  = value ;               // subscript operator
myVector[25] = value ;               // subscript operator
myString[25] = value ;               // subscript operator
myMap["25"]  = value ;               // subscript operator

// Java container accessors, each one has its special notation
value        = myArray[25] ;         // subscript operator
value        = myVector.get(25) ;    // method get
value        = myString.charAt(25) ; // method charAt
value        = myMap.get("25") ;     // method get
myArray[25]  = value ;               // subscript operator
myVector.set(25, value) ;            // method set
myMap.put("25", value) ;             // method put

en Java, nous voyons que pour chaque conteneur à faire la même chose (accéder à son contenu par un index ou un identifiant), nous avons une façon différente de le faire, ce qui est déroutant.

En C++, chaque conteneur utilise la même manière pour accéder à son contenu, grâce à la surcharge de l'opérateur.

manipulation de types naturels avancés

Les exemples ci-dessous utilisent un Matrix objet, en utilisant les premiers liens trouvé sur Google pour " Java objet Matrix " et " c++ objet Matrix ":

// C++ YMatrix matrix implementation on CodeProject
// http://www.codeproject.com/KB/architecture/ymatrix.aspx
// A, B, C, D, E, F are Matrix objects;
E =  A * (B / 2) ;
E += (A - B) * (C + D) ;
F =  E ;                  // deep copy of the matrix

// Java JAMA matrix implementation (seriously...)
// http://math.nist.gov/javanumerics/jama/doc/
// A, B, C, D, E, F are Matrix objects;
E = A.times(B.times(0.5)) ;
E.plusEquals(A.minus(B).times(C.plus(D))) ;
F = E.copy() ;            // deep copy of the matrix

et ceci n'est pas limité aux matrices. Les BigInteger et BigDecimal les classes de Java souffrent de la même verbosité confuse, alors que leurs équivalents en C++ sont aussi clairs que les types intégrés.

Naturel itérateurs:

// C++ Random Access iterators
++it ;                  // move to the next item
--it ;                  // move to the previous item
it += 5 ;               // move to the next 5th item (random access)
value = *it ;           // gets the value of the current item
*it = 3.1415 ;          // sets the value 3.1415 to the current item
(*it).foo() ;           // call method foo() of the current item

// Java ListIterator<E> "bi-directional" iterators
value = it.next() ;     // move to the next item & return the value
value = it.previous() ; // move to the previous item & return the value
it.set(3.1415) ;        // sets the value 3.1415 to the current item

fonctions naturelles:

// C++ Functors
myFunctorObject("Hello World", 42) ;

// Java Functors ???
myFunctorObject.execute("Hello World", 42) ;

Texte de concaténation:

// C++ stream handling (with the << operator)
                    stringStream   << "Hello " << 25 << " World" ;
                    fileStream     << "Hello " << 25 << " World" ;
                    outputStream   << "Hello " << 25 << " World" ;
                    networkStream  << "Hello " << 25 << " World" ;
anythingThatOverloadsShiftOperator << "Hello " << 25 << " World" ;

// Java concatenation
myStringBuffer.append("Hello ").append(25).append(" World") ;

Ok, en Java vous pouvez aussi utiliser MyString = "Hello " + 25 + " World" ; ... Mais, attendez une seconde: C'est la surcharge d'opérateur, n'est-ce pas? N'est-il pas de la triche???

:- D

code générique?

le même code générique modifiant les opérandes doit être utilisable à la fois pour les intégrations/primitives (qui n'ont pas d'interfaces en Java), les objets standards (qui ne peuvent pas avoir la bonne interface), et les objets définis par l'utilisateur.

par exemple, calcul de la valeur moyenne de deux valeurs de types arbitraires:

// C++ primitive/advanced types
template<typename T>
T getAverage(const T & p_lhs, const T & p_rhs)
{
   return (p_lhs + p_rhs) / 2 ;
}

int     intValue     = getAverage(25, 42) ;
double  doubleValue  = getAverage(25.25, 42.42) ;
complex complexValue = getAverage(cA, cB) ; // cA, cB are complex
Matrix  matrixValue  = getAverage(mA, mB) ; // mA, mB are Matrix

// Java primitive/advanced types
// It won't really work in Java, even with generics. Sorry.

discussion sur la surcharge de l'opérateur

Maintenant que nous avons vu des comparaisons justes entre le code C++ utilisant la surcharge de l'opérateur, et le même code en Java, nous pouvons maintenant discuter de la "surcharge de l'opérateur" comme un concept.

la surcharge de L'opérateur existait depuis avant les ordinateurs

même en dehors de l'informatique, il y a surcharge de l'opérateur: par exemple, en mathématiques, les opérateurs comme + , - , * , etc. sont surchargés.

en effet, la signification de + , - , * , etc. changements selon les types d'opérandes (nombres, vecteurs, fonctions d'onde quantiques, matrices, etc.).

la plupart d'entre nous, dans le cadre de nos cours de sciences, a appris de multiples significations pour les opérateurs, selon les types d'opérandes. Les avons-nous trouvées déroutantes?

la surcharge de L'opérateur dépend de ses opérandes

C'est la partie la plus importante de la surcharge d'opérateur: Comme en mathématiques ou en physique, l'opération dépend de ses opérandes de types.

Donc, connaître le type de l'opérande, et vous permettra de savoir l'effet de l'opération.

Même C et Java ont (codé en dur) la surcharge d'opérateur

en C, le comportement réel d'un opérateur change selon ses opérandes. Par exemple, ajouter deux entiers est différent que d'ajouter deux doubles, ou même un entier et un double. Il y a même tout le domaine arithmétique pointeur (sans casting, vous pouvez ajouter à un pointeur un entier, mais vous ne pouvez pas ajouter deux pointeurs...).

en Java, il n'y a pas de pointeur arithmétique, mais quelqu'un a encore trouvé la concaténation de chaîne sans l'opérateur + serait assez ridicule pour justifier une exception dans la" surcharge de l'opérateur est mauvais " credo.

C'est juste que vous, comme un C (pour des raisons historiques) ou Java (pour raisons personnelles , voir ci-dessous) codeur, vous ne pouvez pas fournir votre propre.

en C++, la surcharge de l'opérateur n'est pas optionnelle...

en C++, la surcharge de l'opérateur pour les types intégrés n'est pas possible (et c'est une bonne chose), mais défini par l'utilisateur les types peuvent avoir défini par l'utilisateur les surcharges de l'opérateur.

As déjà dit, en C++, et au contraire de Java, les types utilisateurs ne sont pas considérés comme des citoyens de seconde classe de la langue, lorsqu'on les compare aux types intégrés. Donc, si les types intégrés ont des opérateurs, les types utilisateurs devraient pouvoir les avoir aussi.

la vérité est que, comme le toString() , clone() , equals() les méthodes sont pour Java ( i.e. quasi-standard-like ), la surcharge de l'opérateur c++ fait tellement partie de C++ qu'elle devient aussi naturel comme les opérateurs C d'origine, ou les méthodes Java mentionnées ci-dessus.

combiné avec la programmation de gabarit, la surcharge de l'opérateur devient un modèle de conception bien connu. En fait, vous ne pouvez pas aller très loin dans STL sans utiliser des opérateurs surchargés, et les opérateurs de surcharge pour votre propre classe.

...mais il ne faut pas en abuser

la surcharge d'Opérateur devrait s'efforcer de respecter la sémantique de l'opérateur. Ne pas soustrayez dans un opérateur + (comme dans "ne soustrayez pas dans une fonction add , ou "retourner la merde dans un clone méthode").

Cast surcharge peut être très dangereux car il peut conduire à des ambiguïtés. Elles devraient donc être réservées à des cas bien définis. Comme pour && et || , ne les surchargez jamais à moins que vous savez vraiment ce que vous faites, car vous perdrez l'évaluation du court-circuit que les opérateurs natifs && et || enjoy.

So... OK... Alors pourquoi ce N'est pas possible en Java?

parce que James Gosling l'a dit:

j'ai laissé tomber la surcharge de l'opérateur comme un choix assez personnel parce que j'avais vu trop de gens l'abuser en C++.

James Gosling. Source: http://www.gotw.ca/publications/c_family_interview.htm

s'il vous Plaît de comparer Gosling du texte ci-dessus avec de Stroustrup ci-dessous:

de nombreuses décisions de design C++ trouvent leur origine dans mon aversion pour le fait de forcer les gens à faire les choses d'une manière particulière [...] Souvent, j'ai été tenté de proscrire une fonctionnalité que je n'aimais pas personnellement, je me suis abstenu de le faire parce que Je ne pensais pas avoir le droit pour forcer mes vues sur les autres .

Bjarne Stroustrup. Source: La Conception et l'Évolution de C++ (1.3 Contexte Général)

la surcharge de l'opérateur profiterait-elle à Java?

Certains objets bénéficieraient grandement de la surcharge de l'opérateur (béton ou types numériques, comme BigDecimal, nombres complexes, matrices, conteneurs, itérateurs, comparateurs, parsers, etc.).

en C++, vous pouvez profiter de cet avantage en raison de L'humilité de Stroustrup. En Java, vous êtes tout simplement foutu à cause du de Gosling "choix personnel .

pourrait-il être ajouté à Java?

les raisons pour ne pas ajouter la surcharge des opérateurs maintenant en Java pourraient être un mélange de politique interne, d'allergie à la fonctionnalité, de méfiance envers les développeurs (vous savez, les saboteurs qui semblent hanter les équipes Java...), compatibilité avec les JVM précédentes, délai pour rédiger une spécification correcte, etc..

Alors ne retenez pas votre souffle en attendant cette fonctionnalité...

mais ils le font en C#!!!

Oui...

Alors que c'est loin d'être la seule différence entre les deux langages, celui-ci ne manque jamais de m'amuser.

apparemment, les c # folks, avec leur " chaque primitif est un struct , et un struct dérive de l'Objet" , a droit à la première tentative.

Et ils le font dans autres langues !!!

malgré tout le FUD contre la surcharge de l'opérateur défini utilisé, les langues suivantes le supportent: Scala , Dart , Python , F# , C# , D , Algol 68 , Smalltalk , Groovy , Perl 6 , C++, Ruby , Haskell , Matlab , Eiffel , Lua , Clojure , Fortran 90 , Swift , Ada , Delphi 2005 ...

tant de langues, avec tant de philosophies différentes (et parfois opposées), et pourtant ils sont tous d'accord sur ce point.

de la Nourriture pour la pensée...

James Gosling compared designing Java to the following:

" il y a ce principe sur le déménagement, quand vous vous déplacez d'un appartement à un autre appartement. Une expérience intéressante est d'emballer votre appartement et de tout mettre dans des boîtes, puis de se déplacer dans l'appartement d'à côté et de ne rien déballer jusqu'à ce que vous en avez besoin. Donc tu fais ton premier repas, et tu sors quelque chose d'une boîte. Puis au bout d'un mois ou si vous avez utilisé que pour la jolie beaucoup de comprendre quelles choses dans votre vie vous avez réellement besoin, et puis vous prenez le reste des choses -- oublier à quel point vous l'aimez ou à quel point il est cool -- et vous le jeter. C'est incroyable comment cela simplifie votre vie, et vous pouvez utiliser ce principe dans toutes sortes de problèmes de design: ne pas faire des choses juste parce qu'elles sont cool ou juste parce qu'elles sont intéressantes."

vous pouvez lire le contexte de la citation Ici

essentiellement la surcharge de l'opérateur est grand pour une classe qui Modèles une sorte de point, monnaie ou nombre complexe. Mais après que vous commencez à manquer d'exemples rapides.

un autre facteur était l'abus de la fonctionnalité en C++ par les développeurs surcharger les opérateurs comme '&&', '||', les acteurs et bien sûr "Nouveau". La complexité résultant de la combinaison de cela avec la valeur de passage et les exceptions est bien couverte dans le C++ exceptionnel livre.

découvrez Boost.Unités: texte du lien

il fournit l'analyse dimensionnelle sans frais généraux par la surcharge de l'opérateur. Comment beaucoup plus claire, cela peut-il obtenir?

quantity<force>     F = 2.0*newton;
quantity<length>    dx = 2.0*meter;
quantity<energy>    E = F * dx;
std::cout << "Energy = " << E << endl;

produirait effectivement "énergie = 4 J" ce qui est correct.

les concepteurs de Java ont décidé que la surcharge de l'opérateur était plus de problèmes qu'elle n'en valait la peine. Simple que cela.

dans un langage où chaque variable objet est en fait une référence, la surcharge de l'opérateur comporte le risque supplémentaire d'être tout à fait illogique - à un programmeur C++ au moins. Comparez la situation avec C# 'S = = surcharge de l'opérateur et Object.Equals et Object.ReferenceEquals (ou peu importe son nom).

Groovy a la surcharge de l'opérateur, et fonctionne dans la JVM. Si vous ne vous opposez pas à la performance hit (qui devient plus petit tous les jours). C'est automatique basé sur les noms de méthode. par exemple, ' + ' appelle la méthode 'plus(argument)'.

je pense que cela a pu être un choix de conception conscient pour forcer les développeurs à créer des fonctions dont les noms communiquent clairement leurs intentions. En C++, les développeurs surchargeraient les opérateurs avec des fonctionnalités qui n'auraient souvent aucun rapport avec la nature communément acceptée de l'opérateur donné, ce qui rend presque impossible de déterminer ce qu'un morceau de code fait sans regarder la définition de l'opérateur.

Eh bien, vous pouvez vraiment vous tirer dans le pied avec la surcharge opérateur. C'est comme avec des pointeurs les gens font des erreurs stupides avec eux et donc il a été décidé d'enlever les ciseaux.

Au moins, je pense que c'est la raison. Je suis de ton côté de toute façon. :)

dire que la surcharge de l'opérateur conduit à des erreurs logiques de type que l'opérateur ne correspond pas à la logique d'opération, c'est comme ne rien dire. Le même type d'erreur se produira si le nom de la fonction n'est pas approprié pour la logique d'opération - alors quelle est la solution: laisser tomber la capacité d'utilisation de la fonction!? C'est une réponse Comique - "inapproprié pour la logique d'opération", chaque nom de paramètre, chaque classe, fonction ou quoi que ce soit qui peut être logiquement inapproprié. Je pense que cette option devrait être disponible dans un langage de programmation respectable, et ceux qui pensent que c'est dangereux - Hey aucun bothy dit que vous devez l'utiliser. Prenons le C#. Ils ont fait tomber les pointeurs mais hé - il y a une déclaration de "code dangereux" - programme comme vous le souhaitez sur votre propre risque.

techniquement, il y a surcharge de l'opérateur dans chaque langage de programmation qui peut traiter avec différents types de nombres, par exemple nombres entiers et réels. Explication: le terme surcharge signifie qu'il y a simplement plusieurs implémentations pour une fonction. Dans la plupart des langages de programmation, différentes implémentations sont fournies pour l'opérateur+, une pour les entiers, une pour les réals, cela s'appelle la surcharge de l'opérateur.

maintenant, beaucoup de gens trouvent étrange que Java a la surcharge de l'opérateur pour l'opérateur + pour ajouter des chaînes ensemble, et d'un point de vue mathématique ce serait étrange en effet, mais vu du point de vue du développeur d'un langage de programmation, il n'y a rien de mal à ajouter la surcharge de l'opérateur intégré pour l'opérateur + pour d'autres classes par exemple String. Cependant, la plupart des gens s'accordent à dire qu'une fois que vous ajoutez la surcharge de builtin pour + For String, alors c'est généralement une bonne idée de fournir cette fonctionnalité pour le développeur aussi.

n'est pas du tout d'accord avec l'idée fallacieuse que la surcharge de l'opérateur obstrue le code, car c'est au développeur de décider. C'est naïf de penser, et pour être honnête, ça devient vieux.

+1 pour ajouter la surcharge de l'opérateur en Java 8.

certains disent que la surcharge de l'opérateur en Java conduirait à l'obsfuscation. Est-ce que ces gens ont déjà arrêté de regarder du code Java en faisant des maths de base comme augmenter une valeur financière d'un pourcentage en utilisant BigDecimal ? .... la verbosité d'un tel exercice devient sa propre démonstration d'obsfuscation. Ironiquement, l'ajout de la surcharge de l'opérateur à Java nous permettrait de créer notre propre classe de monnaie qui rendrait un tel code mathématique élégant et simple (moins obsfusated).

en supposant que Java soit le langage de mise en œuvre alors a, b, et c seraient toutes des références au type complexe avec les valeurs initiales de null. Aussi en supposant que le complexe est immuable comme le mentionné BigInteger et similaire immuable BigDecimal , je pense que vous voulez dire ce qui suit, comme vous assignez la référence au complexe retourné de l'ajout b et c, et de ne pas comparer cette référence à A.

N'est pas:

Complex a, b, c; a = b + c;

beaucoup plus simple que:

Complex a, b, c; a = b.add(c);

parfois, il serait agréable d'avoir la surcharge de l'opérateur, les classes d'amis et l'héritage multiple.

Cependant, je pense toujours que c'était une bonne décision. Si Java avait eu la surcharge de l'opérateur, alors nous ne pourrions jamais être sûrs des significations de l'opérateur sans regarder à travers le code source. À l'heure actuelle ce n'est pas nécessaire. Et je pense que votre exemple d'utilisation de méthodes au lieu de surcharger l'opérateur est également très lisible. Si vous voulez clarifier les choses, vous pourriez: toujours ajouter un commentaire au-dessus des déclarations poilues.

// a = b + c
Complex a, b, c; a = b.add(c);

Ce n'est pas une bonne raison pour les interdire, mais d'une pratique:

les gens ne l'utilisent pas toujours de façon responsable. Regardez cet exemple de la bibliothèque Python scapy:

>>> IP()
<IP |>
>>> IP()/TCP()
<IP frag=0 proto=TCP |<TCP |>>
>>> Ether()/IP()/TCP()
<Ether type=0x800 |<IP frag=0 proto=TCP |<TCP |>>>
>>> IP()/TCP()/"GET / HTTP/1.0\r\n\r\n"
<IP frag=0 proto=TCP |<TCP |<Raw load='GET / HTTP/1.0\r\n\r\n' |>>>
>>> Ether()/IP()/IP()/UDP()
<Ether type=0x800 |<IP frag=0 proto=IP |<IP frag=0 proto=UDP |<UDP |>>>>
>>> IP(proto=55)/TCP()
<IP frag=0 proto=55 |<TCP |>>

Voici l'explication:

l'opérateur / a été utilisé comme opérateur de composition entre deux couche. Ce faisant, la couche inférieure peut avoir un ou plusieurs de ses valeurs par défaut des champs surchargés selon la valeur supérieure couche. (Vous avez encore peut donner la valeur que vous voulez). Une corde peut être utilisée comme couche brute.

Alternatives à la prise en charge Native de Java Surcharge d'Opérateur

comme Java n'a pas de surcharge de l'opérateur, voici quelques alternatives que vous pouvez consulter:

1. utilisez une autre langue. Les deux Groovy et Scala ont la surcharge de l'opérateur, et sont basés sur Java.
2. utiliser java-oo , un plugin qui permet surcharge de L'opérateur en Java. Notez qu'il n'est pas indépendant de la plateforme. En outre, il a de nombreux problèmes, et n'est pas compatible avec les dernières versions de Java (i.e. Java 10). ( Original StackOverflow Source )
3. Utiliser JNI , Java Native Interface, ou des solutions de rechange. Cela vous permet d'écrire C ou C++ (peut-être d'autres?) méthodes D'utilisation en Java. Bien sûr, cela n'est PAS indépendant de la plateforme.

si quelqu'un connaît d'autres personnes, veuillez commenter, et je l'ajouterai à cette liste.