C - How can I read data from a file (Considering that I use structures for it)

Question

Good night.

I’m working on a project for the College in C where I have a data structure to work with the data common to "Offenders," or those who committed an infraction.

typedef struct Infractores
{
    int ordemdeEntrada;//ordem de entrada da infração ... começa em 1 acaba em N
    char *marca;
    char *modelo;
    char *matricula;
    double valorportagem;
    int classeVeiculo;
    struct Infractores *seguinte;
};

If you’ve noticed I’m using pointers to *marca , *modelo ... and I have a struct Infractores *seguinte;. This happens because of having to implement lists in the project.

I happen to want to implement a method of reading the latest offenders from a file, for example those who committed offences yesterday. To achieve this I also developed a method:

void ListaInfractoresAnteriores(Infractores *f)
    {
        const char *filenameinfractors = "C:/Users/Vitor/documents/visual studio 2013/Projects/AED II/Resolucao_Teste/Projecto/VVManager/lastdayinfractors.txt";
        FILE *ficheiroInf = fopen(filenameinfractors, "r");
        //struct TesteInfractores auxiliar;
        struct Infractores *auxiliar;
        auxiliar = f;
        while (!feof(ficheiroInf))
        {

            if (fscanf(ficheiroInf, "%d %s %s %lf %d \n", &auxiliar->ordemdeEntrada, *auxiliar->marca, *auxiliar->modelo, &auxiliar->valorportagem, &auxiliar->classeVeiculo) != NULL)
            {
                printf("Marca %s",*auxiliar->marca);
            }


        }
    }

In this method I try to test on what if the input of mine fscanf() for <> (different) from NULL (Null), so he must write the mark, in this case the car, which committed the infringement.

I absolutely cannot read the file using this data structure. How can I read data from the file taking into account that did not want to use a new data structure? Do I have to create new variables?

Note: I intend to use the data structure to manipulate files and manipulate lists.

Answer 1

As you say you should implement chained lists, there is no way to avoid using pointers. Below I made an implementation that uses the list. It is still liable to amend the void ListaInfractoresAnteriores(Infractores * listaDeInfratores) so that you have the list of Offenders in the main function.

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

typedef struct infractores
{
    int ordemdeEntrada; //ordem de entrada da infração ... começa em 1 acaba em N
    char * marca;
    char * modelo;
    char * matricula;
    double valorportagem;
    int classeVeiculo;
    struct infractores * seguinte;

} Infractores;

Infractores * criaInfrator(int ordemDeEntrada, char * marca, char * modelo,
                           double valorportagem, int classeVeiculo){
    Infractores * f = (Infractores *) malloc (sizeof(Infractores));
    f->ordemdeEntrada = ordemDeEntrada;

    f->marca = malloc((strlen(marca)+1)*sizeof(char));
    strcpy(f->marca, marca);
    f->marca[strlen(marca)] = '\0';

    f->modelo = malloc((strlen(modelo)+1)*sizeof(char));
    strcpy(f->modelo, modelo);
    f->modelo[strlen(modelo)] = '\0';

    f->valorportagem = valorportagem;
    f->classeVeiculo = classeVeiculo;
    f->seguinte = NULL;

    return f;
}

void ListaInfractoresAnteriores(Infractores * listaDeInfratores){

    int i;
    int count = 0;

    FILE *fp;

    Infractores * p;

    int ordemEntrada, classeVeiculo;
    double valorPortagem;
    char marca[10], modelo[10];

    if((fp = fopen("lastdayinfractors.txt", "r")) != NULL){

        for(i = 0; !feof(fp); i++, count++)
        {
            fscanf(fp, "%d %s %s %lf %d\n",
                   &ordemEntrada, marca, modelo,
                   &valorPortagem, &classeVeiculo);

            if(i==0){
                p = criaInfrator( ordemEntrada, marca, modelo, valorPortagem, classeVeiculo);
                listaDeInfratores = p;
            }else{
                p->seguinte = criaInfrator( ordemEntrada, marca, modelo, valorPortagem, classeVeiculo);
                p = p->seguinte;
            }
        }

        p = listaDeInfratores;
        while(p!=NULL){
            printf("Marca: %s\n", p->marca);
            p=p->seguinte;
        }

        fclose(fp);
    }
    else
        puts("Não foi possível abrir o arquivo.");
}

int main(void)
{
    Infractores * listaDeInfratores;

    ListaInfractoresAnteriores(listaDeInfratores);

    return 0;
}

Answer 2

The easiest way is to create an array of structures, the hardest way would be to organize your own data structure. With array, simply to read and show I would:

#include <stdio.h> 

typedef struct infractores
{
   int ordemdeEntrada;
   char marca[20];
   char modelo[20];
   char matricula[20];
   double valorportagem;
   int classeVeiculo;
   struct infractores *seguinte;

} Infractores;

void ListaInfractoresAnteriores(Infractores f[]){

   int i;            /* índice dos arrays de struct */
   int n_linhas = 0; /* número linhas que serão lidas 
                        para uso no controle de exibição */

   FILE *fp;

   if((fp = fopen("problema.dat", "r")) != NULL){
      /* Percorre o arquivo até o fim incrementando o contador 
         do array struct e também o número de linhas */
       for(i = 0; !feof(fp); i++, n_linhas++)
       {
           fscanf(fp, "%d %s %s %lf %d\n", 
               &f[i].ordemdeEntrada, f[i].marca, f[i].modelo,
               &f[i].valorportagem, &f[i].classeVeiculo);   
       }
       /* Mostra até a última linha lida, que deve ter valor menor
          que a capacidade do array inserido. */
       for(i = 0; i < n_linhas; i++)
           printf("Marca: %s\n", f[i].marca);   

       fclose(fp);  
   }
   else
       puts("Não foi possível abrir o arquivo.");
}

/* Testando a função com um array de 50 structs */
int main(void)
{
   Infractores f[50];

   ListaInfractoresAnteriores(f);

   return 0;
}

In which I used a 2-line file for testing (remembering that the matrix used fits 50 structures):

10 Ferrari Bluhm 1.999 29
20 Fusca rafael 4.54 21

Exit

Marca: Ferrari
Marca: Fusca

Now, for dynamic uses of structures "loaded" by the file I recommend using a data structure of its own - including using this pointer that self-references the structure - instead of using arrays.