Error with data entry in C

Let's take a closer look at the function 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;
}

There are two obvious flaws:

1.- That is not the correct way to use the realloc function , because, in each iteration, you pass the same size (in this case a byte), therefore, you are not resizing the array!

The second parameter of realloc expects a new size in bytes . At first the array consumes 1 byte, then on resizing you must pass 2 bytes to it, then on the third iteration you must pass 3 bytes and so on.

So to the second parameter you should pass this:

(n+1) * sizeof(char)

A plus one is added to nbecause you have to leave an extra space for the null character, since it indicates the end of the string.

2.- This statement causes a segmentation fault :

*ecu[n]

The above statement is equivalent to:

**(ecu + n)

Now, the question is, what if n = 1? We would simply be accessing a memory address that does not belong to the program and this causes the OS to kill the process. This is all because this expression is used to access X position of an array of pointers , but this is not the case, since the double pointer ( ecu) can only access one pointer.

3. You don't need the getche function ! It is not standard! Use the getchar function which is standard.

The getchar function reads one character at a time from the keyboard buffer.

The function entradawould look like this if we follow the mentioned corrections:

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;
}

How to use:

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;
}

Another problem is the code you have in the function main, you have complicated yourself too much and the way you calculate the size in bytes I still don't understand why you did it that way.

All you have to do is create an array of Nelement structures. So yes it N = 2is because you will have two equations.

In code it would look like this:

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;
}

Observation:

1.- Do not abuse global variables. Look at this thread .

2.- Don't forget to free the memory, otherwise there will be a memory leak.