Memory Leak en código

[yeray_pg]

Hola, mi problema es que tengo un código en C++ y he pasado el Valgrind para si habia memory leaks y efectivamente hay, lo que no sé es encontrarlos. SI me pudierais hechar una manita os lo agredeceria.

http://pastebin.com/ajsuZjKq es el código del main
http://pastebin.com/TFWCt8ah es el código del source

A continuación os dejo el mensaje del Valgrind:

==2722== 252 (144 direct, 108 indirect) bytes in 9 blocks are definitely lost in loss record 2 of 2
==2722== at 0x4C2AB80: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==2722== by 0x4011C7: sub(vector*, vector*) (in /home/yeray/Escritorio/164324_164376/p1)
==2722== by 0x40155E: distance(vector*, vector*) (in /home/yeray/Escritorio/164324_164376/p1)
==2722== by 0x401BCB: determinar_operacion(char*, vector**) (in /home/yeray/Escritorio/164324_164376/p1)
==2722== by 0x401DB0: main (in /home/yeray/Escritorio/164324_164376/p1)

Muchas gracias

[do-while]

¡Buenas!

La verdad es que bucear en un código ajeno es una locura.

Veo cosas raras como esta:

Código (c) [Seleccionar] Expandir


vector* create_vector( int n, float* data ) {
       vector* v;
       v = (vector*) malloc(sizeof( vector )); //creamos un puntero a una instancia del struct        
       v->data = data;                                        
       v->dim = n;                                     //inicializamos dim de v, numero de posiciones
       return v;                                       //devolvemos v
}

//...
void destroy_vector( vector* v ) {
       free( v->data );
       free( v );              //desalojamos la memoria reservada
     
}


A los datos les estás asignando un vector ajeno a la estructura, pero luego intentas liberar la memoria dentro de la propia estructura. La verdad es que no es coherente. Si el vector de datos es un vector exterior a la estructura, libera su memoria fuera de la estructura, o lo que me parece más lógico, crea dentro de la estructura de datos la memoria suficiente para almacenar los datos del vector que pasas en el "constructor" y luego copias su contenido en la memoria que acabas de reservar. Así tienes localizada cualquier asignación dinámica de memoria dentro de la propia estructura de datos y todo está más claro.

La cosa quedaría algo así:

Código (c) [Seleccionar] Expandir


vector* create_vector( int n, float* data ) {
       vector* v;
       v = (vector*) malloc(sizeof( vector )); //creamos un puntero a una instancia del struct
       v->data = (float*) malloc(n * sizeof(float));
       memcpy(v->data, data, n * sizeof(float));
       v->dim = n;                                     //inicializamos dim de v, numero de posiciones
       return v;                                       //devolvemos v
}


Luego, si el parámetro data que recibe esta función ha sido creado utilizando memoria dinámica, la liberas cuando esa variable no te haga mas falta o antes de que salga de su ámbito.

Si ordenas bien las ideas y el código te ahorraras bastantes quebraderos de cabeza. Revisa bien el código viendo donde asignas memoria y comprobando que liberas toda la que asignas.

¡Saludos!

PD: Te dejo un código un poco más claro para una de las funciones:

Código (c) [Seleccionar] Expandir


int contarcomas(char* cadena){
       int j = 1;                            //inicializando en 1 nos ahorramos contar el primer carácter que es un [
       int c = 1;                            // numero de comas                                  
       while(cadena[j] != ']'){              //contar comas
               if(cadena[j++] == ','){ //Siempre hay que incrementar j. Lo hacemos directamente aquí.
                       c++;
               }
       }
       return c;
}


¡Saludos!