Error con entrada de datos en C

Question

hace poco empecé a sumergirme en este mundo de la programación. Claramente, estoy dando mis primeros pasos. Ahora, intentaba hacer un programa que resuelva sistemas de ecuaciones, pero en la entrada de datos ya tengo un problema cuya causa no logro identificar. Me alegraría bastante encontrar alguna respuesta.

La idea de la entrada de datos, es identificar cuantas ecuaciones tiene el sistema y, posteriormente, recoger cada una en una cadena (array) de caracteres. Luego, otra función se encarga de evaluar cada carácter de la cadena y decidir si es un coeficiente, una variable o un signo. Luego, almacena estos datos en una estructura que se crea para cada ecuación. La función que me da problemas es la que recoge la cadena de caracteres, pues cuando ejecuto el programa recibe hasta el sexto carácter y se finaliza por algún error:

introducir el código aquí

    typedef struct ecua
        {                       /*cabecera del programa*/
            int coefi[8];
            char varia[8];                     /*estructura para cada ecuacion*/
            char sig[8];
        }ecuacion;
        void entrada(char**ecu);
        int con1;
        int con2;
        int n;  
    
        int main()   /* en la funcion main, declaro y defino punteros para trabajar con memoria dinamica*/        
        {
            printf("Por favor, indique cuantas ecuaciones hay en el sistema a solucionar\n");
            scanf("%d",&con1);
            ecuacion *pun;
            char *ec; 
            pun=(struct ecua*)malloc(sizeof(int)*8+sizeof(char)*16);
            for(con2=1;con2<=con1;con2++)
            {
                if(con2>1)
                {
                    pun=(struct ecua*)realloc(pun,(sizeof(int)*8+sizeof(char)*16));
                } /*asigna memoria para la clasificación que se hará posteriormente en otra función*/
                entrada(&ec); 
        }
            return 0;
        
        }
    void entrada(char**ecu)     /*no se cual es el error en esta funcion :( */
    {
         n=0;
        *ecu=(char*)malloc(sizeof(char));
        printf("introduzca la ecuacion %d. Para terminar, pulsa enter\n",con2);
        *ecu[0]=getche();  
        while(*ecu[n]!=(13))                       /*Mientras el caracter no sea enter,*/      
        {
            n++;
            *ecu=(char*)realloc(*ecu,sizeof(char));
            *ecu[n]=getche();
            
        }
        return;

}

Answer 1

Analicemos detenidamente la función entrada:

void entrada(char**ecu)    
{
    n=0;
    *ecu=(char*)malloc(sizeof(char));
    printf("introduzca la ecuacion %d. Para terminar, pulsa enter\n",con2);
    *ecu[0]=getche();  
    while(*ecu[n]!=(13))                          
    {
        n++;
        *ecu=(char*)realloc(*ecu,sizeof(char));
        *ecu[n]=getche();
            
    }
    return;
}

Hay dos fallas a simple vista:

1.- Esa no es la forma correcta de usar la función realloc, debido a que, en cada iteración, le pasas el mismo tamaño (en este caso un byte), por lo tanto, ¡no estás redimensionando el array!

El segundo parámetro de realloc espera un nuevo tamaño en bytes. Al principio, el array consume 1 byte, luego al redimensionar, le debes pasar 2 bytes, luego en la tercera iteración debes pasar 3 bytes y así sucesivamente.

Así que al segundo parámetro deberías pasar esto:

(n+1) * sizeof(char)

Se le suma un más uno a n porque hay que dejar un espacio adicional para el caracter nulo, ya que indica el fin de la cadena.

2.- Esta sentencia ocasiona un fallo de segmentación:

*ecu[n]

La sentencia de arriba es equivalente a:

**(ecu + n)

Ahora, la pregunta es, ¿qué pasa si n = 1? Simplemente estaríamos accediendo a una dirección de memoria que al programa no le pertenece y esto hace que el SO mate el proceso. Todo esto se debe porque esta expresión se la usa para acceder a X posición de un array de punteros, pero este no es el caso, ya que el puntero doble (ecu) solo puede acceder a un puntero.

3. ¡No necesitas la función getche! ¡No es estándar! Usa la función getchar que sí es estándar.

La función getchar lee un caracter a la vez del búfer del teclado.

La función entrada quedaría así si seguimos las correcciones mencionadas:

void entrada(char** ecu)
{
    int n = 0;
    int ch;
    char* aux;
    char* buf;
    buf = malloc(sizeof(char));
    //Si hubo una falla al asignar memoria..
    if(buf == NULL)
    {
        //Para detectar el error..
        *ecu = NULL;
        return;
    }
    //Recorremos el búfer del teclado hasta encontrar un salto de línea..
    while((ch = getchar()) != '\n')
    {
        buf[n++] = ch;
        //Debemos usar un puntero auxiliar..
        aux = buf;
        //Ya que la función realloc puede retornar NULL si no pudo reservar memoria y esto sobrescribe el contenido del puntero y perdemos la dirección base donde se aloje el array.
        buf = realloc(buf, (n+1)* sizeof(char));
        if(buf == NULL)
        {
            //De este modo, tenemos la oportunidad de liberar la memoria..
            free(aux);
            //Para detectar el error..
            *ecu = NULL;
            return;
        }
    }
    //El caracter nulo debe estar en la última posición del array..
    buf[n] = '\0';
   //Actualizamos el puntero al que apunte "ecu"..
    *ecu = buf;
}

Modo de uso:

int main(void) 
{
    char* ecu;
    printf("Introduzca algo:\n");
    entrada(&ecu);
    if(ecu == NULL)
    {
        printf("Error: No se puso asignar memoria!");
        return 1;
    }
    printf("%s\n", ecu);
    //Se debe liberar la memoria manualmente.
    free(ecu);
    return 0;
}

Otro problema es el código que tienes en la función main, te has complicado demasiado y la forma como calculas el tamaño en bytes sigo sin entender porque lo hiciste así.

Lo único que debiste hacer es crear un array de estructuras de N elementos. Así que si N = 2 es porque tendrás dos ecuaciones.

En código quedaría así:

typedef struct ecua
{                      
    int coefi[8];
    char varia[8];                    
    char sig[8];
}ecuacion;

//Podemos omitir el nombre del parámetro cuando declaramos la función.
void entrada(char**);

/*
¡No necesitamos usar variables globales! ¡No es necesario en este caso!

*/

//Según el estándar, el encabezado de la función main debe ser: int main(void)
int main(void)       
{
    int cont1;
    ecuacion *pun;
    char *ec; 
    printf("Por favor, indique cuantas ecuaciones hay en el sistema a solucionar\n");
    scanf("%d",&con1);
    while(getchar() != '\n'); //Limpia el búfer del teclado.
    //Crea un array de estructuras de N elementos
    pun = malloc(con1 * sizeof(ecuacion));
    if(pun == NULL)
    {
        printf("Error: No se puso asignar memoria!");
        return 1;
    }
    //Recorremos el array de estructuras
    for(int con2 = 0; con2  < con1; ++con2 )
    {
        printf("introduzca la ecuacion %d. Para terminar, pulsa enter\n", con2 + 1);
        entrada(&ec);
        if(ec == NULL)
        {
            printf("Error: No se puso asignar memoria!");
            return 1;
        } 
        //aquí el código que quieras, para poder acceder al ARRAY lo haces así: pun[1].sig[0] (es un ejemplo claro).
    }
    return 0;
}

void entrada(char** ecu)
{
    int n = 0;
    int ch;
    char* aux;
    char* buf;
    buf = malloc(sizeof(char));
    if(buf == NULL)
    {
        *ecu = NULL;
        return;
    }
    while((ch = getchar()) != '\n')
    {
        buf[n++] = ch;
        aux = buf;
        buf = realloc(buf, (n+1)* sizeof(char));
        if(buf == NULL)
        {
            free(aux);
            *ecu = NULL;
            return;
        }
    }
    buf[n] = '\0';
    *ecu = buf;
}

Observación:

1.- No abuses de las variables globales. Mira este hilo.

2.- No olvides de liberar la memoria, de lo contrario, habrá fuga de memoria.