How to read from a file and parse it

Question

I have a file .txt containing some values formatted like this:

0,30,25,10

Now, I open up the file and store it into an array

char imposta_tratt[300]; 

FILE *fp;
fp = fopen("/home/pi/Documents/imposta_trattamento.txt", "r");
if (fp == 0) return;
fread(imposta_tratt, sizeof(imposta_tratt), 1, fp);
fclose(fp);

Now I expect to have the array filled with my data. I have the values separated by a , so I go on and parse it:

const char delim[2] = ",";
int t=0;
char *token = strtok(imposta_tratt, delim);
    while (token!=NULL){
    
        strcpy(tratt[t],token);
        token = strtok(NULL, delim);
        tratt[t]=token;
        t++;
    }

Here, referring to what's in the file .txt, I expect to have tratt[0]=0; tratt[1]=30; tratt[2]=25; and so on, but seems like I am missing something since it's not like this.

All I want is to have the values of the txt file stored in single variables. Can someone help?

Answer 1

What you are trying to achieve can simply be done using fgets():

bool read_file_content(const char *filename, const size_t tsizemax, int tratt[tsizemax], size_t *tsize, const char *delim)
{
    // Attempt to open filename.
    FILE *fp = fopen(filename, "r");
    if (!fp) return false; // Return false upon failure.
    
    // Try to read one line. If you have more, you need a while loop.
    char imposta_tratt[300];
    if (!fgets(imposta_tratt, sizeof imposta_tratt, fp)) {
        fclose(fp);
        return false;
    }
    
    *tsize = 0;
    char tmp[300]; // Temporary buffer. Used for conversion into int.
    char *token = strtok(imposta_tratt, delim);
    
    while (token && *tsize < tsizemax) {
        strncpy(tmp, token, sizeof tmp);
        tratt[(*tsize)++] = atoi(tmp);
        
        token = strtok(NULL, delim);
    }
    
    fclose(fp);
    return true;
}

• const char *filename: The file you want to parse.
• const size_t tsizemax: The maximum size of your tratt array. It is important to control the size, otherwise your code will have buffer overflow (think of when your file has more than 100 tokens, for example).
• int tratt[tsizemax]: The array that will hold the values.
• size_t *tsize: The number of tokens read (used in combination of tsizemax).
• const char *delim: The delimiter(s), in your case a ,.

This is your main():

int main(void)
{
    int tratt[100];
    size_t size = 0;
    
    if (!read_file_content("in.txt", 100, tratt, &size, ",")) {
        puts("Failed");
        return 1;
    }
    
    for (size_t i = 0; i < size; ++i)
        printf("%d\n", tratt[i]);
}

Output:

0
30
25
10

Answer 2

Suppose "in.txt" has contents

0,30,25,10

The below program uses fscanf to read the integers into the tratt array, one-by-one. As we read integers using fscanf, we make sure it's return value is as expected. If not, we close the file and exit. In the event that the return value of fscanf is not as expected, the program also prints which type of error occurred. Currently, if any error occurs, the program stops. However, you can make the program behave differently depending on the error that occurred if you like.

As output, the program prints all of the integers read into the tratt array. The output is

0
30
25
10

Now this program assumes we know the number of elements we want to read into tratt. If we do not, we could allow for dynamically allocating more memory should the array need more elements or perhaps "in.txt" could contain a data structure, say, at the beginning/end of the file that records information about the file, such as the number of numbers in the file and the data type (a binary file would be best suited for this). These are just a couple of the possibilities.

A better approach might be to read characters in one-by-one (say, using getc) and use strtol to convert a sequence of character digits to a long int (I would have taken an approach similar to this).

Nevertheless, this approach is more succinct and should suffice.

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

#define FILE_NAME "in.txt"
#define MAX_LEN 4

int main(void) {

    int i, tratt[MAX_LEN];
    FILE *fp = fopen(FILE_NAME, "r");      /* open file for reading */

    /* if cannot open file */
    if (fp == NULL) {

        printf("Cannot open %s\n", FILE_NAME);
        exit(EXIT_FAILURE);

    }

    /* read integer, checking return value of scanf as expected */
    if (fscanf(fp, "%d", &tratt[0]) != 1) {
        if (ferror(fp))
            printf("fscanf: read error\n");
        else if (feof(fp))
            printf("fscanf: end of file\n");
        else
            printf("fscanf: matching failure\n");

        fclose(fp);
        exit(EXIT_FAILURE);
    }

    for (i = 1; i < MAX_LEN; i++)
        /* read comma plus integer, checking return value of scanf */
        if (fscanf(fp, ",%d", &tratt[i]) != 1) {
            if (ferror(fp))
                printf("fscanf: read error\n");
            else if (feof(fp))
                printf("fscanf: end of file\n");
            else
                printf("fscanf: matching failure\n");

            fclose(fp);
            exit(EXIT_FAILURE);

        }
    fclose(fp);    /* close file */

    /* print integers stored in tratt */
    for (i = 0; i < MAX_LEN; i++)
        printf("%d\n", tratt[i]);

    return 0;

}