Discussion :

[A_B]

Bonjour,
Depuis un moment j essaye d'effectuer une lecture sur un fichier mais je rencontre toujours une erreur .
En fait jai un objet qui contient un tableau dynamique .
Donc un pointeur, et dans les methodes je le construit en fonction de la taille demandée qui est a son tour un attribut de la meme classe .

Le probleme c'est que pour lire ce genre de structure il faut bien donner a la fonction file.read un parametre adresse dobjet, dans lequel on effectuera la copie .

Comment fonctionne cette instruction Fread ? Et comment il pourra faire la lecture sachant que la taille de lobjet sur le fichier est inconnu a cause du tableau dynamique qu il contient ?

Merci

[koala01]

Salut,

La gestion des tableaux créés dynamiquement est - à n'en pas douter - l'un des cas les plus "peau de banane" que l'on puisse rencontrer en C et en C++...

C'est la raison pour laquelle, quand on programme en C++, le premier conseil à donner est de préférer les classes proposées par le standard à toute possibilité issue du C.

Ainsi, tu aura surement bien plus facile à gérer ta structure si tu remplace le tableau dynamique par un objet de type vector, fourni par le standard dans l'espace de noms std et disponible par inclusion du fichier d'en-tête <vector>.

De la même manière, et pour la même raison, tu devrais t'intéresser de près aux classes de gestion de fichier ifstream (pour la lecture) et/ou ofstream (pour l'écriture), également disponibles dans l'espace de noms std mais grace à l'inclusion du fichier d'en-tête... <fstream> cette fois.

Pour le reste, si tu veux une aide plus précise, il serait sympa de ta part de nous fournir un exemple du code que tu as déjà créé, et de nous expliquer clairement le problème auquel tu es confronté...

Ta question d'origine est effectivement beaucoup trop générale pour que l'on puisse t'apporter une aide efficace

[A_B]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class qcm
{
private:
 
 
 
public:
	int taille  ;
	Question *tab_quest;
	qcm(void);
	void Create_Data(void);
	void Save_Data(void);
	void Load_Data(void);
	void Set_taille(int a );
	int Get_taille(void) ;
public:
	~qcm(void);
};

Voila lobjet en question .
En fait j'arrive a l'ecrire sur un fichier .
Mais j arrive pas a le lire en faisant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

f.Write(&qcm1,sizeof(qcm));

Et je demande comment je pourrai faire, pour lire des entites pareilles, quand il ya un tableau dynamique par exemple .
Sachant qu'on connait pas la taille prealable de l element qu on va lire du fichier !

Merci

[Davidbrcz]

regarde du coté de boost:::serialization, ya un tuto ici par JolyLoic.

[koala01]

Ce qui serait surtout pas mal, c'est d'abandonner l'idée de l'allocation dynamique de la mémoire, et de se diriger vers le conteneur standard qui te semble le plus adapté à ce que tu veux faire...

Tu remplacerais ainsi avantageusement ton

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Question *tab_quest;

par un (par exemple)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

std::vector<Question> tab_quest;

qui te permettrait de supprimer le membre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int taille;

car disponible via

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

tab_quest.size();

De cette manière, lors de la lecture, tu commencerais "simplement" par lire le nombre d'informations à rajouter, et tu ferais une boucle "toute simple" qui pourrait prendre une forme proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
size_t sizeToRead;
file>>sizeToRead;
for(size_t i=0;i<sizeToRead;++i)
{
    std::string answer;
    file>>answer;
    /* vérification éventuelle*/
    tab_quest.push_back(answer);
}

Au passage, étant donné qu'il n'y a sans doute pas lieu de modifier les différetes valeurs une fois que ta variable de type qcm a été créée, il semblerait opportun de placer les membres size et tab_quest en accessibilité private: et de fournir des accesseurs constant pour les valeur représentées

[A_B]

Merci pour la solution ;-)

Mais c'est important pour moi de garder la taille car en fait elle n'est pas fixe, et l'objet est créé avec une taille qui dépend de lutilisateur, donc je pense que c'est important c'est pour cela que j'ai opté pour la solution dynamique .

Sion

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
size_t sizeToRead;
file>>sizeToRead;
for(size_t i=0;i<sizeToRead;++i)
{
    std::string answer;
    file>>answer;
    /* vérification éventuelle*/
    tab_quest.push_back(answer);
}

Sinon pourquoi vous avez choisi string answer .
Dans mon cas ca ne sera pas un objet de type qustion comme dans ma definition de classe ?

Merci

[koala01]

ce n'est effectivement qu'un fuate d'attention de ma part...

Mais, pour ce qu'il en est de la taille, elle est, en tout état de cause, liée au nombre d'éléments que ta classe va contenir.

Tu ne peux en effet pas courir le risque que la taille soit mise à jour, alors que le nombre d'élément n'a pas effectivement changé.

Si ca venait à être le cas, tu courrais le risque d'essayer d'accéder au onzième élément, alors... qu'il n'y en a encore que dix.

Au final, ce que tu dois présenter comme interface est bien plus... ce qui permet de gérer les questions:
une méthode d'ajout d'une question (qui s'occupe de mettre le nombre d'éléments au passage)
un méthode qui permet - éventuelllement - d'en supprimer
une méthode qui permet de chercher une question (voir de "sélectionner" une question, si tu veux faire intervenir un élément aléatoire)
et la fameuse méthode permettant... de savoir combien d'éléments sont présents.

En relisant le code, je me rend d'ailleurs compte que tu propose les accesseurs et les mutateurs, pour des membres... publics, ce qui n'a à l'extrème limite aucun intérêt.

Je remarque aussi que tu devrais penser à respecter la "const correctness": le fait que chaque méthode ne devant pas modifier l'objet soit déclarée constante.

Au final, ta classe qcm devrait ressembler à

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class qcm
{
    public:
	qcm();
	~qcm();
	void Save_Data() const; // la sauvegarde ne modifie pas l'objet
	void Load_Data();
	int Get_taille() const; // le fait de demander la taille ne
                                   // modifie pas l'objet
        {
            return tab_quest.size();
        }
        void addQuestion(const Question& q)
        {
            tab_quest.push_back(q); // la mise à jour de la taille est 
                                    // automatique
        }
        const Question& findQuestion(const std::string& ) const;
        const Question& selectQuestion() const; // selection "aléatoire"
        void eraseQuestion(const std::string&); // facultatif
        {
             std::vector<Question>::iterator it;
             /* recherche de la question à supprimer */
             tab_quest.erase(it); // la mise à jour de la taille est 
                                  // automatique
        }
    private:
        std::vector<Question> tab_question;
};

[A_B]

D'accord !
Je te remercie pour la clarté de tes réponses, c'est vraiment bien clair ;-)

Parcontre jai quelque chose que je voudrais bien verifier :

Notre Vecteur est bien de taille variable et donc pour le lire du fichier il faudrait bien preciser la taille , et de part avant d'effectuer la lecture je ne sais pas vraiment quelle sera la taille de l'objet sur le fichier, donc ca me posera des problèmes au niveau de la lecture !!

Merci

[koala01]

Bon, prenons un exemple concret: tes question, les propososition et la réponse se trouvent dans un fichier prenant une forme proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
questionnaire:
nombre_question : 5
question1 : que fait...
nombre_proposition : 3
proposition1 : blabla
proposition2 : truc
proposition3 : machin
reponse: 3 (c'est la proposition 3 qui est valide)
question2: ???
nombre_proposition : 2
proposition1 : ...

Lorsque tu veux lire le questionnaire,(donc au sein de la méthode Load_Data() ):

1. tu ouvre le fichier
2. tu lis la première ligne
3. tu vérifie que le contenu est bien composé de nombre_question + (symbole de séparation) + un nombre
4. tu lance une boucle, toute simple, sous la forme de
   

   Code :

   Sélectionner tout - Visualiser dans une fenêtre à part

   1
   2
   3
   for(int i = 0; i< (le nombre lu); ++i)
   {
   }

   • Dans la boucle, tu crée un objet de type Question, qui prend le relais de la lecture
   • il commence par placer la question dans le membre qui est prévu à cet effet
   • puis il lit ne nombre de propositions, et il entre dans une boucle, toute aussi simple, sous la forme de
     

     Code :

     Sélectionner tout - Visualiser dans une fenêtre à part

     1
     2
     3
     for(int i = 0;i<(nombre de propositions); ++i)
     {
     }

   • Au sein de cette boucle, l'objet de type Question lit les différentes possibilités, et les ajoute dans le tableau des possibilités, sous une forme proche de
     

     Code :

     Sélectionner tout - Visualiser dans une fenêtre à part

     1
     2
     3
     4
     5
     6
     for(int i = 0;i<(nombre de propositions);++i)
     {
         std::string prop;
         ifs>>prop;
         tab_propositions.push_back(prop);
     }

   • après la boucle, l'objet lit la solution, et la place dans le membre prévu à cet effet.
   • L'objet de type Question a maintenant fini, et est entièrement créé.
5. l'objet de type QCM peut donc terminer son travail, et, au final, la méthode ressemblera à
   

   Code :

   Sélectionner tout - Visualiser dans une fenêtre à part

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   void Load_Data()
   {
       std::ifstream ifs("nom_du_fichier.txt");
       std::string temp;
       ifs>>temp;
       if(temp!="nombre_question")
       {
           /* il y a un malaise ici */
       }
       char c;
       int nb_question;
       ifs>>c>> nb_question;
       for(int i = 0;i<nb_question; ++i)
       {
           Question toadd;
           toadd.Load_data(ifs);
           tab_questions.push_back(toadd);
       }
   }

Ici, bien sur, il y a énormément d'adaptation à effectuer, de vérifications à prévoir, et de trucs dépendant de ton cas personnel à envisager, mais le but ici était de te donner l'occasion de comprendre le principe

[A_B]

Ok !

Merci infiniment pour m'avoir expliqué si clairement avec exemple en plus ;-)
Je sais que je suis un peu lourd , mais si je voudrais utilisé les fichiers binaires est ce qu il y aura une solution a mon probleme ?

Parce que en fait j'ai opté pour cette solution face au fichier texte .

Merci !

[koala01]

Ok !

Merci infiniment pour m'avoir expliqué si clairement avec exemple en plus ;-)
Je sais que je suis un peu lourd , mais si je voudrais utilisé les fichiers binaires est ce qu il y aura une solution a mon probleme ?

Parce que en fait j'ai opté pour cette solution face au fichier texte .

Merci !

Sur ce coup là, il faudra quand même me dire ce qui peut t'avoir poussé à choisir le fichier binaire...

En effet, les cas dans lesquels il devient utile / nécessaire / indispensable (biffer les mentions inutiles ) d'utiliser un fichier de "type binaire" sont suffisemment rares et tu ne te trouve, pour être honnête, dans aucun de ces cas.

[A_B]

En fait tout d'abord je ne veux pas vraiment travailler avec les fichies textes car cela me parait pas vraiment propre vu qu il faudrait prevoir des caracteres de marquages et tout ce qu il ya derriere .
En plus les donnees seront lisibles en fichier texte, ce qu il ne doit pas etre le cas pour mon projet !!!
Donc pour moi je pense que utiliser les fichier binaires cest plus propres , moins de gestion a faire , lecture de champs facile et reccuperation de données en une seule instrcution de lecture !

Voilà

Merci

[ram-0000]

...vu qu il faudrait prevoir des caracteres de marquages et tout ce qu il ya derriere .

Pas compris, tu veux parler des entêtes dans les fichiers unicode, utf8, et autres joyeusetés ?

En plus les donnees seront lisibles en fichier texte, ce qu il ne doit pas etre le cas pour mon projet !!!

Utiliser un fichier binaire ne les rendra pas moins lisibles. La seule chose qui enlève la lisibilité, c'est le chiffrement. Toute solution intermédiaire est un leurre.

Donc pour moi je pense que utiliser les fichier binaires cest plus propres , moins de gestion a faire , lecture de champs facile et reccuperation de données en une seule instrcution de lecture !

Pas moins mais pas plus de gestion que dans un fichier texte.

Je suis tout à fait d'accord avec koala01, dans ce cas précis, l'usage d'un fichier texte est indiqué.

[koala01]

Pour la première raison, je pourrais te répondre que tu dispose de plusieurs possibilité, qui vont d'un fichier CSV ("coma Separated Value") au fichier XML, en passant par des caractères peut utilisés dans le cas d'un QCM parmi @#|

Pour la deuxième raison exposée, tu pourrais parfaitement envisager une encryption des données.

S'agissant uniquement de "cacher" les infos à un lecteur indélicat, une simple méthode de Cesar pourrait parfaitement suffire serait, finalement, très facile à mettre en oeuvre, et aurait au demeurant plus de chances de "résister" à une personne mal intentionnée.

En effet, si tu décide de te diriger vers un fichier binaire, tu devra

1. soit décider d'une "taille constante" pour chacune des chaines de caractères
2. soit indiquer la taille de chaque chaine avant d'indiquer la chaine en question
3. Quoi qu'il en soit, analyser le fichier "caractère par caractère"

pour arriver à tes fins.
Or, on peut reprocher à la méthode

• pour le[1]
  1. que tu ne pourras que difficilement, surtout si des questions sont susceptible d'être rajouter, arriver à déterminer la taille de la chaine la plus longue
  2. pour toutes les autres, que tu provoquera une "perte d'espace" d'autant plus importante que la chaine est petite
• pour le [1] le [2]et le [3]de rendre beaucoup plus complexe le processus de validation et d'analyse du fichier et de récupération des données.

le tout, sans *réellement* fournir une sécurité plus importante vis à vis des personnes mal intentionnées: un simple éditeur hexadécimal suffisant à rendre le texte accessible

Mettons nous d'accord: je comprend parfaitement les raisons qui t'ont incité à te diriger vers un fichier au "format binaire", mais mon but ici est de te démontrer que ce sont finalement de mauvaise raisons pour le faire, et que tu peux arriver à rejoindre tes impératifs de manière bien plus facile en en restant dans un "format texte"

[EDIT]Grilled