comment ouvrir plusieurs fichiers simultanément pour lire dans c

Question

J'essaye de porter une partie de mon code C++ dans c. J'ai la construction suivante

class reader{ 
private: 
FILE *fp; 
alot_of_data data;//updated by read_until() method 
public: 
    reader(const char*filename) 
    read_until(some conditional dependent on the contents of the file, and the arg supplied) 
} 

Im instanciation puis des centaines de ces objets et itérer sur eux en utilisant plusieurs « read_until() » pour chaque fichier jusqu'à ce que AllFiles est EOF. Je n'arrive pas à voir une façon intelligente de faire cela en c, la seule solution que je peux proposer est de faire un tableau de pointeurs FICHIER, et faire la même chose avec toutes les données de membre privées de ma classe.

Mais cela semble très désordonné, puis-je implémenter la fonctionnalité de ma classe comme un pointeur de fonction, ou quoi de mieux, je pense qu'il me manque un motif de conception fondamentale?

Les fichiers sont beaucoup trop gros pour avoir tous en mémoire, la lecture, donc tout de chaque fichier est impossible Merci

Answer 1

Vous créez un type de données abstrait:

typedef struct { 
    FILE *fp; 
    alot_of_data data;//updated by read_until() method 
} reader; 

void init_reader(reader* that, const char* filename); 
void read_until(reader* that, some conditional dependent on the contents of the file, and the arg supplied) 

Ensuite, vous pouvez créer et utiliser des objets de ce type, tout comme avec les objets de la classe, sauf que, au lieu de obj.func(), vous écrivez func(&obj):

reader r; 
init_reader(&r, "blah.txt"); 
read_until(&r, /* ... */); 

Answer 2

Vous pouvez toujours créer une structure pour contenir toutes les informations connexes, puis une boucle sur cela. .. Juste une idée ... (Je pense que C supporte les structures - ça fait un moment ...)

Answer 3

Le principe de cacher des informations est le même, quelle que soit la langue que vous utilisez. Il suffit de déplacer les choses que vous voulez cacher dans le fichier source:

// reader.h 
typedef struct reader reader; 

reader* new_reader(const char*filename); 
void read_until(reader*, ...); 

// reader.c 

struct reader { 
    FILE *fp; 
    alot_of_data data;//updated by read_until() method 
}; 

reader *new_reader(const char*filename) { ... } 
void read_until(reader*, ...) { ... } 

Answer 4

La façon la plus simple est de convertir simplement les données dans un struct:

struct reader 
{ 
    FILE *file; 
    alot_of_data data; 
}; 

Définissez ensuite les fonctions ordinaires, qui prennent struct reader comme leur premier argument:

int reader_construct(struct reader *r, const char *filename) 
{ 
    if((r->file = fopen(filename, "rt")) == NULL) 
    return 0; 
    /* do other inits */ 
    return 1; 
} 

et la fonction de lecture devient:

int read_until(struct reader *r, arguments) 
{ 
    /* lots of interesting code */ 
} 

Alors juste avoir un tableau de structures, appelez reader_construct() sur eux, puis faites les appels read_until() comme requis.

Vous pouvez bien opter cours pour un constructeur plus dynamique, qui renvoie le « objet »:

struct reader * reader_new(const char *filename) 
{ 
    struct reader *r = malloc(sizeof *r); 
    if(r == NULL) 
    return NULL; 
    if(reader_construct(r, filename)) 
    return r; 
    return NULL; 
}