将文件逐行读取到 C 中的字符串数组中

Question

I'm trying to read the following file line by line into an array of strings where each line is an element of the array:

AATGC
ATGCC
GCCGT
CGTAC
GTACG
TACGT
ACGTA
CGTAC
GTACG
TACGA
ACGAA

My code is as follows:

void **get_genome(char *filename) {
    FILE *file = fopen(filename, "r");
    int c;
    int line_count = 0;
    int line_length = 0;
    for (c = getc(file); c != EOF; c = getc(file)) {
        if (c == '\n') line_count++;
        else line_length++;
    }
    line_length /= line_count;
    rewind(file);

    char **genome = calloc(line_length * line_count, sizeof(char));
    for (int i = 0; i < line_count; i++) {
        genome[i] = calloc(line_length, sizeof(char));
        fscanf(file, "%s\n", genome[i]);
    }

    printf("%d lines of %d length\n", line_count, line_length);

    for (int i = 0; i < line_count; i++)
        printf("%s\n", genome[i]);
}

However, for some reason I get garbage output for the first 2 elements of the array. The following is my output:

`NP��
�NP��
GCCGT
CGTAC
GTACG
TACGT
ACGTA
CGTAC
GTACG
TACGA
ACGAA

Answer 1

You seem to assume that all lines have the same line length. If such is the case, you still have some problems:

• the memory for the row pointers is allocated incorrectly, it should be

   char **genome = calloc(line_count, sizeof(char *));

or better and less error prone:

    char **genome = calloc(line_count, sizeof(*genome));

• the memory for each row should be one byte longer the the null terminator.

• \n is the fscanf() format string matches any sequence of whitespace characters. It is redundant as %s skips those anyway.

• it is safer to count items separated by white space to avoid miscounting the items if the file contains any blank characters.

• you do not close file .

• you do not return the genome at the end of the function

• you do not check for errors.

Here is a modified version:

void **get_genome(const char *filename) {
    FILE *file = fopen(filename, "r");
    if (file == NULL)
        return NULL;
    int line_count = 1;
    int item_count = 0;
    int item_length = -1;
    int length = 0;
    int c;
    while ((c = getc(file)) != EOF) {
        if (isspace(c)) {
            if (length == 0)
                continue;  // ignore subsequent whitespace
            item_count++;
            if (item_length < 0) {
                item_length = length;
            } else
            if (item_length != length) {
                printf("inconsistent item length on line %d\", line_count);
                fclose(file);
                return NULL;
            }
            length = 0;
        } else {   
            length++;
        }
    }
    if (length) {
        printf("line %d truncated\n", line_count);
        fclose(file);
        return NULL;
    }
    rewind(file);

    char **genome = calloc(item_count, sizeof(*genome));
    if (genome == NULL) {
        printf("out of memory\n");
        fclose(file);
        return NULL;
    }
    for (int i = 0; i < item_count; i++) {
        genome[i] = calloc(item_length + 1, sizeof(*genome[i]));
        if (genome[i] == NULL) {
            while (i > 0) {
                free(genome[i]);
            }
            free(genome);
            printf("out of memory\n");
            fclose(file);
            return NULL;
        }
        fscanf(file, "%s", genome[i]);
    }
    fclose(file);

    printf("%d items of %d length on %d lines\n",
           item_count, item_length, line_count);

    for (int i = 0; i < item_count; i++)
        printf("%s\n", genome[i]);

    return genome;
}

Answer 2

 char **genome = calloc(line_length * line_count, sizeof(char));

must be

char **genome = calloc(line_count, sizeof(char*));

or more 'secure'

char **genome = calloc(line_count, sizeof(*genome));

in case you change the type of genome

else the allocated block if not enough long if you are in 64b because line_count is 5 rather than 8, so you write out of it with an undefined behavior

You also need to return genome at the end of the function

It was also possible to not count the number of lines and to use realloc to increment your array when reading the file

Answer 3

As I see the lines have the same length. Your function should inform the caller how many lines have been read. There is no need of reading the file twice. There is no need of calloc (which is more expensive function). Always check the result of the memory allocation functions.

Here is a bit different version of the function:

char **get_genome(char *filename, size_t *line_count) {
    FILE *file = fopen(filename, "r");
    int c;
    size_t line_length = 0;
    char **genome = NULL, **tmp;

    *line_count = 0;
    if(file)
    {
        while(1)
        {
            c = getc(file);
            if( c == EOF || c == '\n') break;
            line_length++;
        }    
        rewind(file);

        while(1)
        {
            char *line = malloc(line_length + 1);
            if(line)
            {
                if(!fgets(line, line_length + 1, file))
                {
                    free(line);
                    break;
                }
                line[line_length] = 0;
                tmp = realloc(genome, (*line_count + 1) * sizeof(*genome));
                if(tmp)
                {
                    genome = tmp;
                    genome[*line_count] = line;
                    *line_count += 1;
                }
                else
                {
                    // do some memory free magic
                }
            }
        }
        fclose(file);
    }
    return genome;
}