C：从一个文件读取，排序，然后输出到另一个

Question

I'm just getting into C and I figured this would be a good exercise. I've been putsing around with fgets trying to read from a file and I am just doing something wrong. I would like to enter the file name to read, enter the file name to output to, create that file, sort it (just a list of words), and then dump the sorted list into the created file. I know I should be doing something like:

char strIn[25];
printf("Enter a source filename: ");
fgets(strIn, 25, stdin);
printf("You entered: %s \n", strIn);
FILE *infile;    
infile = fopen(strIn, "r");
if (infile == NULL){
    printf("Unable to open file.");
}


char strOut[25];
printf("Enter a destination filename: ");
fgets(strOut, 25, stdin);
printf("You entered: %s \n", strOut);
FILE *outfile;

Any help is appreciated! Thank you

Answer 1

fgets puts the newline character \\n at the end of your buffer. So you need to remove it.

int length = strlen(strIn);
if ( length > 0 && strIn[length-1] == '\n' )
    strIn[length-1] = '\0';

Answer 2

You are on the right track. qsort will do what you want. The approach used here is not scalable; everything is held in memory and static allocation will make things HUGE very quickly, but it works as a toy example. At the moment it will break once there are more than 1000 lines in the input file.

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

#define MAXNAMELEN 100
#define MAXLINELEN 100
#define MAXITEMS 1000

int main(int argc, char ** argv) {

    FILE * infile, * outfile;
    // Statically allocated -- dastardly!
    char name[MAXNAMELEN];
    char line[MAXLINELEN];
    char lines[MAXITEMS][MAXLINELEN];
    int i, items = 0;

    printf("Enter a source filename: ");
    fgets(name, sizeof(name), stdin);
    name[strlen(name)-1] = '\0'; // strip newline
    // No error checking -- ANYWHERE -- dastardly!
    infile = fopen(name, "r");
    while (fgets(line, sizeof(line), infile)) {
            strcpy(lines[items], line);
            items++;
    }

    qsort(lines, items, MAXLINELEN, strcmp);

    printf("Enter a destination filename: ");
    fgets(name, sizeof(name), stdin);
    name[strlen(name)-1] = '\0'; // strip newline
    outfile = fopen(name, "w");
    for (i=0; i<items; i++) {
        fputs(lines[i], outfile);
    }

    fclose(infile);
    fclose(outfile);
}

Answer 3

Now with dynamic allocation and error-checking (possibly an improvement on than the version above). Sorts /usr/share/dict/words (99171 lines) no problem at all. Still requires that the entire array be held in memory. See External Sorting for a way around that.

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

#define CHUNKLEN 100 
#define INITITEMS 1000

/* Reads a string from stream into buffer until a newline or EOF.  
   buffer is dynamically allocated (and reallocated if necessary) 
   to ensure the string fits. Returns the number of characters put
   into the buffer (zero if EOF and no characters read), or -1 on error. */

int unlimited_read(char ** buffer, FILE * stream) {

    int bufl = CHUNKLEN;
    int strl = 0;
    char * chunk = (char *)malloc(CHUNKLEN);

    if ( (*buffer = (char *) malloc(CHUNKLEN)) == NULL ) {
        perror("memory error (malloc)");
        return -1;
    }

    while (fgets(chunk, CHUNKLEN, stream) != NULL) {

        strcpy(*buffer + strl, chunk);
        strl += strlen(chunk);

        if ( (strl == bufl - 1 ) && *(*buffer + strl - 1) != '\n')  {

            // lengthen buffer
            bufl += CHUNKLEN - 1;
            if ( (*buffer = realloc(*buffer, bufl)) == NULL ) {
                perror("memory error (realloc)");
                return -1;
            }

        } else {
            // This shouldn't fail -- we're only ever making it smaller
            *buffer = realloc(*buffer, strl);
            return strl;
        }

    } // while

    // If fgets returned NULL and we are not at EOF, it didn't work
    return feof(stream) ? strl : -1;
}

/* Compare two strings given pointers to those strings.
   Routine is courtesy of the qsort man page */

int cmpstringp(const void *p1, const void *p2) {
    return strcmp(* (char * const *) p1, * (char * const *) p2);
}

/* Sort lines in a file.  File must end with a newline. */
int main(int argc, char ** argv) {

    FILE * infile, * outfile;
    char * inname, * outname, *tmpstr;
    char ** lines;
    int ret, tmp, nlines, i, items = 0;

    if (argc != 3) {
        printf("Usage: %s file_to_sort output_file\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    inname = argv[1];
    outname = argv[2];  

    if ( (lines = malloc(INITITEMS * sizeof(char *))) == NULL) {
        perror("memory error (malloc)");
        exit(EXIT_FAILURE);
    }

    nlines = INITITEMS;

    infile = fopen(inname, "r");
    while ((ret = unlimited_read(&lines[items], infile)) > 0) {
            items++;
            if (items == nlines) {
                nlines += INITITEMS;
                lines = realloc(lines, (nlines * sizeof(char *)));
            }
    }

    if (ret < 0) {
        printf("WARNING: possibly truncated file\n");
    }

    tmpstr = lines[items - 1]; // Final line in file
    tmp = strlen(tmpstr); 
    if (tmpstr[tmp - 1] != '\n') {
        printf("Error: input file does not end with newline\n");
        exit(EXIT_FAILURE);
    }

    qsort(lines, items, sizeof(char *), cmpstringp);

    outfile = fopen(outname, "w");

    for (i = 0; i < items; i++) {
        fputs(lines[i], outfile);
        free(lines[i]);
    }
    free(lines);

    fclose(infile);
    fclose(outfile);
}