Copier fichier vers un tableau

Fermé
dav1994 Messages postés 20 Date d'inscription samedi 28 juin 2008 Statut Membre Dernière intervention 18 août 2015 - Modifié par dav1994 le 17/08/2015 à 20:05
Bonjour,

Voici l'énoncé complet des fonctions de copier de fichiers vers le tableau ainsi que l'entièreté du code

le code compile et tout fonctionne mais y a-t-il moyen de réaliser la fonction de copie vers le tableau sans utiliser de doubles pointeurs (celle -ci n'a pas été abordée au cours et c'est complexe à réaliser)

Merci beaucoup de votre aide

1.1Afficher le contenu d'un fichier
Fonctionnalité à développer

Il faut afficher le contenu du fichier à l'écran, chaque enregistrement apparaissant sur 1 ligne.

Structure d'un enregistement

Chaque enregistrement aura la structure suivante :
  • un champ représentant un pseudo (chaîne de 34 caractères significatifs + 1 caractère pour le « NULL terminator »)
  • 3 champs (3 entiers sur 4 octets) pour représenter la date de naissance (jour, mois et année)


1.2Afficher le contenu du tableau
Il faut afficher le contenu du tableau à l'écran, à raison de 5 enregistrements maximum par page, chaque enregistrement apparaissant sur 1 ligne.

1.3Copier le contenu d'un fichiers vers le tableau
Fonctionnalité à développer

La fonctionnalité à développer consister à copier tous les enregistrements d'un fichier dans un tableau de structures, à la suite des enregistrements précédents

Remarques
  • Si le tableau est déjà prérempli, il faudra alors ajouter les nouveaux enregistrements à la suite des précédents.
  • La fonctionnalité doit être opérationnelle quel que soit le nombre d'éléments contenu dans le fichier (le fichier peut d'ailleurs être vide)
  • Le tableau manipulé devra contenir un nombre de cases exactement égal au nombre d'éléments contenus dans celui-ci (il ne faut donc pas travailler avec un tableau de taille énorme et n'en manipuler qu'une partie).


1.4Remplacer le tableau par le contenu d'un fichier
La fonctionnalité à développer consister à copier tous les enregistrements d'un fichier dans un tableau de structures, à la place des enregistrements précédents.

Remarques

Ici, on parle bien de remplacer l'intégralité du tableau.

2Contraintes
1.Il faut compléter le programme de base fourni

2.Chaque "case" du "switch" de "principal()" doit faire appel à une fonction

3.Le programme doit contenir un en-tête avec votre nom, votre prénom et votre classe

4.Ne pas utiliser de variable globale

5.Ne pas utiliser la notation indicée pour manipuler les tableaux à 1 dimension, mais utiliser uniquement la notation par pointeur (sauf pour les chaînes de caractères)

6.Ne pas utiliser de passage de paramètre par référence, mais seulement des passages par adresse

7.Les fichiers doivent être ouverts (et fermés) dans chaque fonctionnalité principale du menu, et non pas seulement en début (et en fin) de programme
/* QUESTIONNAIRE D */

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;

/******************************************************/
/* */
/* DEFINITION DES STRUCTURES */
/* */
/******************************************************/

struct enregistrement
{
char pseudo[34];
int jour, mois, annee;
};

/******************************************************/
/* */
/* PROTOTYPES DES FONCTIONS */
/* */
/******************************************************/

void lireFichier(char *nom_fichier);
void creerFichier();
void copierContenuTableau(char *nom_fichier, int *cptdata, struct enregistrement **pdata);
void afficherContenuTableau(int *cptdata, struct enregistrement *pdata);
void remplacerTableau(char *nom_fichier, struct enregistrement **pdata, int *cptdata);


/******************************************************/
/* */
/* CODE DES FONCTIONS */
/* */
/******************************************************/

/***************************************************************************************************************************
  • La fonction "lireFichier()" :
  • - Permet de lire un fichier
  • ENTREE : le nom du fichier à lire
  • SORTIE : /
  • /

/***************************************************************************************************************************/

void lireFichier(char *nom_fichier)
{
struct enregistrement data;
FILE* fichier;
fichier = fopen(nom_fichier, "rb");
while (fread(&data, sizeof(struct enregistrement), 1, fichier)>0)
{
cout << data.pseudo << " ";
cout << data.jour << "/";
cout << data.mois << "/";
cout << data.annee << endl;
}
fclose(fichier);
system("pause");
}

void creerFichier()
{
struct enregistrement data;
FILE* fichier;
fichier = fopen("fichier.gwe", "wb");

cout << "Pseudo : ";
cin.ignore();
gets(data.pseudo);
cout << "Jour de naissance : ";
cin >> data.jour;
cout << "Mois de naissance : ";
cin >> data.mois;
cout << "Annee de naissance : ";
cin >> data.annee;
fwrite(&data, sizeof(struct enregistrement), 1, fichier);
fclose(fichier);
}

/***************************************************************************************************************************
  • La fonction "copierContenuTableau()" :
  • - Permet de copier le contenu du tableau
  • ENTREE : le nom du fichier à lire
  • SORTIE : /
  • /

/***************************************************************************************************************************/

void copierContenuTableau(char *nom_fichier, int *cptdata, struct enregistrement **pdata)
{
struct enregistrement data;
FILE* fichier;
fichier = fopen(nom_fichier, "rb");
while (fread(&data, sizeof(struct enregistrement), 1, fichier)>0)
{
if ((*pdata = (struct enregistrement *) realloc(*pdata, (*cptdata + 1) * sizeof(struct enregistrement))) == NULL)
{
cout << "Pas assez de memoire !";
}
strcpy((*pdata)[*cptdata].pseudo, data.pseudo);
(*pdata)[*cptdata].jour = data.jour;
(*pdata)[*cptdata].mois = data.mois;
(*pdata)[*cptdata].annee = data.annee;

(*cptdata)++;
}
fclose(fichier);
system("pause");
}

/***************************************************************************************************************************
  • La fonction "afficherContenuTableau()" :
  • - Permet d'afficher le contenu du tableau
  • ENTREE : le nom du fichier à lire
  • SORTIE : /
  • /

/***************************************************************************************************************************/

void afficherContenuTableau(int *cptdata, struct enregistrement *pdata)
{
if (pdata == NULL)
{
cout << "Le contenu du tableau est vide." << endl;
}
else
{
for (int i = 0; i < *cptdata; i++)
{
cout << pdata[i].pseudo << " ";
cout << pdata[i].jour << "/";
cout << pdata[i].mois << "/";
cout << pdata[i].annee << endl;

}
}
system("pause");
}

/***************************************************************************************************************************
  • La fonction "remplacerTableau()" :
  • - Permet de remplacer le tableau
  • ENTREE : le nom du fichier à lire
  • SORTIE : /
  • /

/***************************************************************************************************************************/

void remplacerTableau(char *nom_fichier, struct enregistrement **pdata, int *cptdata)
{
free(*pdata);
  • pdata = NULL;
  • cptdata = 0;

copierContenuTableau(nom_fichier, &(*cptdata), &(*pdata));
afficherContenuTableau(&(*cptdata), &(**pdata));

}

/***************************************************************************************************************************
  • La fonction "afficherMenu()" :
  • - affiche le menu
  • - et gère la saisie du choix de l'utilisateur

*
  • ENTREE : /
  • SORTIE : le choix de l'utilisateur
  • /

int afficherMenu(void){
// 0. Déclaration des variables
int choix;

// 1. Affichage du menu
system("cls");
cout << "Voulez-vous : " << endl << endl;
cout << "[1] Afficher le contenu du 1er fichier" << endl;
cout << "[2] Afficher le contenu du 2eme fichier" << endl;
cout << "[3] Copier le contenu du 1er fichier dans le tableau" << endl;
cout << "[4] Copier le contenu du 2eme fichier dans le tableau" << endl;
cout << "[5] Remplacer le tableau par le contenu du 1er fichier" << endl;
cout << "[6] Remplacer le tableau par le contenu du 2eme fichier" << endl;
cout << "[7] Afficher le contenu du tableau" << endl;
cout << "[8] Quitter le programme" << endl << endl;
cout << "Votre choix : ";

// 2. Saisie du choix de l'utilisateur + validation automatique
cin >> choix;
while (choix<1 || choix>8){
cout << "Erreur. Saisissez une autre valeur : ";
cin >> choix;
}

// 3. Le choix est renvoyé au programme appelant
return choix;
}

/***************************************************************************************************************************
  • La fonction "programmePrincipal()" :
  • - gère l'affichage du menu (en boucle)
  • - permet de réaliser la fonctionnalité choisie

*
  • ENTREE : /
  • SORTIE : rien
  • /

void programmePrincipal(){
// 0. Déclaration des variables
int choix;
int cptdata = 0;
struct enregistrement *pdata = NULL;
do{
// 1. Affichage du menu + saisie du choix de l'utilisateur
choix = afficherMenu();

// 2. On réalise le choix de l'utilisateur
switch (choix){
case 1: lireFichier("fichier1.gwe");
break;
case 2: lireFichier("fichier2.gwe");
break;
case 3: copierContenuTableau("fichier1.gwe", &cptdata, &(pdata));
break;
case 4: copierContenuTableau("fichier2.gwe", &cptdata, &(pdata));
break;
case 5: remplacerTableau("fichier1.gwe", &(pdata), &cptdata);
break;
case 6: remplacerTableau("fichier2.gwe", &(pdata), &cptdata);
break;
case 7: afficherContenuTableau(&cptdata, &(*pdata));
break;
}
} while (choix != 8);
}

/******************************************************/
/* */
/* PROGRAMME PRINCIPAL */
/* */
/******************************************************/
int main(){

// 1. Ecran d'accueil
system("cls");
cout << "Examen du 16 juin 2015" << endl << endl;
system("pause");

// 2. Gestion du menu et des fonctionnalités du programme
programmePrincipal();

// 3. Fin du programme
system("cls");
cout << "Fin du programme" << endl << endl;
return 0;
}