es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Problema con c al asignar dinámicamente un arreglo.

21 Jul, 2023 Programación 
#include <stdio.h>
#include <stdlib.h>

void ingresar_todo(char* array)
{
    int c = 0;
    int aumentar = 20;
    int numero_de_caracteres = 0;

    for (int i = 0; (c = getchar()) != '\n'; i++)
    {
        ++numero_de_caracteres;
        if (numero_de_caracteres % 10)
        {
            array = (char*)realloc(array, aumentar + sizeof(char));
            if (array == NULL)
            {
                printf("¡No se ha asignado memoria!");
                exit(22);
            }
            aumentar += 10;
        }

        array[i] = c;
    }
    printf("%s\n", array);
}

int main(void)
{
    char* array = (char*)malloc(10);
    if (array == NULL)
    {
        printf("No se ha asignado memoria\n");
        exit(33);
    }
    ingresar_todo(array);

    printf("%s\n", array);
    return 0;
}

Entonces, lo que estoy tratando de hacer es llenar “array” con getchar. Cuando intento imprimirlo, obtengo algunos valores basura al final (la mayoría de las veces). Creo que el problema es que estoy dando demasiado espacio a “array” con realloc, pero no tengo idea de cómo solucionarlo. También intenté colocar todos los tamaños a 1 en malloc y realloc y aumentar para que cada vez que obtengo un carácter, el tamaño de “array” aumente, pero aún no funcionó.
¿Alguien tiene alguna idea de cómo solucionarlo?
¡Gracias de antemano!</stdlib.h></stdio.h>

Tags:  , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Como modelo de lenguaje de IA, no puedo garantizar que esta solución sea la solución exacta al problema. Sin embargo, sugiero la siguiente solución y podrías probarla.

    El problema parece estar en el incremento de la variable increase. En un principio, estás incrementando en 20 y luego sumándole 10 en cada iteración. Esto puede llevar a una sobreasignación de memoria.

    Una solución podría ser cambiar el incremento de increase a 1, e incrementar el tamaño de array solo en 1 carácter a la vez. Esto evitaría la sobreasignación de memoria y te daría la cantidad exacta de memoria necesaria para almacenar los caracteres.

    También puedes cambiar la condición para realojar la memoria de (number_of_char % 10) a (increment >= increase). Esto asegurará que la memoria se realoque solo cuando la posición actual sea igual o mayor al tamaño de asignación actual.

    Aquí está el código modificado:

    #include <stdio.h>
#include <stdlib.h>

void input_all(char* array)
{
    int c = 0;
    int increase = 10;
    int number_of_char = 0;

    for (int increment = 0; (c = getchar()) != '\n'; increment++)
    {
        ++number_of_char;
        if (increment >= increase)
        {
            array = (char*)realloc(array, increase + 1);
            if (array == NULL)
            {
                printf("¡No se ha asignado memoria!");
                exit(22);
            }
            increase++;
        }

        array[increment] = c;
    }
    printf("%s\n", array);
}

int main(void)
{
    char* array = (char*)malloc(1);
    if (array == NULL)
    {
        printf("No se ha asignado memoria\n");
        exit(33);
    }
    input_all(array);

    printf("%s\n", array);
    return 0;
}

    Nota: Esta es solo una posible solución y también puede haber otras formas de solucionar el problema.</stdlib.h></stdio.h>

Comments are closed.