Programa C tocante a punteros, problemas asignacion memoria

Hola a todos otra vez, vuelvo a estar encallado con C, ahora mas concretamente en la practica final de una de las asignaturas de mi universidad, la practica es complicada de explicar, pero ahora toco posiciones en memoria y tal, no se porque, tengo un array dinamico de tipo int, osea (int * del cual voy aumentando su espacio con un malloc) y no se porque, cuando acabo la iteracion en la que lleno este array de numeros, luego cuando intento imprimir los valores, me salen ceros, cuando dentro mismo de la iteracion justo despues de asignar el numero, imprimo el valor y me sale.

El codigo de la iteracion en cuestion es:

for (recorre_estructura = 0; strlen(struc6[recorre_estructura].grupo_letras) !=0; recorre_estructura++)
   {
      recorre_cifrado = 0;
      struc6[recorre_estructura].veces_grupo = 0;
      
      for (pos_inicial = struc6[recorre_estructura].distancia_inicial /*0*/ ; texto_cifrado[recorre_cifrado] != '\0'; pos_inicial++)
      {
         for (recorre_cifrado = pos_inicial; (recorre_cifrado <= (pos_inicial + 5)) && (texto_cifrado[recorre_cifrado]) != '\0'; recorre_cifrado++)
         {
            //Vamos rellenando los valores en nuestro grupo de caracteres temporal
            if (recorre_cifrado < (pos_inicial + 5))
            {
               grupo_6[asigna_matriz] = texto_cifrado[recorre_cifrado];
               asigna_matriz++;
            }
            
            //Una vez llena la estructura, compararemos esa cadena con la cadena de la estructura previamente asignada         
            if (recorre_cifrado == (pos_inicial + 5))
            {
               grupo_6[asigna_matriz] = texto_cifrado[recorre_cifrado];
               asigna_matriz++;
               grupo_6[asigna_matriz] = '\0';
               
               //Comparamos las cadenas...
               cadenas_iguales = strcmp(struc6[recorre_estructura].grupo_letras, grupo_6);
               
               //Si son iguales
               if (cadenas_iguales == 0)
               {
                  struc6[recorre_estructura].veces_grupo++;
                  
                  //Como el primer grupo que encuentre, sera a si mismo, y por lo tanto la distancia sera 0, empezaremos a trabajar con las distancias a partir de cada segunda coincidencia.
                  if (struc6[recorre_estructura].veces_grupo > 1)
                  {
                     //Reservamos espacio para mi array de numeros a medida que vayamos encontrando
                     mis_distancias.distancias =(int *) malloc((pos_distancia + 1) * sizeof(int));
                     
                     //Asignamos la distancias
                     mis_distancias.distancias[pos_distancia] = recorre_cifrado - 5 - struc6[recorre_estructura].distancia_inicial;
                     
                     //Asignaremos a un segundo campo de la estructura cuantas distancias nos encontramos.
                     mis_distancias.numero_distancias = pos_distancia;
                     
                     //Impersion de prueba de los distintos valores que nos encuentra
                     printf("Cadena %s Distancia no %d valor distancia: %d\n",grupo_6, pos_distancia, mis_distancias.distancias[pos_distancia]);

                     pos_distancia++;
                  }
               
               }
                  
               asigna_matriz = 0;
               
            }
         }
      }
   }
   
   
   
   printf("%d", mis_distancias.numero_distancias);
   
   for (recorre_estructura = 0; recorre_estructura < mis_distancias.numero_distancias; recorre_estructura++)
   {
      printf ("%d", mis_distancias.distancias[recorre_estructura]);
   }


En el primer printf me salen los numeros bien, en el segundo no.

Subo tambien el codigo si lo quereis mirar con profundidad.

Alguna idea?

Gracias
Cada vez que llamas a malloc se crea memoria de nuevo, queandose la anterior perdida. Solo debes crear el vector 1 vez.
Y hacer realloc? Osea, yo lo que quiero hacer es que cada vez que encuentro una coincidencia, el vector se vaya haciendo mas grande conforme yo necesite asignarle valores.
Jeil escribió:Y hacer realloc? Osea, yo lo que quiero hacer es que cada vez que encuentro una coincidencia, el vector se vaya haciendo mas grande conforme yo necesite asignarle valores.


Si, realloc es lo que tu quieres hacer, aunque no es muy eficiente.
Que me aconsejas que haga entonces? Por cierto, ahora en los reallocs que hago me imprime bien los valores fuera de la iteracion, esta iteracion esta en una funcion a la cual yo le paso un char * por parametro que es la direccion de memoria a la que yo apunto para llenar los valores, el caso es que despues de llamar a la funcion si quiero imprimir los valores dentro del main no me imprime nada, o me imprime cosas raras. Alguna idea?
Jeil escribió:Que me aconsejas que haga entonces? Por cierto, ahora en los reallocs que hago me imprime bien los valores fuera de la iteracion, esta iteracion esta en una funcion a la cual yo le paso un char * por parametro que es la direccion de memoria a la que yo apunto para llenar los valores, el caso es que despues de llamar a la funcion si quiero imprimir los valores dentro del main no me imprime nada, o me imprime cosas raras. Alguna idea?


Éste foro no es lugar para preguntas básicas de este tipo, cuando entre el moderador te cerrará el hilo, pero como me has caído bien te voy a ayudar.

malloc, realloc y calloc devuelven una dirección de memoria, distinta por supuesto que la que tu le pasas a la función. En C, los parámetros se pasan por valor, con lo cual al salir de la función el puntero tendrá el mismo contenido que antes de llamarla.

La solución es:
1: pasas por referencia osea,
void funcion(&puntero)
{

//dentro de la función usas el puntero con *
*puntero = realloc(...)
}

2: no pasas el puntero, lo creas en la función y luego lo devuelves.

char* funcion()
{
char * puntero;

...

return puntero;
}

int main()
{
char * vector = funcion();
.....
free(vector);
return 0;
}
5 respuestas