C # que fait l'opérateur == en détail?

StackOverflow https://stackoverflow.com/questions/806020

Question

en c # que se passe-t-il exactement en arrière-plan lorsque vous faites une comparaison avec " == " opérateur sur deux objets? Est-ce juste comparer les adresses? ou est-ce quelque chose comme Equals () ou CompareTo ()?

PS: qu’en est-il de la " == " opérateur en java? se comporte-t-il de la même manière?

Était-ce utile?

La solution

Pour autant que je sache:

  • il compare les types de valeur par valeur (égalité)
  • il compare les types de référence par référence (identité)
  • sauf si l'opérateur == est surchargé, il appelle celui-là.

Equals est implémenté dans un objet et peut également être remplacé. L'implémentation par défaut dans Object effectue une comparaison de référence pour les types de référence. Donc, par défaut, Equals et == font la même chose.

Je pense qu'en Java, vous ne pouvez pas surcharger l'opérateur ==. Mais ma connaissance de Java est plutôt dépassée.

Modifier: Notez que l'opérateur == est une méthode statique. Il est lié au moment de la compilation, en fonction des types de vos variables ou de vos champs. Equals est une méthode virtuelle trouvée au moment de l'exécution, basée sur les types d'exécution réels.

Autres conseils

Comme extension de excellente réponse de Stefan - une autre exception concerne les opérandes impliquant Nullable<T> - auquel cas & "levé &"; opérateurs appliquent (14.2.7 dans ECMA 334v4):

  

Pour les opérateurs d'égalité   ==! =

     

une forme levée d'opérateur existe si les types d'opérande sont à la fois   types de valeur non nullables et si le   le type de résultat est bool. La forme levée   est construit en ajoutant un single?   modificateur pour chaque type d'opérande. le   opérateur levé considère deux null   des valeurs égales et une valeur nulle inégale   à toute valeur non nulle. Si les deux   les opérandes sont non nuls, les levées   l'opérateur déballe les opérandes et   applique l'opérateur sous-jacent à   produire le résultat bool.

Cela signifie: car il existe un opérateur d'égalité entre (par exemple): 

int i = ..., j = ...;
bool eq = i == j;

Il existe donc un opérateur implicite de la forme (bien que cela soit fait différemment): 

int? i = ..., j = ...;
bool eq;
if(i.HasValue) {
    if(j.HasValue) { // both have values; compare
       eq = i.GetValueOrDefault() == j.GetValueOrDefault();
    } else { // one null; always false
       eq = false;
    }
} else { // true if both null, else false
    eq = !j.HasValue;
}

à partir de MSDN :

  

Pour les types de valeur prédéfinis, le   L'opérateur d'égalité (==) renvoie vrai si   les valeurs de ses opérandes sont égales,   faux sinon. Pour les types de référence   autre que chaîne, == renvoie true si   ses deux opérandes se réfèrent au même   objet. Pour le type de chaîne, ==   compare les valeurs des chaînes.

Non ... l'opérateur == ne se comporte pas toujours de la même manière en java et en c #.

Par exemple avec Strings; Java == compare les références des objets chaîne ... (si vous utilisez des types primitifs, == en java compare les valeurs). Voilà pourquoi 

// returns FALSE in JAVA
(new String("test") == "test")

ne retournera pas true en java ...

En C # en revanche, l'opérateur == se comporte différemment sur les chaînes. Par exemple, il retournera true dans le cas suivant: 

// returns TRUE in C#
(new String("test".ToCharArray()) == "test")

Le comportement de l'opérateur == dépend de la déclaration de la variable à laquelle vous l'appliquez (pas de la classe de l'objet, je vais ajouter un exemple).

Pour les types de valeur, il comparera leurs valeurs.

Pour les types de référence a == b renvoie true si a est le même objet que b, sauf si l'opérateur == a été surchargé. Pas redéfini comme d'autres l'ont dit, vous ne pouvez pas remplacer les opérateurs en c # car ils ne sont pas virtuels.

            objet obj_a, obj_b;             chaîne str_a, str_b; 

        str_a = "ABC";
        str_b = new string("ABC".ToCharArray());
        obj_a = str_a;
        obj_b = str_b;

        Console.WriteLine("str_a == str_b = {0}", str_a == str_b); // in string == operator is overloaded
        Console.WriteLine("str_a.Equals(str_b) = {0}", str_a.Equals(str_b)); // string overrides Object.Euqals
        Console.WriteLine("obj_a == obj_b = {0}", obj_a == obj_b); // in object == operator is not overloaded
        Console.WriteLine("obj_a.Equals(obj_b) = {0}", obj_a.Equals(obj_b)); // Object.Equesl is virtual and overridden method from string will be executed.
        Console.ReadKey();

Le résultat de ce programme est 

str_a == str_b = True
str_a.Equals(str_b) = True
obj_a == obj_b = False
obj_a.Equals(obj_b) = True
Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top