Renseigner le champ d'un classe lors d'une lecture de fichier par le Set

Renseigner le champ d'un classe lors d'une lecture de fichier par le Set_

Bonjour,
je me demande s'il est possible de renseigner directement un champ lors de la phase de lecture d'un fichier.

Je souhaite faire un truc qui ressemble a ça.

class.hpp

Code:

1
2
3
4
5
6
7
8
9
10
11
class classSolutionMatrice
{
    public:
        classSolutionMatrice();
        ~classSolutionMatrice();
        int Get_nbPersonnes() { return _nbPersonnes; }
        void Set_nbPersonnes(int val) { _nbPersonnes = val; }
 
    private:
        int _nbPersonnes;
};

Mon Code

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include "class.hpp"
/*.......Reste de mon code.....*/
int lecture (classSolutionMatrice& maMatrice)
{
    ifstream sourceFile (FICHIERTEXTE);
    if (sourceFile.is_open()){
    {
       maMatrice.Set_nbPersonnes(reinterpret_cast <int>(sourceFile)) ; //Mettre la premiere chaine de caractère lue et transtipée dans maMatrice._nbPersonnes
             // Je n'e sais pas si utiliser reinterpret_cast est le plus judicieux
       sourceFile.close();
       return 0;
    }
    else  {  return-1; }
}

Merci de m'apporter un peux de lumière là dessus.

Cordialement

Kosen

Code:

1
2
3
4
5
6
7
8
9
10
ifstream sourceFile (FICHIERTEXTE);
if (sourceFile.is_open()){
{
	int readBuf = 0;
	sourceFile >> readBuf;
	maMatrice.Set_nbPersonnes(readBuf);
	sourceFile.close(); // pas nécessaire ici
	return 0;
}
return -1;

Il faut donc passer par une variable intermédiaire.
Merci

Voir aussi std::istream_iterator, qui évitera l'utilisation de variables tampon dans ce genre de cas :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
#include <iterator>
 
ifstream sourceFile(FICHIERTEXTE);
if (sourceFile.is_open())
{
	maMatrice.Set_nbPersonnes(*istream_iterator<int>(sourcefile));
 
	// ou plus proprement :
 
	istream_iterator<int> it(sourcefile), itend;
	maMatrice.Set_nbPersonnes(it!=itend ? *it : 0);
 
	return 0;
}
 
return -1;

Salut,

Ceci dit, on ne le répétera sans doute jamais assez, le fait d'exposer un mutateur sur le nombre de personnes ne me semble clairement pas idéal :aie:

Je m'explique :

Soit le nombre de personnes est défini une bonne fois pour toute dans le constructeur de ta classe et n'est plus susceptible d'être modifié, auquel cas, tu l'auras compris, il n'y a pas lieu de fournir le mutateur,
Soit la gestion du nombre de personnes peut évoluer selon les besoins de ta classe, mais, à ce moment là, il y a, de nouveau, deux possibilités :

Soit elle augmente et diminue ce nombre selon sa propre logique en fonction de ses besoins
Soit tu dois demander explicitement d'augmenter (ou de diminuer) ce nombre en fournissant non pas le nombre total, mais une valeur correspondant à la différence que tu veux observer, avec des fonctions plus proches de increaseCapacity ou de decreaseCapacity
En effet, la présence d'une fonction setXXX implique, hors de cette fonction de lecture (dont je parlerai un peu plus tard ;)), que c'est à l'utilisateur de veiller à ce que la valeur qu'il fournit à la fonction soit cohérente avec la valeur actuelle de _nbPersonnes et se traduira généralement par un code proche de
Code:

1 2 3 int temp = obj.Get_nbPersonnes(); /* la logique qui te permet d'évaluer le nouveau nombre de personnes */ obj.Set_nbPersonnes(temp);
avec le gros problème que "la logique qui permet d'évaluer le nouveau nombre de personnes" risque de se retrouver dupliquée un peu partout dans ton code, en violation du conseil DRY (Don't Repeat Yourself, ou, si tu préfères en francais : Ne te répétes pas) :aie:

Par contre, si tu divise cet accesseur en deux comportements distincts donnant à ta classe la forme de
Code:

1 2 3 4 5 6 7 8 9 10 11 class classSolutionMatrice { public: classSolutionMatrice(); ~classSolutionMatrice(); int Get_nbPersonnes() { return _nbPersonnes; } void augmenterNbPersonnes(int difference){_nbPersonnes+= difference;} void diminuerNbPersonnes(int difference){_nbPersonnes-= difference;} private: int _nbPersonnes; };
(notes au passage que l'utilisation de l'underscore comme préfix pour les membres est, théoriquement, réservée à l'implémentation du compilateur, tu devrais le placer en suffixe plutot ;))

Tu n'auras plus à t'inquiéter du nombre de personnes actuel, mais seulement à indiquer de combien il faut augmenter (ou diminuer) le nombre de personne, et la logique qui s'y rapplique ne sera plus dupliquée.

Bien sur, je ne peux pas m'empêcher de revenir sur le premier point que j'indiquais : La responsabilité qui concerne la décision d'augmenter ou de diminuer le nombre de personnes devrait sans doute beaucoup plus incomber à la classe elle-même qu'à l'utilisateur de celle-ci ;)

Reste la fameuse fonction de lecture car tout ce que j'ai écrit jusqu'à présent semble pour le moins incompatible avec une telle fonction :aie:

Mais, ce qu'il est important de constater, c'est qu'il n'y a que cette fonction de lecture (et sa fonctions inverse d'écriture éventuelle) qui méritent d'avoir un "droit d'accès particulier" au contenu de la classe, et, non seulement à _nbPersonnes, mais, sans doute, à l'ensemble des membres qui composent la classe.

Dans ce cas, la solution est, sommes toutes, toute simple : l'amitié est faite exactement pour cela, car nous sommes visiblement dans une situation où elle permet d'augmenter significativement la portée de l'encapsulation ;)

Tu pourrais donc modifier une dernière fois ta classe pour qu'elle prenne la forme de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 class classSolutionMatrice { friend int lecture (classSolutionMatrice& maMatrice); /* si tu veux pouvoir le lire, tu voudras sans doute aussi pouvoir la lire ;) friend int ecriture(classSolutionMatrice& maMatrice); */ public: classSolutionMatrice(); ~classSolutionMatrice(); int Get_nbPersonnes() { return _nbPersonnes; } void augmenterNbPersonnes(int difference){_nbPersonnes+= difference;} void diminuerNbPersonnes(int difference){_nbPersonnes-= difference;} private: int _nbPersonnes; };