La plaga Tux

Última actualización 16/07/2009

Buscando solución a un raro problema que me ha surgido programando, he encontrado por casualidad esta curiosa Web (en inglés) donde se nos dan algunos consejos para optimizar todo lo posible nuestro código escrito en C o C++. Aquí os dejo algunas de las optimizaciones que aparecen:

• Realizar la inicialización de variables mediante las listas de constructores. De esta forma inicializamos las variables miembro de la clase directamente. En caso de no utilizar las listas de los constructores, las variables miembro de la clase se declaran y se inicializan con un valor aleatorio.

//De esta forma m_Data se declara e inicializa al mismo tiempo
TMyClass::TMyClass(const TData &data) : m_Data(data)
{
}
// En vez de ...
TMyClass::TMyClass(const TData &data)
{
  //Antes de ejecutar esta instrucción m_Data está declarada e inicializada con algún valor aleatorio
  m_Data = data;
}

• Realizar bucles for siempre que se pueda con cuenta descendente, ya que al realizar la transformación a lenguaje máquina las operaciones de decremento y comparación con 0 son más rápidas. Sin embargo, no se debe aplicar esta recomendación cuando estamos trabajando con acceso a memoria, ya que dicho caso es mejor recorrer un vector, o matriz de forma natural.

for (i = n-1; i >= 0; --i)
//En vez de ...
for (i = 0; i < n; ++i)

• Usar int en vez de char o short, ya que es el tipo de dato por defecto en las máquina. C y C++ realizan operaciones aritméticas y el paso de parámetros a nivel de enteros, aún teniendo un número entero que puede entrar en un byte, deberías seguir considerando usar un int para almacenar el número. Si usas una char, el compilador primero convertirá los valores a enteros, realizará las operaciones y después volverá a convertir el resultado en char.
• Declarar siempre que se pueda las funciones locales como estáticas (static).

static void foo()

• Optimizar las sentencias switch poniendo en primer lugar los casos más habituales.
• Inicializar variables en sus declaraciones.
• Evitar las operaciones costosas. Una operación aritmética de suma es más eficiente que una de multiplicación, y a su vez una multiplicación es más eficiente que una división. Además si queremos elevar números al cuadrado podemos realizar la multiplicación del número por si mismo y nos evitamos tener que hacer una llamada a función.
• Siempre que sea posible usar los operadores de asignación aritmética. Por ejemplo usar

  x += value;
  

  En vez de

  x = x + value;
  

  Ya que así nos evitamos tener que crear un objeto temporal.

• Declarar las funciones de pocas líneas de código como inline. Esto hace que el compilador duplique el cuerpo de dichas funciones en el lugar donde son llamadas.
• Cuando trabajamos con arrays de estructuras, el compilador realiza una multiplicación del tamaño de la estructura para realizar el indexado del array. Si el tamaño de la estructura es una potencia de 2, la costosa operación de multiplicación puede ser reemplazada por una operación sencilla de desplazamiento de bits. Por lo tanto, si mantenemos los tamaños de las estructuras como potencias de 2, mejoraremos el rendimiento en el indexado de los arrays.
• Minimizar el número de variables locales. Si el número de variables locales en una función es menor, el compilador será capaz de ajustarlas en registros. De hecho, evitará las operaciones con punteros relacionadas con la pila. Esto puede resultar en una considerable mejora debido a dos razones:
  • Todas las variables locales están en registro y por lo tanto se mejora el rendimiento sobre el acceso a ellas en memoria.
  • Si no se necesitan salvar variables locales en la pila, el compilador no incurrirá en el establecimiento y restauración del puntero a la cabeza de la pila.
• Reducción del número de parámetros. Las llamadas a funciones con un número grande de argumentos pueden ser costosas debido a que puede que muchos de dichos parámetros se pasen a la pila en cada llamada. Por la misma razón, se debe evitar pasar estructuras completas como parámetros. Se debe usar punteros y referencias en dichos casos.
• En la medida de lo posible, mantener los constructores de los objetos ligeros, ya que el constructor será invocado en cada creación de una instancia de objeto. Ten en cuenta también que muchas veces el compilador podrá crear objetos temporales sobre las creaciones explícitas de objetos en tus programas. Por lo tanto, optimizando los constructores puedes obtener una valiosa ganancia en rendimiento.

Referencias:

• http://www.eventhelix.com/realtimemantra/basics/optimizingcandcppcode.htm
• http://www.custard.org/~andrew/optimize.php