Corrupción de memoria? La solución es

Esto será una entrada corta. Programando en C uno no puede menos que pensar que en algún momento los punteros, allocs y por supuesto los arreglos no funcionarán como uno espera. Pero encontrar estos errores entre míles de líneas de código definitivamente no es algo agradabale, claro. sin la ayuda de buenas herramientas.
Programando Tuxhistory me encontré con una muy desagradable sorpresa, un fallo de segmentación que se daba en los lugares mas diversos. Parecería como si hubiera una sinfín de ellos esparcidos por tódo el código. El debugging simple no daba con el responsable, gdb arrojaba lugares exactos donde sedaban, pero nada parecía estar mal, hasta que, gdb señaló al culpable a glib, malloc, etc... Esto no parecía ser más que una corrupción grave de memoria.
Por suerte logré encontrar el fabuloso VALGRIND! Wow! Una estupenda herramienta para poder identificar el verdadero orígen del problema y analizar las errores de escritura, lectura, corrupcion y leaks de memoria. Logré descubrir que el verdadero problema se encontraba en un arreglo que se debordaba con el paso del tiempo y corrompía la memoria aledaña. En verdad, si se encuentran en una situación como esta, les recomiendo ampliamente usar Valgrind http://valgrind.org/ y su excelente documentación: http://valgrind.org/docs/manual/manual.html
Y lo mejor es LIBRE bajo GPL!

Arreglos dinámicos multidimensionales en C

En muchas ocaciones no queremos crear un arreglo que se utilice sólo la menoria necesaria en tiempo de ejecución. Sin embargo no resulta tan claro crear este tipo de arreglos de forma dinámica. Peor aún, si creamos un arreglo dentro de una función y queremos revolver el valor de un arreglo estatico esto sería imposible, ya que como es una variable local de la función se elimina antes de poder pasar el valor. Por lo tanto incluyo este pequeño código para poder realizar estas funciones.

#include <stdlib.h>
#define FREE(p)   do { free(p); (p) = NULL; } while(0)

int **alloc_array(int, int);
void free_array(int **, int);

int **alloc_array(int x_size, int y_size)
{
   int i;
   int **array;
   array = malloc(x_size * sizeof(int *));
   if(array == NULL)
   {
 return NULL;
   }
   for(i = 0; i < x_size; i++)
   {
       array[i] = malloc(y_size * sizeof(int));
       if(array[i] == NULL)
       {
           return NULL;
       }
   }
   return array;
}

void free_array(int **array, int x_size)
{
   int i;
   for(i = 0; i < x_size; i++)
      FREE(array[i]);
   FREE(array);
}

Como vemos, tambien es necesario liberar la memoria que hemos reservado para nuestra memoria. Es necesario hacer esto para cada una de las variables y a su vez referenciar todos los punteros a NULL.