Newsgroup: it.comp.lang.c
Titolo: ok, le stringhe le ho copiate. pero'...

Ho trovato molto piu utile (ed efficace) usare memcpy, che ha risolto
il problema del copiaggio eccelelentemente.
Il guaio e' un altro.
Vi racconto brevemente il mio programmino: vorrebbe ordinare un file
alfabeticamente, stringa per stringa. per farlo, leggo una stringa
alla volta, e la deposito in un elemento di una lista di stringhe in
memoria: lavoro su questa struttura, ordinando le stringhe con
bubblesort, e scrivo l'output in un file di uscita.
(lo so, che e' una porcata di algoritmo: soprassediamo su questo
aspetto :-) )
Il punto e' che il programma funziona (oh, come sono stato contento
quando l'ho visto ordinare le righe di quel file di prova!) con file
grossi fino a 5k o giu di li.
Con la mia lista di mp3, che e' grossa il doppio, windows genera una
'operazione non valida', e linux un 'segmentation fault'.
Porcodiuncane, dico, ho 24 MB di ram, ci stara' un file da 10 k, no?
perche' con un file da 5 k funziona (restituendo un output corretto!)
e con 10 no?
vi scrivo il codice, se qualcuno ha la pazienza di dargli un occhiata,
glie ne saro' molto grato!
/* Sorts a file alphabetically 
string by string, using bubblesort */
#define MAXLENGHT 80
#include <stdlib.h>
#include <stdio.h>
void readline(FILE *text , char string[MAXLENGHT]);
void insstring(char *string,FILE *target);
char buffer[MAXLENGHT];
 
int i; 				// counters
int e; 
 
unsigned int howmany=1;		// total number of strings in the
inputfile
FILE *input;		
FILE *outpt;        
struct line {
	char string[MAXLENGHT];
	struct line *next;
};
struct line *begin;
struct line *actual;
struct line *prox;
struct line *temp;
main(int argc, char *argv[]){
if (argc!=3) {
     printf("\n%s\n%s%s\n\n",
     "Usage: ssort file1 file2 ",
     "file1 strings will be sorted and output will be written in ",
     "file 2.");
     exit(1);  
     }
if (argv[1]==argv[2]){
	printf ("Error: Input and output file are the same! -
bye!\n");     
	exit(0);
	}
if (input=fopen(argv[1],"r"));
     else {
        printf ("Error opening input file \"%s\" - Bye!\n",argv[1]);
     exit(0);
     }
if (getc(input)==EOF){
     printf("The input file is empty! - Have a nice day!\n");
     exit(1);
     }
else fseek(input,-1,SEEK_CUR);
if (outpt=fopen(argv[2],"r+"));
     else {
        printf ("Error opening output file \"%s\" - bye!\n",argv[2]);
     exit(0);
     }
begin=malloc(sizeof(struct line));
actual=malloc(sizeof(struct line));
prox=malloc(sizeof(struct line));
readline(input, begin->string);
actual=begin;
begin->next=actual;
while (getc(input)!=EOF) {
fseek(input,-1,SEEK_CUR);
readline(input,prox->string);
++howmany;
actual->next=prox;
actual=prox;
prox=(malloc(sizeof(struct line)));
prox->next=NULL;
} // while (filling list whit lines)
for (i=1;i<=howmany;++i){
	actual=begin;
	for (e=1;e<howmany;++e) {
if ( memcmp(actual->string,actual->next->string,MAXLENGHT)>0 )
		{		
		memcpy(buffer,actual->string,MAXLENGHT);
	 	memcpy(actual->string,actual->next->string,MAXLENGHT);
		memcpy(actual->next->string,buffer,MAXLENGHT);
		} //if strings are not ordered
	actual=actual->next;
 	} // internal "for" cycle  
} // external "for" cycle  
/*Start writing the output file*/
actual=begin;
for (i=1;i<=howmany;++i){
	fprintf(outpt,actual->string);
	actual=actual->next;
	} // for (printing cycle)
} //main()
void readline(FILE *text, char string[MAXLENGHT])
{
i=0;                     		//this code reads a line
while ( (string[i]=getc(text)) ) { 	//in the input file and store
it
 	if (string[i]=='\n')
		{
		string[i+1]=='\0';
		break; 	//in the "toins" array
		}
  	++i;                         
	}
}// readline()
Ciao
Febs
rimuovere .nane per rispondere
remove.nane to reply

 wrote:
[ snip ]
c>Con la mia lista di mp3, che e' grossa il doppio, windows genera una
c>'operazione non valida', e linux un 'segmentation fault'.
[ snip ]
c>if (argv[1]==argv[2]){
      ^^^^^^^^^^^^^^^^
Qui devi usare
	....
	#include <string.h>
        ....
        if (strcmp(argv[1], argv[2]) == 0) {
		/* ...ecc */
[ snip ]
Forse il problema sta qui.
c>void readline(FILE *text, char string[MAXLENGHT])
c>{
c>i=0;                     		//this code reads a line
c>while ( (string[i]=getc(text)) ) { 	//in the input file and store
c>it
c> 	if (string[i]=='\n')
c>		{
c>		string[i+1]=='\0';
                           ^^
Errore ;)
c>		break; 	//in the "toins" array
c>		}
c>  	++i;                         
c>	}
c>}// readline()
Non tanto nell'errore che ti segnalo, quanto nel fatto che
questa funzione non considera assolutamente MAXLENGHT.
Prova a sostituirla con qualcosa del genere
	....
	#include <string.h>
	....
	void readline(FILE * text, char string[MAXLENGHT])
	{
        	char *c;
        	fgets(string, MAXLENGHT, text);
        	if((c = strchr(string, '\n')))
                	*c = '\0';
	}	
e a vedere se ti da' lo stesso errore. 
Considera che adesso le stringhe *non* sono terminate con 
'\n'.
Ciao ciao,
Andrea
-- 
"...Unix, MS-DOS, and Windows NT (also known as the Good, the Bad, and 
 the Ugly)."
(by Matt Welsh)

e con 10 no?
Ho letto velocemente il codice e noto che non verifichi mai se il
puntatore restituito dalla malloc sia valido (non NULL). Non so se il
tuo problema derivi da questo (dovresti vedere sul compilatore il tipo
di compilazione adottata), ma ti consiglierei di farlo.
_____________________________________________________
Francesco Trotta
http://space.tin.it/computer/ftrotta
elimina "x_" dal mio indirizzo per le risposte

     }
Il messaggio di errore viene fornito se il file viene aperto
correttamente!
if(!(input = fopen(...)))
o, in maniera più leggibile,
if((input = fopen(...)) == NULL)


if((input = fopen(...)) == NULL)
Svista madornale! Il costrutto if era corretto, ma non utilizzato al
meglio. Invece di creare un if con una codnizione per poi utilizzare
la parte else, non potresti utilizzare direttamente un if con la
condizine negata? :-)


> #define MAXLENGHT 80
ECCOLO L'ERRORE! :)
Tu hai definito già in partenza il massimo numero di stringhe che
possono essere ordinate. Cercare di scrivere o leggere nella stringa #80
(partono da 0, quindi la #79 è l'ottantesima e la #80 è l'ottantunesima)
equivale a cercare di accedere ad un area di memoria che il programma
non si è riservato, causando l'errore. Aumenta questo parametro!! Magari
sprechi memoria (allocando 250Kb di memoria per poi dovere ordinare 3
stringhe) ma almeno avrai risolto il problema.
La soluzione migliore, in realtà, sta nell'utilizzare un'allocazione
dinamica della memoria, ma è più complicato (se vuoi che te lo spieghi,
scrivimi!)
Ciao!!
-- 
+ ICEMAZE +
ice...@planet.it
"Digito ergo sum"