De acuerdo con la documentación del ==
operador en MSDN ,
Para los tipos de valores predefinidos, el operador de igualdad (==) devuelve verdadero si los valores de sus operandos son iguales, de lo contrario, falso. Para los tipos de referencia que no sean cadenas, == devuelve verdadero si sus dos operandos se refieren al mismo objeto. Para el tipo de cadena, == compara los valores de las cadenas. Los tipos de valores definidos por el usuario pueden sobrecargar el operador == (ver operador). También pueden los tipos de referencia definidos por el usuario, aunque por defecto == se comporta como se describe anteriormente para los tipos de referencia predefinidos y definidos por el usuario.
Entonces, ¿por qué este fragmento de código no se compila?
bool Compare<T>(T x, T y) { return x == y; }
Me sale el error Operador '==' no se puede aplicar a operandos de tipo 'T' y 'T' . Me pregunto por qué, ya que entiendo que el ==
operador está predefinido para todos los tipos.
Editar: Gracias a todos. Al principio no me di cuenta de que la declaración se refería solo a los tipos de referencia. También pensé que se proporciona una comparación bit a bit para todos los tipos de valores, lo que ahora sé que no es correcto.
Pero, en caso de que esté usando un tipo de referencia, ¿usaría el ==
operador la comparación de referencia predefinida, o usaría la versión sobrecargada del operador si un tipo definiera uno?
Edición 2: a través de prueba y error, aprendimos que el ==
operador usará la comparación de referencia predefinida cuando use un tipo genérico sin restricciones. En realidad, el compilador utilizará el mejor método que pueda encontrar para el argumento de tipo restringido, pero no buscará más. Por ejemplo, el siguiente código siempre se imprimirá true
, incluso cuando Test.test<B>(new B(), new B())
se llama:
class A { public static bool operator==(A x, A y) { return true; } }
class B : A { public static bool operator==(B x, B y) { return false; } }
class Test { void test<T>(T a, T b) where T : A { Console.WriteLine(a == b); } }
==
no está permitido entre dos operandos del mismo tipo. Esto es cierto para los struct
tipos (excepto los tipos "predefinidos") que no sobrecargan el operator ==
. Como ejemplo simple, intente esto:var map = typeof(string).GetInterfaceMap(typeof(ICloneable)); Console.WriteLine(map == map); /* compile-time error */
var kvp1 = new KeyValuePair<int, int>(); var kvp2 = kvp1;
, entonces no puede verificar kvp1 == kvp2
porque KeyValuePair<,>
es una estructura, no es un tipo predefinido de C # y no sobrecarga el operator ==
. Sin embargo, se proporciona un ejemplo var li = new List<int>(); var e1 = li.GetEnumerator(); var e2 = e1;
con el que no puede hacerlo e1 == e2
(aquí tenemos la estructura anidada List<>.Enumerator
(llamada "List`1+Enumerator[T]"
por el tiempo de ejecución) que no se sobrecarga ==
).
bool
de void
...