jueves, 04 de octubre de 2007 22:05
jonas
Errores comunes al programar (II de II)
Siguiendo en la linea del post anterior, vamos a comentar dos de los puntos que fueron mencionados, los problemas con operaciones aritméticas y de comparación que, aunque de conocimiento básico no viene nada mal recordar.
- Operaciones aritméticas. Supongamos que tenemos un determinado objeto, como pueda ser una imagen, que tiene dimensiones (ancho y alto) y que queremos redimensionarla de tal forma que necesitamos obtener los porcentajes en que se redimensionan para el ancho (width) y alto (height), pues basta con dividir las nuevas dimensiones por las originales:
//valores de
ejemplo
int
widthOrigen = 2698;
int
heightOrigen = 1780;
int width =
1024;
int height =
768;
float
porcentajeW, porcentajeH;
porcentajeW = (width /
widthOrigen);
porcentajeH
= (height / heightOrigen);
pero este código no es del todo correcto porque lo que se produce es una división de enteros, por lo que el resultado será un entero aunque luego lo almacenemos en un float, para que el resultado de la división sea correcto bastaría con hacer un casting de uno de los operandos, posteriormente el compilador "promociona" el valor de menor precisión al del tipo de mayor precisión, es decir, de int a float:
porcentajeW = (width / (float)widthOrigen);
porcentajeH
= (height / (float)heightOrigen);
- Operaciones de comparación. Esto es algo básico en la programación orientada a objetos, si intentamos comparar dos objetos con el operador de comparación (==) pues no obtendremos el resultado deseado porque lo que hacemos es comparar sus referencias a memoria, solo es válido para los tipos básicos(int, float, string...). Para comparar objetos podemos y/o debemos usar el método Equals(object obj), pero no basta con hacer una llamada a este método, pues obtendríamos el mismo resultado que al usar el operador de comparación. Este método pertenece a la clase object y debe ser sobrescrito en nuestras clases para que compare dos objetos de forma correcta. Supongamos que tenemos una clase llamada Complejo como la siguiente:
public class Complejo
{
public int a;
public int b;
public Complejo(int
a, int b)
{
this.a = a;
this.b = b;
}
//...
public override bool Equals(object
obj)
{
try
{
Complejo
aux = (Complejo)obj;
if (this.a == aux.a)
if (this.b == aux.b)
return true;
}
catch (InvalidCastException)
{
// es un
objeto de otro tipo
}
return false;
}
}
Podemos destacar el método Equals(object obj), que no tiene ninguna complejidad, el cual se encarga de sobrescribir la forma predeterminada de comparar dos objetos de tipo Complejo. Al compilar, obtendremos una advertencia por no sobrescribir el método GetHashCode() así que o lo sobrescribís o pasáis de la advertencia. Por último y para ver la diferencia entre una simple comparación y el método Equals() lo mejor es verlo con un ejemplo:
Complejo c1 = new Complejo(2,
5);
Complejo c2 = new Complejo(2,
5);
Complejo c3 = c1;
Console.WriteLine("c1 = c2: " + (c1 == c2));
Console.WriteLine("c1 = c3: " + (c1 == c3));
Console.WriteLine("c2 = c3: " + (c2 == c3));
Console.WriteLine("c1.Equals(c2): " + c1.Equals(c2));
Console.WriteLine("c1.Equals(c3): " + c1.Equals(c3));
Console.WriteLine("c2.Equals(c3): " + c2.Equals(c3));
c3.a = 7;
Console.WriteLine("c1 = c2: " + (c1 == c2));
Console.WriteLine("c1 = c3: " + (c1 == c3));
Console.WriteLine("c2 = c3: " + (c2 == c3));
Console.WriteLine("c1.Equals(c2): " + c1.Equals(c2));
Console.WriteLine("c1.Equals(c3): " + c1.Equals(c3));
Console.WriteLine("c2.Equals(c3): " + c2.Equals(c3));
¿Cuál es el resultado?