Buenas gente, necesito una mano, ayudenme con este problema

Poco a poco avanzo con memoria dinamica, me gusta más usar calloc  

ahora mi problema es que en el problema me estan pidiendo un arreglo multidimensional, tratando de leer multiples cadenas dependiendo de cuantas cadenas quiere el usuario, y ahi es donde me quedo corto a la hora de crear la reserva de la memoria.

No creo que sea tan dificil, pero realmente los ejercicios que estoy consultando estan un poco enredados y más que ayudarme, me confunden mucho más porque estan mezclando elementos de cadenas con estruturas y cosas así, necesito una aclaración de uds compañeros.

/*
    Escribir un programa para leer n cadenas de caracteres. Cada cadena tiene una longitud variable
    y esta formada por cualquier carácter. La memoria que ocupa cada cadena se ha de ajustar al
    tamaño que tiene. Una vez leidas las cadenas se debe realizar un proceso que consiste en eliminar
    todos los blancos, siempre manteniendo el espacio ocupado ajustado al número de caracteres.
 
    El programa debe mostrar las cadenas leídas y las cadenas transformadas.
*/
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define longitud 100
 
int main()
{
    char *cadena;
    int contador=0;
    int i;
    cadena = (char*) calloc(longitud, sizeof(char));
 
    if(cadena == NULL)
    {
        printf("\n\t  Error de asignación de memoria, adios!!");
        exit(-1);
    }
 
    printf("Digite la cadena:  ");
    fgets(cadena, longitud, stdin);
 
 
 
    for(i=0; i<strlen(cadena); i++)
    {
        if(cadena[i] == ' ')
        {
            cadena[i] = cadena[i+1];
            contador++;
        }
    }
 
    printf("\n\n\t La cadena es: %s", cadena);
    printf("\t Cantidad de espacios:  %d", contador);
    printf("\n\t longitud: %d  -- strlen(cadena):  %d", longitud, strlen(cadena));
 
    free(cadena);
    return 0;
}
 

Les agradezco cualquier pista

slds

¡Buenas!

Lo que no debes hacer es asignar una cantidad de memoria predeterminada a una cadena, lo hagas asignando esa memoria de forma dinamica o estatica, ya que si defines, por ejemplo, una longitud de 1000 caracteres puedes estar desaprobechando memoria si se introduce una cadena de menor longitud o puedes estar perdiendo informacion si tiene mayor longitud.

Lo que tienes que hacer es leer caracteres con una cadena de un tamaño determinado (por ejemplo 10 caracteres) y mediante realloc añadirlos a la linea que introduzcas. ¿Como sabras cuando has terminado de leer una linea? utiliza fgets, deja de leer cuando detecta un '\n' y lo almacena en la cadena:


Creo que es la unica manera que tienes de leer el contenido de una linea sin saber de antemano cual es la longitud maxima que puede tener.

¡Saludos!

Ten en cuenta que hoy en día importa más la eficiencia que la memoria, hoy en día nadie se preocupa por 6-7 bytes de más pero sí un progama tarda menos o no. El realloc es una operación costosa (creas un nuevo vector, copias el contenido al nuevo vector byte a byte y borras el antiguo).

No obstante, te presento una versión con realloc "amortiguado":

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
void LeerLinea(char** Linea)
{
    const int Incremento = 5;
    int tam = 0;
    int max = Incremento;
    int ch;
 
    (*Linea) = (char*) calloc(max,sizeof(char));
 
    while((ch = getchar()) != '\n' && ch != EOF)
    {
        (*Linea)[tam++] = ch;
 
        if (tam == max)
        {
            max += Incremento;
            (*Linea) = (char*)realloc (*Linea,max);
 
            if (*Linea == NULL)
            {
                 printf("\n\t  Error de asignación de memoria, adios!!");
                 exit(-1);
            }
        }
    }
 
    (*Linea)[tam] = 0; // caracter nulo
}
 
int main()
{
    char **cadena;
    int num_cadenas;
    int contador=0;
    int i,j;
 
    do
    {
        printf("Digite el numero de cadenas:  ");
        scanf("%d", &num_cadenas);
    }
    while(num_cadenas < 1);
 
    getchar();
 
    cadena = (char**) calloc(num_cadenas, sizeof(char*));
 
    if(cadena == NULL)
    {
        printf("\n\t  Error de asignación de memoria, adios!!");
        exit(-1);
    }
 
    // leyendo cada linea en memoria
    for(i=0; i<num_cadenas; i++)
    {
        LeerLinea(&cadena[i]);
    }
 
    for(i=0; i<num_cadenas; i++)
    {
        for(j=0;cadena[i]; j++ )
        {
            if(cadena[i][j] == ' ')
            {
                cadena[i][j] = cadena[i][j+1];
            }
        }
    }
 
 
    for (i = 0; i < num_cadenas; i++)
        printf("cadena # %2d: %s\n", i + 1, cadena[i]);
 
 
    /* Primero se libera la memoria de cada linea ... */
    for (i = 0; i < num_cadenas; i++)
        free(cadena[i]);
 
    /* ... a continuacion el bloque de memoria principal */
    free(cadena);
    return 0;
}

Es "realloc amortiguado" porque aumento la memoria de 5 en 5 en vez de 1 en 1. Así hago mucho menos reallocs y como mucho desperdicio 4 bytes.

Un comentario: en este momento los caracteres ' ' no se eliminan correctamente (solo se sobrescriben con el siguiente carácter). Para eliminarlos de la cadena hay que utilizar un bucle mas o menos así:

#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{
   char a[] = "Esta es alguna cadena con espacios";
   int i;
   int j;
 
   printf("\"%s\"\n", a);
 
   i = j = 0;
   do {
      if (a[i] != ' ')
         a[j++] = a[i];
   }while (a[i++] != '\0');
 
   /* 
   ** En tu programa el bloque debe reajustarse, el 
   ** numero de bytes esta dado por la variable "j"
   */
 
   printf("\"%s\"\n", a);
 
   return EXIT_SUCCESS;
}

Un saludo

En parte ya que otro problema se presenta si la cadena es "a  b  c" (dos espacios como separacion) la cadena resultante sera "a bb cc".

Un saludo