By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
445,804 Members | 1,666 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 445,804 IT Pros & Developers. It's quick & easy.

is a good C?

P: n/a
TC
I'm not a C programmer.
This is a good C?
how check the return value of getch or scanf?
and how check for the \n at the end of the text read?
FEOF do not return true if the file (text file) is finish?
if no what use?
/*Inclusione librerie*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

/*Definizione della strutura Elemento*/
typedef struct
{
char *parola;
unsigned int freq;
}Elem;

/*Definizione della lista delle parole trovate*/
struct Albero
{
Elem Elemento;
struct Albero *s;
struct Albero *d;
};

/*Definizione variabili*/
/*Albero ordinato per alfabeto*/
struct Albero *treeA = NULL;
/*Albero ordinato per frequenze*/
struct Albero *treeF = NULL;

unsigned int count = 0;

/*Definizione funzioni*/
/*Funzione di scansione del file costruzione delle parole e chiamata
della funzione di inseriento nell'albero ordinato per alfabeto*/
void Scansione(FILE *pf);
/*Aggiungi nodo all'albero ordinato per alfabeto*/
struct Albero *AggNodo_TreeA(struct Albero *nodo, char *parola);
/*Stampa albero*/
void Print(struct Albero *nodo);
/*Crea un nuovo albero ordinato per frequenza utilizzando come sorgente
l'albero
ordinato per alfabeto*/
void CreaAlberoF(struct Albero *sorg);
/*Aggiunge un nuovo nodo all'albero ordinato pre frequenze copiando i
valori dal
nodo passato come sorgente*/
struct Albero * AggNodo_TreeF(struct Albero *sorg, struct Albero *dest);
main (void)
{
char scelta;
int fOK;
int g;
/*Nome del file di testo*/
char nf[50];
/*Puntatore al file*/
FILE *pf;
/*MAIN*/
printf("\n Avvio del programma \n");

do
{
fOK = 0;
printf("\nInserire il nome del file di testo che si desidera
utilizzare (Esempio: Testo.txt) \n");

g = fscanf(stdin,"%s",nf); /*Lettura del nome del file */

pf=fopen(nf,"r"); /*Apertura del file in modalitÓ di lettura*/

/*Controllo apertura del file*/
if (pf==NULL)
{
/*Restituzione del messaggio di errore in caso di mancata apertura*/
perror("ERRORE nell'apertura del file");
fOK = 1;

}

}while(fOK != 0);

printf("\n\n");

do
{
scelta = 0;
/*Men¨*/
printf("\n 1- Scansione del file di testo \n");
printf("\n 2- Creazione del file delle parole ordinato per frequenza \n");
printf("\n 3- Stampa a video del file delle parole ordinato per
frequenza \n");
printf("\n 4- Stampa a video del file delle parole ordinato per ordine
alfabetico \n");
printf("\n 5- Esci \n");

do
{
scelta = getchar();
}while(scelta!= '1' && scelta!= '2' && scelta!= '3' && scelta!= '4' &&
scelta!= '5');
count=0;
/*Blocco di scelta*/
switch(scelta)
{
case ('1'):
Scansione(pf);
printf("\n Scansione EFFETTUATA! \n");
break;
case ('2'):
CreaAlberoF(treeA);
printf("\n Lista delle parole ordinata per frequenza creata! \n");
break;
case ('3'):
Print(treeF);
break;
case('4'):
Print(treeA) ;
break;
default:
exit(0);
}
}while(scelta!=5);
}

/*Funzione che effettua la scansione del file per individuare le parole
e richiama la funzione di aggiunta di un nuovo elemento all'albero
alfabeto*/
void Scansione (FILE *pf)
{
char *ptr;
char *parola;
char *allocazione;
char c; /*Variabile per la letura dei caratteri dal file di testo*/
char *carattere; /*Variabile utilizzatata per la concatenazione*/
int lung; /*Lunghezza della parola*/

/*Istanziazione e inizializzazione della variabile carattere*/
carattere = malloc(2*sizeof(carattere));
carattere[0]='\0';

/*Istanziazione e inizializzazione della variabile parola*/
parola = malloc(1*sizeof(parola));
parola[0]='\0';

while(!feof(pf)) /*Ripete fino alla fine del file*/
{
c = fgetc(pf);/*Lettura del carattere */

/*Controllo se il carattere Ŕ presente nell'alfabeto*/
if (isalpha(c))
{
/*Calcolo della lunghezza della parola */
lung=strlen(parola);

/*Assgnamento del valore alla variabile carattere*/
carattere[0]=c;
carattere[1]='\0';

if(!(allocazione = realloc(parola,(lung+1)*sizeof(parola))))
{
printf("\n Errore di allocazione della memoria.\n");
exit(0);
}
else
{
parola = allocazione;
}
/*lowercase*/
*carattere = tolower(*carattere);
/*Concatenzazione dei caratteri per formare la parola*/
parola = strcat(parola,carattere);
}
else
{
/*Inserimento della parola*/
if ((parola[0]!='\0'))
{

/*Richiamo della funzione che aggiunge le parole nell'albero
ordinato per alfabeto*/
if (treeA == NULL)
{
/*Aggionamemto della radice */
treeA = AggNodo_TreeA(treeA,parola);
}
else
{
AggNodo_TreeA(treeA,parola);
}
/*Reinizializzazione della variabile parola*/
parola= realloc(parola,sizeof(char));
parola[0]='\0';
}
}
}
/*Chiusura file*/
fclose(pf);
}

/*Funzione di aggiunta di un nodo all'albero*/
struct Albero *AggNodo_TreeA(struct Albero *nodo, char *parola)
{

if (nodo == NULL)
{
/*Creazione nuovo nodo dell'albero*/
if(!(nodo = (struct Albero*) malloc(sizeof(struct Albero))))
{
printf("\n Errore di allocazione della memoria.\n");
exit(0);
}
/*Imposto il valore dei puntatori ai nodi figli*/
nodo->d = NULL;
nodo->s = NULL;
/*Impostazione della frequenza*/
nodo->Elemento.freq = 1;

/*Allocazione della memoria per la stringa contenete la parola*/
nodo->Elemento.parola =
malloc(strlen(parola)*sizeof(nodo->Elemento.parola));
if(nodo->Elemento.parola == NULL)
{
printf("\n Errore di allocazione della memoria.\n");
exit(0);
}
/*Copia della stringa*/
strcpy(nodo->Elemento.parola,parola);

}
else
{
/*Variabile che restituisce il valore della comparazione parola*/
int conf;
/*Comparazione della parola*/
conf = strcmp(nodo->Elemento.parola,parola);

switch(conf)
{
case (1):
nodo->s = AggNodo_TreeA(nodo->s,parola);
break;
case (-1):
nodo->d = AggNodo_TreeA(nodo->d,parola);
break;
default:
/*Se le parole sono uguali incremento il valore della frequenza*/
nodo->Elemento.freq = nodo->Elemento.freq + 1 ;
break;
}
}
return nodo;
}

/*Funzione di stampa dell'albero passato in input*/
void Print(struct Albero *nodo)
{

if (nodo != NULL)
{

/*Richiamo della funzione sul ramo sinistro*/
Print(nodo->s);

if (count == 10 )
{
printf("\n Premere un tasto per continuare...\n");
getchar();
count = 0;
}
else
{
count++;
}
/*Stampa della parola*/
printf("\n PAROLA: %s ", nodo->Elemento.parola);
printf(" FREQUENZA: %d ", nodo->Elemento.freq);

/*Richiamo della funzione sul ramo destro*/
Print(nodo->d);
}
}
struct Albero * AggNodo_TreeF(struct Albero *sorg, struct Albero *dest)
{
if (dest == NULL)
{
/*Creazione nuovo nodo dell'albero*/
dest = (struct Albero*) malloc(sizeof(struct Albero));
/*Imposto il valore dei puntatori ai nodi figli*/
dest->d = NULL;
dest->s = NULL;
/*Impostazione della frequenza*/
dest->Elemento.freq = sorg->Elemento.freq;
/*Allocazione della memoria per la stringa contenete la parola*/
dest->Elemento.parola =
malloc(strlen(sorg->Elemento.parola)*sizeof(dest->Elemento.parola));
if(dest->Elemento.parola == NULL)
{
printf("\n Errore di allocazione della memoria.\n");
exit(0);
}
/*Copia della stringa*/
strcpy(dest->Elemento.parola,sorg->Elemento.parola);
}
else
{
/*Comparazione Frequenza*/
if ( dest->Elemento.freq < sorg->Elemento.freq)
{
dest->s = AggNodo_TreeF(sorg,dest->s);
}
else
{
dest->d = AggNodo_TreeF(sorg,dest->d);
}
}
return dest;
}

/*Funzione che crea l'abero delle frequenze partendo dall'abero ordinato
per
alfabeto passato in input*/
void CreaAlberoF(struct Albero *sorg)
{
if (sorg != NULL)
{
CreaAlberoF(sorg->s);
if (treeF == NULL)
{
treeF = AggNodo_TreeF(sorg, treeF);
}
else
{
AggNodo_TreeF(sorg, treeF);
}
CreaAlberoF(sorg->d);
}
}
Dec 14 '05 #1
Share this Question
Share on Google+
3 Replies


P: n/a

"TC" <te******@inwind.it> wrote in message
news:3C******************@twister2.libero.it...
I'm not a C programmer.
This is a good C?
how check the return value of getch or scanf?
and how check for the \n at the end of the text read?
FEOF do not return true if the file (text file) is finish?
if no what use?
/*Inclusione librerie*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

/*Definizione della strutura Elemento*/
typedef struct
{
char *parola;
unsigned int freq;
}Elem;

/*Definizione della lista delle parole trovate*/
struct Albero
{
Elem Elemento;
struct Albero *s;
struct Albero *d;
};

/*Definizione variabili*/
/*Albero ordinato per alfabeto*/
struct Albero *treeA = NULL;
/*Albero ordinato per frequenze*/
struct Albero *treeF = NULL;

unsigned int count = 0;

/*Definizione funzioni*/
/*Funzione di scansione del file costruzione delle parole e chiamata
della funzione di inseriento nell'albero ordinato per alfabeto*/
void Scansione(FILE *pf);
/*Aggiungi nodo all'albero ordinato per alfabeto*/
struct Albero *AggNodo_TreeA(struct Albero *nodo, char *parola);
/*Stampa albero*/
void Print(struct Albero *nodo);
/*Crea un nuovo albero ordinato per frequenza utilizzando come sorgente
l'albero
ordinato per alfabeto*/
void CreaAlberoF(struct Albero *sorg);
/*Aggiunge un nuovo nodo all'albero ordinato pre frequenze copiando i
valori dal
nodo passato come sorgente*/
struct Albero * AggNodo_TreeF(struct Albero *sorg, struct Albero *dest);
main (void)
{
char scelta;
int fOK;
int g;
/*Nome del file di testo*/
char nf[50];
/*Puntatore al file*/
FILE *pf;
/*MAIN*/
printf("\n Avvio del programma \n");

do
{
fOK = 0;
printf("\nInserire il nome del file di testo che si desidera utilizzare
(Esempio: Testo.txt) \n");

g = fscanf(stdin,"%s",nf); /*Lettura del nome del file */

pf=fopen(nf,"r"); /*Apertura del file in modalitÓ di lettura*/

/*Controllo apertura del file*/
if (pf==NULL)
{
/*Restituzione del messaggio di errore in caso di mancata apertura*/
perror("ERRORE nell'apertura del file");
fOK = 1;

}

}while(fOK != 0);

printf("\n\n");

do
{
scelta = 0;
/*Men¨*/
printf("\n 1- Scansione del file di testo \n");
printf("\n 2- Creazione del file delle parole ordinato per frequenza \n");
printf("\n 3- Stampa a video del file delle parole ordinato per frequenza
\n");
printf("\n 4- Stampa a video del file delle parole ordinato per ordine
alfabetico \n");
printf("\n 5- Esci \n");

do
{
scelta = getchar();
}while(scelta!= '1' && scelta!= '2' && scelta!= '3' && scelta!= '4' &&
scelta!= '5');
count=0;
/*Blocco di scelta*/
switch(scelta)
{
case ('1'):
Scansione(pf);
printf("\n Scansione EFFETTUATA! \n");
break;
case ('2'):
CreaAlberoF(treeA);
printf("\n Lista delle parole ordinata per frequenza creata! \n");
break;
case ('3'):
Print(treeF);
break;
case('4'):
Print(treeA) ;
break;
default:
exit(0);
}
}while(scelta!=5);
}

/*Funzione che effettua la scansione del file per individuare le parole
e richiama la funzione di aggiunta di un nuovo elemento all'albero
alfabeto*/
void Scansione (FILE *pf)
{
char *ptr;
char *parola;
char *allocazione;
char c; /*Variabile per la letura dei caratteri dal file di testo*/
char *carattere; /*Variabile utilizzatata per la concatenazione*/
int lung; /*Lunghezza della parola*/

/*Istanziazione e inizializzazione della variabile carattere*/
carattere = malloc(2*sizeof(carattere));
carattere[0]='\0';

/*Istanziazione e inizializzazione della variabile parola*/
parola = malloc(1*sizeof(parola));
parola[0]='\0';

while(!feof(pf)) /*Ripete fino alla fine del file*/
{
c = fgetc(pf);/*Lettura del carattere */

/*Controllo se il carattere Ŕ presente nell'alfabeto*/
if (isalpha(c))
{
/*Calcolo della lunghezza della parola */
lung=strlen(parola);

/*Assgnamento del valore alla variabile carattere*/
carattere[0]=c;
carattere[1]='\0';

if(!(allocazione = realloc(parola,(lung+1)*sizeof(parola))))
{
printf("\n Errore di allocazione della memoria.\n");
exit(0);
}
else
{
parola = allocazione;
}
/*lowercase*/
*carattere = tolower(*carattere);
/*Concatenzazione dei caratteri per formare la parola*/
parola = strcat(parola,carattere);
}
else
{
/*Inserimento della parola*/
if ((parola[0]!='\0'))
{

/*Richiamo della funzione che aggiunge le parole nell'albero
ordinato per alfabeto*/
if (treeA == NULL)
{
/*Aggionamemto della radice */
treeA = AggNodo_TreeA(treeA,parola);
}
else
{
AggNodo_TreeA(treeA,parola);
}
/*Reinizializzazione della variabile parola*/
parola= realloc(parola,sizeof(char));
parola[0]='\0';
}
} }
/*Chiusura file*/
fclose(pf);
}

/*Funzione di aggiunta di un nodo all'albero*/
struct Albero *AggNodo_TreeA(struct Albero *nodo, char *parola)
{

if (nodo == NULL)
{
/*Creazione nuovo nodo dell'albero*/
if(!(nodo = (struct Albero*) malloc(sizeof(struct Albero))))
{
printf("\n Errore di allocazione della memoria.\n");
exit(0);
}
/*Imposto il valore dei puntatori ai nodi figli*/
nodo->d = NULL;
nodo->s = NULL;
/*Impostazione della frequenza*/
nodo->Elemento.freq = 1;

/*Allocazione della memoria per la stringa contenete la parola*/
nodo->Elemento.parola =
malloc(strlen(parola)*sizeof(nodo->Elemento.parola));
if(nodo->Elemento.parola == NULL)
{
printf("\n Errore di allocazione della memoria.\n");
exit(0);
}
/*Copia della stringa*/
strcpy(nodo->Elemento.parola,parola);

}
else
{
/*Variabile che restituisce il valore della comparazione parola*/
int conf;
/*Comparazione della parola*/
conf = strcmp(nodo->Elemento.parola,parola);

switch(conf)
{
case (1):
nodo->s = AggNodo_TreeA(nodo->s,parola);
break;
case (-1):
nodo->d = AggNodo_TreeA(nodo->d,parola);
break;
default:
/*Se le parole sono uguali incremento il valore della frequenza*/
nodo->Elemento.freq = nodo->Elemento.freq + 1 ;
break;
}
}
return nodo;
}

/*Funzione di stampa dell'albero passato in input*/
void Print(struct Albero *nodo)
{

if (nodo != NULL)
{

/*Richiamo della funzione sul ramo sinistro*/
Print(nodo->s);

if (count == 10 )
{
printf("\n Premere un tasto per continuare...\n");
getchar();
count = 0;
}
else
{
count++;
}
/*Stampa della parola*/
printf("\n PAROLA: %s ", nodo->Elemento.parola);
printf(" FREQUENZA: %d ", nodo->Elemento.freq);

/*Richiamo della funzione sul ramo destro*/
Print(nodo->d);
}
}
struct Albero * AggNodo_TreeF(struct Albero *sorg, struct Albero *dest)
{
if (dest == NULL)
{
/*Creazione nuovo nodo dell'albero*/
dest = (struct Albero*) malloc(sizeof(struct Albero));
/*Imposto il valore dei puntatori ai nodi figli*/
dest->d = NULL;
dest->s = NULL;
/*Impostazione della frequenza*/
dest->Elemento.freq = sorg->Elemento.freq;
/*Allocazione della memoria per la stringa contenete la parola*/
dest->Elemento.parola =
malloc(strlen(sorg->Elemento.parola)*sizeof(dest->Elemento.parola));
if(dest->Elemento.parola == NULL)
{
printf("\n Errore di allocazione della memoria.\n");
exit(0);
}
/*Copia della stringa*/
strcpy(dest->Elemento.parola,sorg->Elemento.parola);
}
else
{
/*Comparazione Frequenza*/
if ( dest->Elemento.freq < sorg->Elemento.freq)
{
dest->s = AggNodo_TreeF(sorg,dest->s);
}
else
{
dest->d = AggNodo_TreeF(sorg,dest->d);
}
}
return dest;
}

/*Funzione che crea l'abero delle frequenze partendo dall'abero ordinato
per
alfabeto passato in input*/
void CreaAlberoF(struct Albero *sorg)
{
if (sorg != NULL)
{ CreaAlberoF(sorg->s);
if (treeF == NULL)
{
treeF = AggNodo_TreeF(sorg, treeF);
}
else
{
AggNodo_TreeF(sorg, treeF);
} CreaAlberoF(sorg->d); }
}


Whilst I understabnd the C (can read it), I can't see the wood for the
blurry trees. Anyone a C -> English converter?
Dec 14 '05 #2

P: n/a
TC wrote:
I'm not a C programmer.
Well, OK... This is a good C?
Not really.
how check the return value of getch or scanf?
and how check for the \n at the end of the text read?
FEOF do not return true if the file (text file) is finish?
if no what use?
Actually it's not of much use. Please see the FAQ (which, being a good
citizen of comp.lang.c, you've already read, yes?)...

/*Inclusione librerie*/ They are *headers*. They are not *libraries*. #include <stdio.h>
#include <string.h>
#include <stdlib.h>

/*Definizione della strutura Elemento*/
typedef struct
{
char *parola;
unsigned int freq;
}Elem;

/*Definizione della lista delle parole trovate*/
struct Albero
{
Elem Elemento;
struct Albero *s;
struct Albero *d;
};

/*Definizione variabili*/
/*Albero ordinato per alfabeto*/
struct Albero *treeA = NULL;
Since it's static, it would be initialized to NULL anyway. /*Albero ordinato per frequenze*/
struct Albero *treeF = NULL;
Similarly.
unsigned int count = 0;
Similarly (albeit, to 0).

Making these explicit, OTOH, doesn't hurt anything.
/*Definizione funzioni*/
/*Funzione di scansione del file costruzione delle parole e chiamata
della funzione di inseriento nell'albero ordinato per alfabeto*/
void Scansione(FILE *pf);
/*Aggiungi nodo all'albero ordinato per alfabeto*/
struct Albero *AggNodo_TreeA(struct Albero *nodo, char *parola);
/*Stampa albero*/
void Print(struct Albero *nodo);
/*Crea un nuovo albero ordinato per frequenza utilizzando come sorgente
l'albero
ordinato per alfabeto*/
void CreaAlberoF(struct Albero *sorg);
/*Aggiunge un nuovo nodo all'albero ordinato pre frequenze copiando i
valori dal
nodo passato come sorgente*/
struct Albero * AggNodo_TreeF(struct Albero *sorg, struct Albero *dest);
main (void) Implicit int has gone away as of C99. Better would be:
int main(void) {
char scelta;
int fOK;
int g;
/*Nome del file di testo*/
char nf[50];
/*Puntatore al file*/
FILE *pf;
/*MAIN*/
printf("\n Avvio del programma \n");

do
{
fOK = 0;
printf("\nInserire il nome del file di testo che si desidera
utilizzare (Esempio: Testo.txt) \n");

g = fscanf(stdin,"%s",nf); /*Lettura del nome del file */ And what happens if the filename is longer than 49 characters? A buffer
overrun, that's what. *Big* security hole.

Using fgets() would be better.
pf=fopen(nf,"r"); /*Apertura del file in modalitÓ di lettura*/

/*Controllo apertura del file*/
if (pf==NULL)
{
/*Restituzione del messaggio di errore in caso di mancata
apertura*/
perror("ERRORE nell'apertura del file");
fOK = 1;

}

}while(fOK != 0);
Think about it. Evenif you don't successfully open the file you get
here. I don't think that's what you want.
printf("\n\n");

do
{
scelta = 0;
/*Men¨*/
printf("\n 1- Scansione del file di testo \n");
printf("\n 2- Creazione del file delle parole ordinato per
frequenza \n");
printf("\n 3- Stampa a video del file delle parole ordinato per
frequenza \n");
printf("\n 4- Stampa a video del file delle parole ordinato per
ordine alfabetico \n");
printf("\n 5- Esci \n");

do
{
scelta = getchar(); Ouch! The function getchar() returns an *int*. How do you expect to
handle an end of file condition? }while(scelta!= '1' && scelta!= '2' && scelta!= '3' && scelta!=
'4' && scelta!= '5');
count=0;
/*Blocco di scelta*/
switch(scelta)
{
case ('1'):
Scansione(pf);
printf("\n Scansione EFFETTUATA! \n");
break;
case ('2'):
CreaAlberoF(treeA);
printf("\n Lista delle parole ordinata per frequenza
creata! \n");
break;
case ('3'):
Print(treeF);
break;
case('4'):
Print(treeA) ;
break;
default:
exit(0);
}
}while(scelta!=5);
}

/*Funzione che effettua la scansione del file per individuare le parole
e richiama la funzione di aggiunta di un nuovo elemento all'albero
alfabeto*/
void Scansione (FILE *pf)
{
char *ptr;
char *parola;
char *allocazione;
char c; /*Variabile per la letura dei caratteri dal file di testo*/ int c; /* for the same reason as stated above */ char *carattere; /*Variabile utilizzatata per la concatenazione*/
int lung; /*Lunghezza della parola*/

/*Istanziazione e inizializzazione della variabile carattere*/
carattere = malloc(2*sizeof(carattere));
carattere[0]='\0';

/*Istanziazione e inizializzazione della variabile parola*/
parola = malloc(1*sizeof(parola));
parola[0]='\0';

while(!feof(pf)) /*Ripete fino alla fine del file*/

Nope. See the FAQ!

At this point, I've become bored. You've posted too much code. The
excessive comments in a language other than that which this newsgroup
uses have become tiring.

In the future, post a relevant, compilable snippet. Deal with one
problem at a time.

HTH,
--ag

--
Artie Gold -- Austin, Texas
http://goldsays.blogspot.com (new post 8/5)
http://www.cafepress.com/goldsays
"If you have nothing to hide, you're not trying!"
Dec 14 '05 #3

P: n/a
TC wrote:
I'm not a C programmer.
This is a good C?
how check the return value of getch or scanf?
and how check for the \n at the end of the text read?
FEOF do not return true if the file (text file) is finish?
if no what use?
It may be better to ask this questions separately with
a small example to illustrate what you mean -- this gives
you a better chance of helpful answers.
Also, a hint as to what the program is supposed to do or
a comment illustrating your problems may help.

/*Inclusione librerie*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h> You forgot <ctype.h> for isalpha() and tolower()

/*Definizione della strutura Elemento*/
typedef struct
{
char *parola;
unsigned int freq;
}Elem;

/*Definizione della lista delle parole trovate*/
struct Albero
{
Elem Elemento;
struct Albero *s;
struct Albero *d;
};

/*Definizione variabili*/
/*Albero ordinato per alfabeto*/
struct Albero *treeA = NULL;
/*Albero ordinato per frequenze*/
struct Albero *treeF = NULL;

unsigned int count = 0;

/*Definizione funzioni*/
/*Funzione di scansione del file costruzione delle parole e chiamata
della funzione di inseriento nell'albero ordinato per alfabeto*/
void Scansione(FILE *pf);
/*Aggiungi nodo all'albero ordinato per alfabeto*/
struct Albero *AggNodo_TreeA(struct Albero *nodo, char *parola);
/*Stampa albero*/
void Print(struct Albero *nodo);
/*Crea un nuovo albero ordinato per frequenza utilizzando come sorgente
l'albero
ordinato per alfabeto*/
void CreaAlberoF(struct Albero *sorg);
/*Aggiunge un nuovo nodo all'albero ordinato pre frequenze copiando i
valori dal
nodo passato come sorgente*/
struct Albero * AggNodo_TreeF(struct Albero *sorg, struct Albero *dest);
main (void) Make it explicit:
int main (void) {
char scelta;
Note that single characters are best contained in an int
as character constants are of type int and many functions
return an int which is either EOF (EOF is always <0) or
a character cast to unsigned char cast to int.
int fOK;
int g;
/*Nome del file di testo*/
char nf[50];
/*Puntatore al file*/
FILE *pf;
/*MAIN*/
printf("\n Avvio del programma \n");

do
{
fOK = 0;
printf("\nInserire il nome del file di testo che si desidera
utilizzare (Esempio: Testo.txt) \n");

g = fscanf(stdin,"%s",nf); /*Lettura del nome del file */
Use either fgets() plus sscanf() or fscanf() with a sensible restriction
on the input length, e.g.
fscanf(stdin, "%49s", nf);
Test whether g equals the number of expected input items, i.e.
if (g != 1)
{ /* Handle error here */ }

pf=fopen(nf,"r"); /*Apertura del file in modalitÓ di lettura*/

/*Controllo apertura del file*/
if (pf==NULL)
{
/*Restituzione del messaggio di errore in caso di mancata
apertura*/
perror("ERRORE nell'apertura del file");
fOK = 1;

}

}while(fOK != 0);

printf("\n\n");

do
{
scelta = 0;
/*Men¨*/
printf("\n 1- Scansione del file di testo \n");
printf("\n 2- Creazione del file delle parole ordinato per
frequenza \n");
printf("\n 3- Stampa a video del file delle parole ordinato per
frequenza \n");
printf("\n 4- Stampa a video del file delle parole ordinato per
ordine alfabetico \n");
printf("\n 5- Esci \n");

do
{
scelta = getchar();
}while(scelta!= '1' && scelta!= '2' && scelta!= '3' && scelta!=
'4' && scelta!= '5');
See above, here you may make a mistake, depending on whether
plain char has the value range of signed char or the value
range of unsigned char.
Better:
int scelta;
In addition, you forget to check for EOF.
while (EOF != (scelta = getchar()))
if (scelta >= (unsigned char) '1' && scelta <= (unsigned char) '5')
break;

As you are following this up with a switch having a default case,
you do not need special error handling for the case scelta==EOF.
count=0;
/*Blocco di scelta*/
switch(scelta)
{
case ('1'):
Scansione(pf);
printf("\n Scansione EFFETTUATA! \n");
break;
case ('2'):
CreaAlberoF(treeA);
printf("\n Lista delle parole ordinata per frequenza
creata! \n");
break;
case ('3'):
Print(treeF);
break;
case('4'):
Print(treeA) ;
break;
default:
exit(0);
This is rather abrupt. Consider issuing an explaining message
along with exiting.
In addition, if you have dynamically allocated memory somewhere,
then you should free it before the termination of your program.
}
}while(scelta!=5);
return 0; }

/*Funzione che effettua la scansione del file per individuare le parole
e richiama la funzione di aggiunta di un nuovo elemento all'albero
alfabeto*/
void Scansione (FILE *pf)
{
char *ptr;
You do not use this one. char *parola;
char *allocazione;
char c; /*Variabile per la letura dei caratteri dal file di testo*/
char *carattere; /*Variabile utilizzatata per la concatenazione*/
int lung; /*Lunghezza della parola*/
This is an int but the return type of strlen() is size_t

/*Istanziazione e inizializzazione della variabile carattere*/
carattere = malloc(2*sizeof(carattere));
carattere[0]='\0';

/*Istanziazione e inizializzazione della variabile parola*/
parola = malloc(1*sizeof(parola));
parola[0]='\0';

while(!feof(pf)) /*Ripete fino alla fine del file*/
Read the comp.lang.c FAQ, it covers how not to use feof()
{
c = fgetc(pf);/*Lettura del carattere */

/*Controllo se il carattere Ŕ presente nell'alfabeto*/
if (isalpha(c))
{
/*Calcolo della lunghezza della parola */
lung=strlen(parola);

/*Assgnamento del valore alla variabile carattere*/
carattere[0]=c;
carattere[1]='\0';

if(!(allocazione =
realloc(parola,(lung+1)*sizeof(parola))))
{
printf("\n Errore di allocazione della memoria.\n");
exit(0);
}
else
{
parola = allocazione;
}
/*lowercase*/
*carattere = tolower(*carattere);
/*Concatenzazione dei caratteri per formare la parola*/
parola = strcat(parola,carattere);
}
else
{
/*Inserimento della parola*/
if ((parola[0]!='\0'))
{

/*Richiamo della funzione che aggiunge le parole
nell'albero
ordinato per alfabeto*/
if (treeA == NULL)
{
/*Aggionamemto della radice */
treeA = AggNodo_TreeA(treeA,parola);
}
else
{
AggNodo_TreeA(treeA,parola);
}
/*Reinizializzazione della variabile parola*/
parola= realloc(parola,sizeof(char));
parola[0]='\0';
}
}
}
/*Chiusura file*/
fclose(pf);
}

/*Funzione di aggiunta di un nodo all'albero*/
struct Albero *AggNodo_TreeA(struct Albero *nodo, char *parola)
{

if (nodo == NULL)
{
/*Creazione nuovo nodo dell'albero*/
if(!(nodo = (struct Albero*) malloc(sizeof(struct Albero))))
{
printf("\n Errore di allocazione della memoria.\n");
exit(0);
}
/*Imposto il valore dei puntatori ai nodi figli*/
nodo->d = NULL;
nodo->s = NULL;
/*Impostazione della frequenza*/
nodo->Elemento.freq = 1;

/*Allocazione della memoria per la stringa contenete la parola*/
nodo->Elemento.parola =
malloc(strlen(parola)*sizeof(nodo->Elemento.parola));
if(nodo->Elemento.parola == NULL)
{
printf("\n Errore di allocazione della memoria.\n");
exit(0);
}
/*Copia della stringa*/
strcpy(nodo->Elemento.parola,parola);

}
else
{
/*Variabile che restituisce il valore della comparazione parola*/
int conf;
/*Comparazione della parola*/
conf = strcmp(nodo->Elemento.parola,parola);

switch(conf)
{
case (1):
nodo->s = AggNodo_TreeA(nodo->s,parola);
break;
case (-1):
nodo->d = AggNodo_TreeA(nodo->d,parola);
break;
default:
/*Se le parole sono uguali incremento il valore della
frequenza*/
nodo->Elemento.freq = nodo->Elemento.freq + 1 ;
break;
}
}
return nodo;
}

/*Funzione di stampa dell'albero passato in input*/
void Print(struct Albero *nodo)
{

if (nodo != NULL)
{

/*Richiamo della funzione sul ramo sinistro*/
Print(nodo->s);

if (count == 10 )
{
printf("\n Premere un tasto per continuare...\n");
getchar();
count = 0;
}
else
{
count++;
}
/*Stampa della parola*/
printf("\n PAROLA: %s ", nodo->Elemento.parola);
printf(" FREQUENZA: %d ", nodo->Elemento.freq);
Correct format:
%u
/*Richiamo della funzione sul ramo destro*/
Print(nodo->d);
}
}
struct Albero * AggNodo_TreeF(struct Albero *sorg, struct Albero *dest)
{
if (dest == NULL)
{
/*Creazione nuovo nodo dell'albero*/
dest = (struct Albero*) malloc(sizeof(struct Albero));
/*Imposto il valore dei puntatori ai nodi figli*/
dest->d = NULL;
dest->s = NULL;
/*Impostazione della frequenza*/
dest->Elemento.freq = sorg->Elemento.freq;
/*Allocazione della memoria per la stringa contenete la parola*/
dest->Elemento.parola =
malloc(strlen(sorg->Elemento.parola)*sizeof(dest->Elemento.parola));
if(dest->Elemento.parola == NULL)
{
printf("\n Errore di allocazione della memoria.\n");
exit(0);
}
/*Copia della stringa*/
strcpy(dest->Elemento.parola,sorg->Elemento.parola);
}
else
{
/*Comparazione Frequenza*/
if ( dest->Elemento.freq < sorg->Elemento.freq)
{
dest->s = AggNodo_TreeF(sorg,dest->s);
}
else
{
dest->d = AggNodo_TreeF(sorg,dest->d);
}
}
return dest;
}

/*Funzione che crea l'abero delle frequenze partendo dall'abero ordinato
per
alfabeto passato in input*/
void CreaAlberoF(struct Albero *sorg)
{
if (sorg != NULL)
{
CreaAlberoF(sorg->s);
if (treeF == NULL)
{
treeF = AggNodo_TreeF(sorg, treeF);
}
else
{
AggNodo_TreeF(sorg, treeF);
}
CreaAlberoF(sorg->d);
}
}


Please correct the above, then come back with _minimal_ examples
to illustrate your problems or an explicit request for a code
review.
Give us all information necessary to help you (this may be more
than you think is necessary, so give as much as you can).
Cheers
Michael
--
E-Mail: Mine is an /at/ gmx /dot/ de address.
Dec 14 '05 #4

This discussion thread is closed

Replies have been disabled for this discussion.