C/C++ - Problemone con l'allocazione dinamica

08/12/13 22:06

Il problema è il seguente: Data una lista ordinata composta da N elementi, il programma restituisce un errore quando tento di eliminare il primo elemento della lista(vedi elimina()).

CODICE:

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

#define NAME_LENGTH 50
#define DES_LENGTH 50
#define PUTS_LINE_STDERR fputs("________________________________________________________________________________\n", stderr);


typedef struct my_articolo
{
    signed int code;
    char *name;
    char *des;
    float price;
    signed int q_disp;
    signed int q_min;
    struct my_articolo *n;
} articolo;

articolo *start = 0;

void apri(void);
void inserisci(void);
void cerca(void);
void modifica(void);
void elimina(void);
void visualizza(void);
void esporta(void);

char* r_line(char *str, unsigned int length, FILE *stream);
articolo* if_code(signed int code);
articolo** if_name(articolo **arr, const char *name);
void stampa(articolo **arr);



int main()
{
    void (*cmd[])(void) = {apri, inserisci, cerca, modifica, elimina, visualizza, esporta};

    unsigned int c_code = 0;

    while(1)
    {
        PUTS_LINE_STDERR;
        fputs("                                 @ Database @\n\n", stderr);
        fputs("1 - Apri database\n\n", stderr);
        fputs("2 - Inserisci articolo nel database\n\n", stderr);
        fputs("3 - Cerca articolo/i nel database\n\n", stderr);
        fputs("4 - Modifica articolo del database\n\n", stderr);
        fputs("5 - Elimina articolo/i del database o svuota l'intero database\n\n", stderr);
        fputs("6 - Visualizza il database\n\n", stderr);
        fputs("7 - Esporta database\n\n", stderr);
        fputs("8 - Esci dal programma\n", stderr);
        PUTS_LINE_STDERR;
        fputs("Inserire il codice corrispondente all'operazione: ", stderr);

        fflush(stdin);
        scanf("%u", &c_code);
        c_code--;

        if(c_code < 7)
        {
            (*cmd[c_code])();
            fputs("\n------------------------ Premere un tasto per continuare ----------------------\n", stderr);
            fflush(stdin);
            getchar();
            fputs("\n\n", stderr);
        }
        else if(c_code == 7)
        {
            return 0;
        }
        else
        {
            fputs("\n\nIl codice inserito non e' valido.\n\n------------------------ Premere un tasto per continuare ----------------------\n", stderr);
            fflush(stdin);
            getchar();
            fputs("\n\n", stderr);
        }
    }
}



char* r_line(char *str, unsigned int length, FILE *stream)
{
    signed char ch = 'Il problema è il seguente: Data una lista ordinata composta da N elementi, il programma restituisce un errore quando tento di eliminare il primo elemento della lista(vedi elimina()).



CODICE:



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

#define NAME_LENGTH 50
#define DES_LENGTH 50
#define PUTS_LINE_STDERR fputs("________________________________________________________________________________\n", stderr);


typedef struct my_articolo
{
    signed int code;
    char *name;
    char *des;
    float price;
    signed int q_disp;
    signed int q_min;
    struct my_articolo *n;
} articolo;

articolo *start = 0;

void apri(void);
void inserisci(void);
void cerca(void);
void modifica(void);
void elimina(void);
void visualizza(void);
void esporta(void);

char* r_line(char *str, unsigned int length, FILE *stream);
articolo* if_code(signed int code);
articolo** if_name(articolo **arr, const char *name);
void stampa(articolo **arr);



int main()
{
    void (*cmd[])(void) = {apri, inserisci, cerca, modifica, elimina, visualizza, esporta};

    unsigned int c_code = 0;

    while(1)
    {
        PUTS_LINE_STDERR;
        fputs("                                 @ Database @\n\n", stderr);
        fputs("1 - Apri database\n\n", stderr);
        fputs("2 - Inserisci articolo nel database\n\n", stderr);
        fputs("3 - Cerca articolo/i nel database\n\n", stderr);
        fputs("4 - Modifica articolo del database\n\n", stderr);
        fputs("5 - Elimina articolo/i del database o svuota l'intero database\n\n", stderr);
        fputs("6 - Visualizza il database\n\n", stderr);
        fputs("7 - Esporta database\n\n", stderr);
        fputs("8 - Esci dal programma\n", stderr);
        PUTS_LINE_STDERR;
        fputs("Inserire il codice corrispondente all'operazione: ", stderr);

        fflush(stdin);
        scanf("%u", &c_code);
        c_code--;

        if(c_code < 7)
        {
            (*cmd[c_code])();
            fputs("\n------------------------ Premere un tasto per continuare ----------------------\n", stderr);
            fflush(stdin);
            getchar();
            fputs("\n\n", stderr);
        }
        else if(c_code == 7)
        {
            return 0;
        }
        else
        {
            fputs("\n\nIl codice inserito non e' valido.\n\n------------------------ Premere un tasto per continuare ----------------------\n", stderr);
            fflush(stdin);
            getchar();
            fputs("\n\n", stderr);
        }
    }
}



char* r_line(char *str, unsigned int length, FILE *stream)
{
    signed char ch = '{parsed_message}';
    BYTE i = 0;

    if(stream == stdin) fflush(stdin);

    while(isspace(ch = fgetc(stream)));

    while(((ch != '\n') && (ch != EOF)) && (i < length - 1))
    {
        str[i++] = ch;
        ch = fgetc(stream);
        str = (char*) realloc(str, (i + 1) * sizeof(char));
    }

    if(i == length - 1)
    {
        str = (char*) realloc(str, (i + 2) * sizeof(char));
        str[i] = '~';
        str[i + 1] = '{parsed_message}';
    }

    str[i] = '{parsed_message}';

    if(stream == stdin) fflush(stdin);

    return str;
}


void inserisci()
{
    articolo *p = 0, *c = 0, *nn = calloc(1, sizeof(articolo));
    char *n_name = (char*) calloc(1, sizeof(char)), *n_des = (char*) calloc(1, sizeof(char));

    if(!nn)
    {
        fputs("\nErrore di memoria. Impossibile aggiungere l'articolo.\n", stderr);
        free(nn);
        return;
    }

i_code:
    fputs("\nInserisci il codice del componente (0 - 99999999): ", stderr);
    fflush(stdin);
    scanf("%8i", &nn->code);

    if(nn->code < 0 || nn->code > 99999999)
    {
        fputs("\nIl codice inserito non e' valido.\n", stderr);
        goto i_code;
    }

    for(c = start, p = 0; c && nn->code > c->code; p = c, c = c->n);

    if(c && (nn->code == c->code))
    {
        fputs("\nL'articolo esiste gia'. Impossibile aggiungerlo.\n", stderr);
        free(nn);
        return;
    }

i_name:
    fputs("Inserisci il nome dell'articolo: ", stderr);
    r_line(n_name, NAME_LENGTH, stdin);

    if(strlen(n_name) <= 0)
    {
        fputs("\nIl nome inserito non e' valido.\n", stderr);
        goto i_name;
    }

    nn->name = n_name;


i_des:
    fputs("Inserisci la descrizione dell'articolo: ", stderr);
    r_line(n_des, DES_LENGTH, stdin);

    if(strlen(n_des) <= 0)
    {
        fputs("\nLa descrizione inserita non e' valida.\n", stderr);
        goto i_des;
    }

    nn->des = n_des;


i_price:
    fputs("Inserisci il prezzo dell'articolo(0 - 9999999.99): ", stderr);
    fflush(stdin);
    scanf("%7f", &nn->price);

    if(nn->price < 0.0 || nn->price > 9999999.99)
    {
        fputs("\nIl prezzo inserito non e' valido.\n", stderr);
        goto i_price;
    }


i_disp:
    fputs("Inserisci la disponibilita' dell'articolo(0 - 9999999): ", stderr);
    fflush(stdin);
    scanf("%7i", &nn->q_disp);

    if(nn->q_disp < 0 || nn->q_disp > 9999999)
    {
        fputs("\nIl valore inserito non e' valido.\n", stderr);
        goto i_disp;
    }


i_min:
    fputs("Inserisci la quantita' minima di riordino(0 - 9999998): ", stderr);
    fflush(stdin);
    scanf("%7i", &nn->q_min);

    if(nn->q_min < 0 || nn->q_min > 9999998)
    {
        fputs("\nIl valore inserito non e' valido.\n", stderr);
        goto i_min;
    }

    nn->n = c;

    if(!p)
    {
        start = nn;
    }
    else
    {
        p->n = nn;
    }
}


void elimina()
{
    articolo *p = 0, *c = 0;
    signed int code = 0, c_code = 0;

    if(!start)
    {
        fputs("\nDatabase vuoto.\n", stderr);
        return;
    }

menu_e:
    fputs("\n1 - Elimina uno o piu' componenti\n", stderr);
    fputs("\n2 - Elimina tutto il database\n", stderr);
    fputs("\n3 - Torna al menu'\n", stderr);
    fputs("\nInserisci il codice corrispondente alla tua scelta: ", stderr);

    fflush(stdin);
    scanf("%u", &c_code);

    switch(c_code)
    {
    case 1:
del:
        fputs("\nInserisci il codice del componente: ", stderr);

        fflush(stdin);
        scanf("%u", &code);

        for(c = start, p = 0; c && (c->code != code); p = c, c = c->n);

        if(!c)
        {
            fputs("\nComponente non trovato. Impossibile completare la cancellazione.\n", stderr);
            fputs("\nRiprovare?[s/n]: ", stderr);
            fflush(stdin);
            if(fgetc(stdin) == 's')
            {
                PUTS_LINE_STDERR;
                goto del;
            }
            goto ask_e;
        }
        if(!p)
        {
            start = c->n;
        }
        else
        {
            p->n = c->n;
        }

        free(c->name);
        free(c->des);
        free(c);

        fputs("\nComponente eliminato.\n", stderr);
        break;

    case 2:
        for(p = start, c = 0; p; p = c)
        {
            c = p->n;
            free(p->name);
            free(p->des);
            free(p);
        }

        start = 0;

        fputs("\nDatabase svuotato.\n", stderr);
        return;

    case 3:
        return;

    default:
        fputs("\nIl codice inserito non e' valido.\n", stderr);
        PUTS_LINE_STDERR
        goto menu_e;
        break;
    }

ask_e:
    fputs("\nContinuare con le eliminazioni?[s/n]: ", stderr);
    fflush(stdin);
    if(fgetc(stdin) == 's')
    {
        PUTS_LINE_STDERR;
        goto menu_e;
    }
}




Grazie in anticipo per il vostro aiuto! ';
    BYTE i = 0;

    if(stream == stdin) fflush(stdin);

    while(isspace(ch = fgetc(stream)));

    while(((ch != '\n') && (ch != EOF)) && (i < length - 1))
    {
        str[i++] = ch;
        ch = fgetc(stream);
        str = (char*) realloc(str, (i + 1) * sizeof(char));
    }

    if(i == length - 1)
    {
        str = (char*) realloc(str, (i + 2) * sizeof(char));
        str[i] = '~';
        str[i + 1] = 'Il problema è il seguente: Data una lista ordinata composta da N elementi, il programma restituisce un errore quando tento di eliminare il primo elemento della lista(vedi elimina()).



CODICE:



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

#define NAME_LENGTH 50
#define DES_LENGTH 50
#define PUTS_LINE_STDERR fputs("________________________________________________________________________________\n", stderr);


typedef struct my_articolo
{
    signed int code;
    char *name;
    char *des;
    float price;
    signed int q_disp;
    signed int q_min;
    struct my_articolo *n;
} articolo;

articolo *start = 0;

void apri(void);
void inserisci(void);
void cerca(void);
void modifica(void);
void elimina(void);
void visualizza(void);
void esporta(void);

char* r_line(char *str, unsigned int length, FILE *stream);
articolo* if_code(signed int code);
articolo** if_name(articolo **arr, const char *name);
void stampa(articolo **arr);



int main()
{
    void (*cmd[])(void) = {apri, inserisci, cerca, modifica, elimina, visualizza, esporta};

    unsigned int c_code = 0;

    while(1)
    {
        PUTS_LINE_STDERR;
        fputs("                                 @ Database @\n\n", stderr);
        fputs("1 - Apri database\n\n", stderr);
        fputs("2 - Inserisci articolo nel database\n\n", stderr);
        fputs("3 - Cerca articolo/i nel database\n\n", stderr);
        fputs("4 - Modifica articolo del database\n\n", stderr);
        fputs("5 - Elimina articolo/i del database o svuota l'intero database\n\n", stderr);
        fputs("6 - Visualizza il database\n\n", stderr);
        fputs("7 - Esporta database\n\n", stderr);
        fputs("8 - Esci dal programma\n", stderr);
        PUTS_LINE_STDERR;
        fputs("Inserire il codice corrispondente all'operazione: ", stderr);

        fflush(stdin);
        scanf("%u", &c_code);
        c_code--;

        if(c_code < 7)
        {
            (*cmd[c_code])();
            fputs("\n------------------------ Premere un tasto per continuare ----------------------\n", stderr);
            fflush(stdin);
            getchar();
            fputs("\n\n", stderr);
        }
        else if(c_code == 7)
        {
            return 0;
        }
        else
        {
            fputs("\n\nIl codice inserito non e' valido.\n\n------------------------ Premere un tasto per continuare ----------------------\n", stderr);
            fflush(stdin);
            getchar();
            fputs("\n\n", stderr);
        }
    }
}



char* r_line(char *str, unsigned int length, FILE *stream)
{
    signed char ch = '{parsed_message}';
    BYTE i = 0;

    if(stream == stdin) fflush(stdin);

    while(isspace(ch = fgetc(stream)));

    while(((ch != '\n') && (ch != EOF)) && (i < length - 1))
    {
        str[i++] = ch;
        ch = fgetc(stream);
        str = (char*) realloc(str, (i + 1) * sizeof(char));
    }

    if(i == length - 1)
    {
        str = (char*) realloc(str, (i + 2) * sizeof(char));
        str[i] = '~';
        str[i + 1] = '{parsed_message}';
    }

    str[i] = '{parsed_message}';

    if(stream == stdin) fflush(stdin);

    return str;
}


void inserisci()
{
    articolo *p = 0, *c = 0, *nn = calloc(1, sizeof(articolo));
    char *n_name = (char*) calloc(1, sizeof(char)), *n_des = (char*) calloc(1, sizeof(char));

    if(!nn)
    {
        fputs("\nErrore di memoria. Impossibile aggiungere l'articolo.\n", stderr);
        free(nn);
        return;
    }

i_code:
    fputs("\nInserisci il codice del componente (0 - 99999999): ", stderr);
    fflush(stdin);
    scanf("%8i", &nn->code);

    if(nn->code < 0 || nn->code > 99999999)
    {
        fputs("\nIl codice inserito non e' valido.\n", stderr);
        goto i_code;
    }

    for(c = start, p = 0; c && nn->code > c->code; p = c, c = c->n);

    if(c && (nn->code == c->code))
    {
        fputs("\nL'articolo esiste gia'. Impossibile aggiungerlo.\n", stderr);
        free(nn);
        return;
    }

i_name:
    fputs("Inserisci il nome dell'articolo: ", stderr);
    r_line(n_name, NAME_LENGTH, stdin);

    if(strlen(n_name) <= 0)
    {
        fputs("\nIl nome inserito non e' valido.\n", stderr);
        goto i_name;
    }

    nn->name = n_name;


i_des:
    fputs("Inserisci la descrizione dell'articolo: ", stderr);
    r_line(n_des, DES_LENGTH, stdin);

    if(strlen(n_des) <= 0)
    {
        fputs("\nLa descrizione inserita non e' valida.\n", stderr);
        goto i_des;
    }

    nn->des = n_des;


i_price:
    fputs("Inserisci il prezzo dell'articolo(0 - 9999999.99): ", stderr);
    fflush(stdin);
    scanf("%7f", &nn->price);

    if(nn->price < 0.0 || nn->price > 9999999.99)
    {
        fputs("\nIl prezzo inserito non e' valido.\n", stderr);
        goto i_price;
    }


i_disp:
    fputs("Inserisci la disponibilita' dell'articolo(0 - 9999999): ", stderr);
    fflush(stdin);
    scanf("%7i", &nn->q_disp);

    if(nn->q_disp < 0 || nn->q_disp > 9999999)
    {
        fputs("\nIl valore inserito non e' valido.\n", stderr);
        goto i_disp;
    }


i_min:
    fputs("Inserisci la quantita' minima di riordino(0 - 9999998): ", stderr);
    fflush(stdin);
    scanf("%7i", &nn->q_min);

    if(nn->q_min < 0 || nn->q_min > 9999998)
    {
        fputs("\nIl valore inserito non e' valido.\n", stderr);
        goto i_min;
    }

    nn->n = c;

    if(!p)
    {
        start = nn;
    }
    else
    {
        p->n = nn;
    }
}


void elimina()
{
    articolo *p = 0, *c = 0;
    signed int code = 0, c_code = 0;

    if(!start)
    {
        fputs("\nDatabase vuoto.\n", stderr);
        return;
    }

menu_e:
    fputs("\n1 - Elimina uno o piu' componenti\n", stderr);
    fputs("\n2 - Elimina tutto il database\n", stderr);
    fputs("\n3 - Torna al menu'\n", stderr);
    fputs("\nInserisci il codice corrispondente alla tua scelta: ", stderr);

    fflush(stdin);
    scanf("%u", &c_code);

    switch(c_code)
    {
    case 1:
del:
        fputs("\nInserisci il codice del componente: ", stderr);

        fflush(stdin);
        scanf("%u", &code);

        for(c = start, p = 0; c && (c->code != code); p = c, c = c->n);

        if(!c)
        {
            fputs("\nComponente non trovato. Impossibile completare la cancellazione.\n", stderr);
            fputs("\nRiprovare?[s/n]: ", stderr);
            fflush(stdin);
            if(fgetc(stdin) == 's')
            {
                PUTS_LINE_STDERR;
                goto del;
            }
            goto ask_e;
        }
        if(!p)
        {
            start = c->n;
        }
        else
        {
            p->n = c->n;
        }

        free(c->name);
        free(c->des);
        free(c);

        fputs("\nComponente eliminato.\n", stderr);
        break;

    case 2:
        for(p = start, c = 0; p; p = c)
        {
            c = p->n;
            free(p->name);
            free(p->des);
            free(p);
        }

        start = 0;

        fputs("\nDatabase svuotato.\n", stderr);
        return;

    case 3:
        return;

    default:
        fputs("\nIl codice inserito non e' valido.\n", stderr);
        PUTS_LINE_STDERR
        goto menu_e;
        break;
    }

ask_e:
    fputs("\nContinuare con le eliminazioni?[s/n]: ", stderr);
    fflush(stdin);
    if(fgetc(stdin) == 's')
    {
        PUTS_LINE_STDERR;
        goto menu_e;
    }
}




Grazie in anticipo per il vostro aiuto! ';
    }

    str[i] = 'Il problema è il seguente: Data una lista ordinata composta da N elementi, il programma restituisce un errore quando tento di eliminare il primo elemento della lista(vedi elimina()).



CODICE:



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

#define NAME_LENGTH 50
#define DES_LENGTH 50
#define PUTS_LINE_STDERR fputs("________________________________________________________________________________\n", stderr);


typedef struct my_articolo
{
    signed int code;
    char *name;
    char *des;
    float price;
    signed int q_disp;
    signed int q_min;
    struct my_articolo *n;
} articolo;

articolo *start = 0;

void apri(void);
void inserisci(void);
void cerca(void);
void modifica(void);
void elimina(void);
void visualizza(void);
void esporta(void);

char* r_line(char *str, unsigned int length, FILE *stream);
articolo* if_code(signed int code);
articolo** if_name(articolo **arr, const char *name);
void stampa(articolo **arr);



int main()
{
    void (*cmd[])(void) = {apri, inserisci, cerca, modifica, elimina, visualizza, esporta};

    unsigned int c_code = 0;

    while(1)
    {
        PUTS_LINE_STDERR;
        fputs("                                 @ Database @\n\n", stderr);
        fputs("1 - Apri database\n\n", stderr);
        fputs("2 - Inserisci articolo nel database\n\n", stderr);
        fputs("3 - Cerca articolo/i nel database\n\n", stderr);
        fputs("4 - Modifica articolo del database\n\n", stderr);
        fputs("5 - Elimina articolo/i del database o svuota l'intero database\n\n", stderr);
        fputs("6 - Visualizza il database\n\n", stderr);
        fputs("7 - Esporta database\n\n", stderr);
        fputs("8 - Esci dal programma\n", stderr);
        PUTS_LINE_STDERR;
        fputs("Inserire il codice corrispondente all'operazione: ", stderr);

        fflush(stdin);
        scanf("%u", &c_code);
        c_code--;

        if(c_code < 7)
        {
            (*cmd[c_code])();
            fputs("\n------------------------ Premere un tasto per continuare ----------------------\n", stderr);
            fflush(stdin);
            getchar();
            fputs("\n\n", stderr);
        }
        else if(c_code == 7)
        {
            return 0;
        }
        else
        {
            fputs("\n\nIl codice inserito non e' valido.\n\n------------------------ Premere un tasto per continuare ----------------------\n", stderr);
            fflush(stdin);
            getchar();
            fputs("\n\n", stderr);
        }
    }
}



char* r_line(char *str, unsigned int length, FILE *stream)
{
    signed char ch = '{parsed_message}';
    BYTE i = 0;

    if(stream == stdin) fflush(stdin);

    while(isspace(ch = fgetc(stream)));

    while(((ch != '\n') && (ch != EOF)) && (i < length - 1))
    {
        str[i++] = ch;
        ch = fgetc(stream);
        str = (char*) realloc(str, (i + 1) * sizeof(char));
    }

    if(i == length - 1)
    {
        str = (char*) realloc(str, (i + 2) * sizeof(char));
        str[i] = '~';
        str[i + 1] = '{parsed_message}';
    }

    str[i] = '{parsed_message}';

    if(stream == stdin) fflush(stdin);

    return str;
}


void inserisci()
{
    articolo *p = 0, *c = 0, *nn = calloc(1, sizeof(articolo));
    char *n_name = (char*) calloc(1, sizeof(char)), *n_des = (char*) calloc(1, sizeof(char));

    if(!nn)
    {
        fputs("\nErrore di memoria. Impossibile aggiungere l'articolo.\n", stderr);
        free(nn);
        return;
    }

i_code:
    fputs("\nInserisci il codice del componente (0 - 99999999): ", stderr);
    fflush(stdin);
    scanf("%8i", &nn->code);

    if(nn->code < 0 || nn->code > 99999999)
    {
        fputs("\nIl codice inserito non e' valido.\n", stderr);
        goto i_code;
    }

    for(c = start, p = 0; c && nn->code > c->code; p = c, c = c->n);

    if(c && (nn->code == c->code))
    {
        fputs("\nL'articolo esiste gia'. Impossibile aggiungerlo.\n", stderr);
        free(nn);
        return;
    }

i_name:
    fputs("Inserisci il nome dell'articolo: ", stderr);
    r_line(n_name, NAME_LENGTH, stdin);

    if(strlen(n_name) <= 0)
    {
        fputs("\nIl nome inserito non e' valido.\n", stderr);
        goto i_name;
    }

    nn->name = n_name;


i_des:
    fputs("Inserisci la descrizione dell'articolo: ", stderr);
    r_line(n_des, DES_LENGTH, stdin);

    if(strlen(n_des) <= 0)
    {
        fputs("\nLa descrizione inserita non e' valida.\n", stderr);
        goto i_des;
    }

    nn->des = n_des;


i_price:
    fputs("Inserisci il prezzo dell'articolo(0 - 9999999.99): ", stderr);
    fflush(stdin);
    scanf("%7f", &nn->price);

    if(nn->price < 0.0 || nn->price > 9999999.99)
    {
        fputs("\nIl prezzo inserito non e' valido.\n", stderr);
        goto i_price;
    }


i_disp:
    fputs("Inserisci la disponibilita' dell'articolo(0 - 9999999): ", stderr);
    fflush(stdin);
    scanf("%7i", &nn->q_disp);

    if(nn->q_disp < 0 || nn->q_disp > 9999999)
    {
        fputs("\nIl valore inserito non e' valido.\n", stderr);
        goto i_disp;
    }


i_min:
    fputs("Inserisci la quantita' minima di riordino(0 - 9999998): ", stderr);
    fflush(stdin);
    scanf("%7i", &nn->q_min);

    if(nn->q_min < 0 || nn->q_min > 9999998)
    {
        fputs("\nIl valore inserito non e' valido.\n", stderr);
        goto i_min;
    }

    nn->n = c;

    if(!p)
    {
        start = nn;
    }
    else
    {
        p->n = nn;
    }
}


void elimina()
{
    articolo *p = 0, *c = 0;
    signed int code = 0, c_code = 0;

    if(!start)
    {
        fputs("\nDatabase vuoto.\n", stderr);
        return;
    }

menu_e:
    fputs("\n1 - Elimina uno o piu' componenti\n", stderr);
    fputs("\n2 - Elimina tutto il database\n", stderr);
    fputs("\n3 - Torna al menu'\n", stderr);
    fputs("\nInserisci il codice corrispondente alla tua scelta: ", stderr);

    fflush(stdin);
    scanf("%u", &c_code);

    switch(c_code)
    {
    case 1:
del:
        fputs("\nInserisci il codice del componente: ", stderr);

        fflush(stdin);
        scanf("%u", &code);

        for(c = start, p = 0; c && (c->code != code); p = c, c = c->n);

        if(!c)
        {
            fputs("\nComponente non trovato. Impossibile completare la cancellazione.\n", stderr);
            fputs("\nRiprovare?[s/n]: ", stderr);
            fflush(stdin);
            if(fgetc(stdin) == 's')
            {
                PUTS_LINE_STDERR;
                goto del;
            }
            goto ask_e;
        }
        if(!p)
        {
            start = c->n;
        }
        else
        {
            p->n = c->n;
        }

        free(c->name);
        free(c->des);
        free(c);

        fputs("\nComponente eliminato.\n", stderr);
        break;

    case 2:
        for(p = start, c = 0; p; p = c)
        {
            c = p->n;
            free(p->name);
            free(p->des);
            free(p);
        }

        start = 0;

        fputs("\nDatabase svuotato.\n", stderr);
        return;

    case 3:
        return;

    default:
        fputs("\nIl codice inserito non e' valido.\n", stderr);
        PUTS_LINE_STDERR
        goto menu_e;
        break;
    }

ask_e:
    fputs("\nContinuare con le eliminazioni?[s/n]: ", stderr);
    fflush(stdin);
    if(fgetc(stdin) == 's')
    {
        PUTS_LINE_STDERR;
        goto menu_e;
    }
}




Grazie in anticipo per il vostro aiuto! ';

    if(stream == stdin) fflush(stdin);

    return str;
}


void inserisci()
{
    articolo *p = 0, *c = 0, *nn = calloc(1, sizeof(articolo));
    char *n_name = (char*) calloc(1, sizeof(char)), *n_des = (char*) calloc(1, sizeof(char));

    if(!nn)
    {
        fputs("\nErrore di memoria. Impossibile aggiungere l'articolo.\n", stderr);
        free(nn);
        return;
    }

i_code:
    fputs("\nInserisci il codice del componente (0 - 99999999): ", stderr);
    fflush(stdin);
    scanf("%8i", &nn->code);

    if(nn->code < 0 || nn->code > 99999999)
    {
        fputs("\nIl codice inserito non e' valido.\n", stderr);
        goto i_code;
    }

    for(c = start, p = 0; c && nn->code > c->code; p = c, c = c->n);

    if(c && (nn->code == c->code))
    {
        fputs("\nL'articolo esiste gia'. Impossibile aggiungerlo.\n", stderr);
        free(nn);
        return;
    }

i_name:
    fputs("Inserisci il nome dell'articolo: ", stderr);
    r_line(n_name, NAME_LENGTH, stdin);

    if(strlen(n_name) <= 0)
    {
        fputs("\nIl nome inserito non e' valido.\n", stderr);
        goto i_name;
    }

    nn->name = n_name;


i_des:
    fputs("Inserisci la descrizione dell'articolo: ", stderr);
    r_line(n_des, DES_LENGTH, stdin);

    if(strlen(n_des) <= 0)
    {
        fputs("\nLa descrizione inserita non e' valida.\n", stderr);
        goto i_des;
    }

    nn->des = n_des;


i_price:
    fputs("Inserisci il prezzo dell'articolo(0 - 9999999.99): ", stderr);
    fflush(stdin);
    scanf("%7f", &nn->price);

    if(nn->price < 0.0 || nn->price > 9999999.99)
    {
        fputs("\nIl prezzo inserito non e' valido.\n", stderr);
        goto i_price;
    }


i_disp:
    fputs("Inserisci la disponibilita' dell'articolo(0 - 9999999): ", stderr);
    fflush(stdin);
    scanf("%7i", &nn->q_disp);

    if(nn->q_disp < 0 || nn->q_disp > 9999999)
    {
        fputs("\nIl valore inserito non e' valido.\n", stderr);
        goto i_disp;
    }


i_min:
    fputs("Inserisci la quantita' minima di riordino(0 - 9999998): ", stderr);
    fflush(stdin);
    scanf("%7i", &nn->q_min);

    if(nn->q_min < 0 || nn->q_min > 9999998)
    {
        fputs("\nIl valore inserito non e' valido.\n", stderr);
        goto i_min;
    }

    nn->n = c;

    if(!p)
    {
        start = nn;
    }
    else
    {
        p->n = nn;
    }
}


void elimina()
{
    articolo *p = 0, *c = 0;
    signed int code = 0, c_code = 0;

    if(!start)
    {
        fputs("\nDatabase vuoto.\n", stderr);
        return;
    }

menu_e:
    fputs("\n1 - Elimina uno o piu' componenti\n", stderr);
    fputs("\n2 - Elimina tutto il database\n", stderr);
    fputs("\n3 - Torna al menu'\n", stderr);
    fputs("\nInserisci il codice corrispondente alla tua scelta: ", stderr);

    fflush(stdin);
    scanf("%u", &c_code);

    switch(c_code)
    {
    case 1:
del:
        fputs("\nInserisci il codice del componente: ", stderr);

        fflush(stdin);
        scanf("%u", &code);

        for(c = start, p = 0; c && (c->code != code); p = c, c = c->n);

        if(!c)
        {
            fputs("\nComponente non trovato. Impossibile completare la cancellazione.\n", stderr);
            fputs("\nRiprovare?[s/n]: ", stderr);
            fflush(stdin);
            if(fgetc(stdin) == 's')
            {
                PUTS_LINE_STDERR;
                goto del;
            }
            goto ask_e;
        }
        if(!p)
        {
            start = c->n;
        }
        else
        {
            p->n = c->n;
        }

        free(c->name);
        free(c->des);
        free(c);

        fputs("\nComponente eliminato.\n", stderr);
        break;

    case 2:
        for(p = start, c = 0; p; p = c)
        {
            c = p->n;
            free(p->name);
            free(p->des);
            free(p);
        }

        start = 0;

        fputs("\nDatabase svuotato.\n", stderr);
        return;

    case 3:
        return;

    default:
        fputs("\nIl codice inserito non e' valido.\n", stderr);
        PUTS_LINE_STDERR
        goto menu_e;
        break;
    }

ask_e:
    fputs("\nContinuare con le eliminazioni?[s/n]: ", stderr);
    fflush(stdin);
    if(fgetc(stdin) == 's')
    {
        PUTS_LINE_STDERR;
        goto menu_e;
    }
}

Grazie in anticipo per il vostro aiuto! :rofl:

Ultima modifica effettuata da drewnik99 09/12/13 14:32

aaa

08/12/13 22:35

nessuno

Mancano alcune costanti

PUTS_LINE_STDERR
NAME_LENGTH
DES_LENGTH

e

r_line

P.S. Tutti quei goto sono orrendi ...

Ricorda che nessuno è obbligato a risponderti e che nessuno è perfetto ...
---
Il grande studioso italiano Bruno de Finetti ( uno dei padri fondatori del moderno Calcolo delle probabilità ) chiamava il gioco del Lotto Tassa sulla stupidità.

08/12/13 22:48

drewnik99

Una soluzione alternativa ai goto?

E per il problema con i free()?

aaa

09/12/13 6:56

nessuno

I goto non si usano. Al loro posto utilizza i cicli.

Adesso manca il main ...

Ultima modifica effettuata da nessuno 09/12/13 7:00

09/12/13 11:16

drewnik99

Potresti dirmi quali sono i vantaggi nell'utilizzare i cicli al posto di goto?
Guardando l'assembly prodotto, isolando una piccola porzione con un menu, non sembrano esserci sostanziali differenze, anche se non sono molto esperto.

Il programma in realtà è molto più ampio, ma il problema si riscontra nella funzione elimina(), per questo ho postato la stessa e inserisci() per mostrare come aggiungo gli elementi alla lista ordinata.
Non riesco ancora a capire perchè il programma non mi permette di eliminare il primo elemento della lista ordinata, ma solo i successivi.

Grazie a tutti per i suggerimenti.

aaa

09/12/13 12:24

nessuno

Per il goto leggi

it.wikipedia.org/wiki/…

Per il resto, senza vedere cosa fai nel main e come chiami le varie funzioni, con quali argomenti, potrebbe essere un problema risalire all'errore. Sicuramente provando il tuo main si fa prima e con certezza.

Tanto per capirci, anche la funzione

r_line

non mi convince e potrebbe essere sbagliata ... vorrei vedere come la usi.

Ultima modifica effettuata da nessuno 09/12/13 12:30

09/12/13 14:11

drewnik99

Ok, grazie per il link, ho modificato il post iniziale, guarda pure lì. :rofl:

E' possibile eliminare start come variabile globale e passarla come parametro a tutte le funzioni sapendo che vengono richiamate così:

void apri(articolo *start);
void inserisci(articolo *start);
void cerca(articolo *start);
void modifica(articolo *start);
void elimina(articolo *start);
void visualizza(articolo *start);
void esporta(articolo *start);

int main()
{
    articolo *start = 0;
    unsigned int c_code = 0;
    void (*cmd[7])(articolo*) = {apri, inserisci, cerca, modifica, elimina, visualizza, esporta};

    scanf("%u", &c_code);
    c_code--;

    (*cmd[c_code])(start);
}

Ultima modifica effettuata da drewnik99 09/12/13 17:59

aaa