Discussion :

[renlel]

Est-il possible de passer un flux en paramètre ? Sur quelle ligne du fichier (en lecture) pointe le flux après son appel dans le programme supérieur ?

[roulious]

Est-il possible de passer un flux en paramètre ?

Oui, mais pas par valeur, vu qu'ils ne disposent pas d'un constructeur de recopie public.

Sur quelle ligne du fichier (en lecture) pointe le flux après son appel dans le programme supérieur ?

À l'endroit où tu l'y a laissé dans la fonction appelée.

[koala01]

Salut,

Il est tout à fait possible de passer un flux en parametre, mais sous forme de référence, et, de préférence non constante...

Il est aussi recommandé d'envisager de renvoyer la référence sur le flux.

Le fait de passer le flux comme référence, c'est pour la raison indiquée par roulios, celui de le passer comme référence non constante, c'est parce qu'en toute logique, ta fonction a de grande chances de modifier le flux (ce qui serait interdit avec une référence constante )

La recommandation d'envisager de renvoyer la référence (non constante) sur le flux en fin de traitement est à prendre en considération si tu souhaites pouvoir faire des appels en série.

Enfin, il peut s'avérer intéressant d'en fait surcharger les opérateurs de flux << et >> pour classe, ce qui te permettra d'utiliser ta classe comme un cin/cout classique

Quelque exemples:

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
#include <iostream>
// je vais travailler sur un fichier pour l'exemple... il faut fstream ;)
#include <fstream>
// et les string
#include <string>
// une classe avec surcharge des opérateurs de flux (fonctionnera avec
// tous types de flux
class surcharge
{
    public:
        surcharge(){}
        ~surcharge(){}
        //surcharge de l'opérateur <<
        // fonctionnera avec tous les flux
        // ref est judicieusement déclarée constante pour
        // éviter la tentation de la modifier
        friend
       std::ostream& operator<<(std::ostream& ofs,const surcharge& ref)
       {
             ofs<<ref.entier<<"\t"<<ref.str<<std::endl;
             // pour permettre la mise en série
             return ofs;
       }
       //surcharge de l'operateur >>
       // comme il faut modifier les valeur de ref, ne pas le déclarer const ;)
        friend
       std::istream& operator>>(std::istream& ifs, surcharge& ref)
       {
           // on lit d'abord entier puis str
           ifs>>ref.entier>>ref.str;
           // pour la mise en série
           return ifs;
       }
    private:
        //les deux membres
        int entier;
        std::string str;
};
//une classe "reader" qui se charge de la lecture
class reader
{
    public:
       // on prend le nom du fichier en parametre du constructeur
       reader(const std::string& filename):filename(filename){}
       ~reader(){}
       // la fonction de lecture
       surcharge* Read()
       {
             //ouverture du fichier
             std::ifstream ifs(filename.c_str());
             //création de l'objet à lire
             surcharge* ret=new surcharge[3];
             // lecture "en série" des informations
             ifs>>ret[0]>>ret[1]>>ret[2];
             return ret;
       }
    private:
        std::string filename;
};
// la preuve que ca fonctionne
int main()
{
    reader read("essai.txt");
	surcharge* verif=read.Read();
	for(unsigned int i=0;i<3;i++)
        std::cout<<verif[i];
    delete verif;
    verif=NULL;
	return 0;
}

crée juste un fichier "essai.txt" qui contien

Code :

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

1
2
3
4
 
1 chaine1
2 chaine2
3 chaine3

pour te faire une idée
(évidemment, ici, les valeurs sont définies en dur... mais ca te fera comprendre le principe )