Passage en paramètres de flux de fichier

Version imprimable

Bonjour à tous,

J'ai une routine assez longue à coder de lecture/écriture de fichier et comme certaine partis pourraient être traitées avec des fonction à part, j'aimerais passer en paramètre à ces fonction la position du flux que je lis/écris.

Déjà j'aimerais savoir si c'est possible et ensuite comment on déclare de tels flux dans le passage de paramètre ?
Ce serait quelque chose comme :
void construc_ligne(oftream(?) nomflux, char * [11] nomfich) ?

Comme je ne sais pas si je m'explique bien, voici mon bout de code comme exemple plus concret :

Code:

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
void Dune::build_table(Vecteurdunes vd, int srid, char date[11] , int temps_relatif)
{
    int nbd, j, nbp;
    double nx, ny, nz ;
    Point p;
 
    char nsql[taille];
    ofstream fich(nsql, ios::app);
 
     if(!fich)
         cout<<"... !\n";
     else
     {
        for(int i=0; i<nbd; i++)
        {
 
            if (!entree)
            {
                cout << " \n ...!! \n" ;
            }  
            else // fichier dune ouvert
            {
                while (entree.eof()==false)
                {
                     //fonction lecture fichier
                     entree >> nom; //lecture de la première ligne
                     entree >> id;
                     entree >> nbp;
                     //construction des X de la ligne de crête
                     for (j=0; j<nbp; j++)

A ce stade là je voudrais créer ma fonction de construction de ligne et lui passer en paramètre le flux que j'ai appelé "entree"

Code:

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
                     crete.construc_ligne(oftream(?) entree, char[11] nomfich);
                     {
                         entree >> nx;
                         p.set_x(nx);
                         crete.ajout_point(p);
                     }
                     for (j=0; j<nbp; j++) //construction des Y de la ligne de crête
                     {
                         entree >> ny;
                         p = crete.get_point(j);
                         p.set_y(ny);
                         crete.set_point(p, j);
                     }
                     for (j=0; j<nbp; j++) //construction des Z de la ligne de crête
                     {
                         entree >> nz;
                         p = crete.get_point(j);
                         p.set_z(nz);
                         crete.set_point(p, j);
                     }
                 }
                 crete.L.erase(crete.L.begin(), crete.L.end());
             }//fin fichier dune ouvert
         }//fin pour le i em fichier ouvert du vecteur dune
     }/*FIN SET_info*/
}

Merci d'avance pour vos réponses :)

EDIT : Merci énormément à celui qui a modifié l'apparence du code, c'est beaucoup plus clair comme ça !! J'ai bien tenté de faire comme dans les autres post, mais je n'ai pas réussi à trouver comment faire.

02/09/2010, 23h51
Asohan
Salut,

Je vois bien ce que tu veux dire. Je crois que tu as déjà presque trouvé la bonne solution :). Si je ne m'abuse, il suffit de faire un :
Code:

1 2 TYPE function(ifstream & file, ...)
pour lire un fichier depuis la fonction function, ou bien
Code:

1 2 TYPE function(ofstream & file, ...)
pour écrire. Attention néanmoins à passer le flux par référence &.

Si je me trompe, merci de me corriger ;) car je suis pas certain à 100% de ce que je dis.
03/09/2010, 00h16
akima

Je vais tester ça demain et je te dirais si ça marche : merci pour le conseil en tout cas :)
03/09/2010, 12h06
atha2

Les flux de la stl ne sont pas copiable. Il faut donc les passer en argument soit par référence soit par adresse mais pas par valeur.

La solution d'Asohan doit donc marcher.

Hello à tous les deux !

Alors, voici ce que j'ai déclaré (fichier de la classe "dune.h") :

Code:

bool set_table(ofstream);

Voici comment je l'ai implémenté dans "dune.cpp" (ou peut importe le nom, ce n'est qu'un test tout bête pour le moment) :
Code:

1 2 3 4 5 6 bool Dune::set_table(ofstream & fichtest) { fichtest<<"T.E.S.T _ _ F.O.N.C.T.I.O.N "<<endl; fichtest<<"*** position dans la fonction même et écriture dans le fichier test "<<endl; return 1; }
Voici comment je l'appelle dans une autre fonction (puisque c'est bien là le but) :
Code:

1 2 3 4 5 6 7 8 char * nomtest = new char[20]; bool bip; nomtest = "TEST.txt"; ofstream ftest(nomtest, ios::app); ftest << "Alors voila, c'est un test" << " "<<endl; bip = set_table(ofstream & ftest); cout <<"and the winner is ?" <<bip<<endl;
et voici le message d'erreur qu'il me marque : http://img225.imageshack.us/img225/9518/resue.jpg
Vous avez des idées pour corriger ça ?
Merci d'avance :]

03/09/2010, 20h57
Asohan
Dans le fichier Dune.h, tu dois déclarer le prototype ainsi :

Code:

bool set_table(ofstream & fichtest);

C'est à dire de la même façon que dans le fichier .cpp sinon le compilateur va te faire un caca nerveux :D

Donc : dans le .h
Code:

1 2 TYPE function(/*Liste d'arguments*/);
et dans le .cpp :
Code:

1 2 3 4 5 TYPE function(/*Liste d'arguments IDENTIQUE au .h*/) { // ... }
C'est pour ça que tu as une erreur de prototype does not match.

Sinon pour ton code, tu peux simplement passer le flux :
Code:

1 2 3 4 ... bip = set_table(ftest); ...
pas besoin de mettre de référence ici.

Ah oui et dernière petite chose : ta fonction set_table doit retourner un type bool alors retourne plutôt true que 1 (je sais je chipote sur des détails :P mais c'est pour la lisibilité du code).

Ok, j'ai bien tout noté. Je teste ça demain et je te dirais. Maintenant, sur le point de mettre la même chose dans le ".h" que le ".cpp", ce n'est pas toujours exact. Je m'explique. Regarde ces fonctions :
Code:

1 2 3 4 void build_table(Vecteurdunes, int, char date[11], int); void export_geomSQL(char *, int, char *, int, int); Ligne build_polygone(Ligne, char *);
Dans le .cpp elles sont déclarées comme ceci :
Code:

1 2 3 4 5 6 void Dune::build_table(Vecteurdunes vd, int srid, char date[11] , int temps_relatif) {...} void Dune::export_geomSQL(char * nsql, int srid, char * nfpoly, int idp, int temps_relatif) {...} Ligne Dune::build_polygone(Ligne l, char * nfpoly) {...}
Je n'ai pas précisé les noms des variables dans le ".h" et pourtant ça marche (le programme compile et me fait bien ce qui est demandé tout ça). Là j'ai voulu faire pareil.
Mais sinon je vais quand même tester, on ne sais jamais.

Pour le booléen en réalité je ne sais pas trop quoi en faire : honnêtement il ne me sert pas vraiment. Une fonction de type "void" me conviendrait mieux, mais je crois qu'à ce moment là je suis obligé de l'appliquer à un objet non ?
Si c'est bien ça alors ça n'ira pas non plus, je n'ai rien sur lequel l'appliquer... bon bon bon... je vais y réfléchir...

Bonne nuit, et merci pour l'aide, c'est vraiment sympa :]

04/09/2010, 08h57
hiura

C'est une question de signature. Elle doit être identique dans le .h (déclaration) et dans le .cpp (implémentation).

La signature d'une fonction c'est son nom ainsi que le type de ses paramètres.

Ex :
int main(int argc, char** argv) => main(int, char**)
bool write_data(stream& a_stream) => write_data(stream&)

Note : le type de retour n'est pas inclus dans la signature.

Note : stream != stream&. Ce sont deux type différents. L'un est «brut», l'autre est une référence. Dans la signature, ils ne sont pas interchangeable.

Note : tu peux très bien avoir qqch comme :
int f(int, char, stream&); // .h
int f(int i, char c, stream&); // .cpp, pas de nom pour une variable signifie qu'elle ne sera pas utilisée.

PS : je marque toujours le nom des variables dans le .h, histoire que les paramètres soient compréhensible lors de l'utilisation des divers fonctions sans pour autant devoir passer par une documentation (commentaires du style «le 4ème paramètre est blablabla», ou doc externe quelconque).
04/09/2010, 09h02
hiura
Hum, j'avais pas vu :

Citation:

Envoyé par akima

Pour le booléen en réalité je ne sais pas trop quoi en faire : honnêtement il ne me sert pas vraiment. Une fonction de type "void" me conviendrait mieux, mais je crois qu'à ce moment là je suis obligé de l'appliquer à un objet non ?

Une fonction retournant void n'est pas plus différente d'une retournant int, bool, ou un type de ta concoctions. L'«Objet» n'a rien à voir là dedans. ;)

Par exemple, je peux avoir :
Code:

1 2 3 void hello(std::string const & name) { std::cout << "Hello, " << name << "\n"; }
et l'utiliser simplement comme ceci :
Code:

1 2 3 4 5 int main() { hello("John"); return 0; }
04/09/2010, 11h49
akima

@Asohan : MERCI !! C'est nickel ça marche du feu de dieu 8-)

@hiura : d'accord, je vois. Si j'ai bien compris, dans le ".h" nous pouvons ou non décider de mettre le nom des variable alors ? Sauf que dans certain cas ça passe (pour des variables standard type int, bool, char, etc...) mais dans le cas de variables bizarres (définies par moi ou dans le cas de flux), ça ne marche pas... C'est ça ?
Désolé si mes questions paraissent débiles, je n'ai pas codé depuis un paquet d'années et je ne suis même pas informaticien à la base (surtout qu'on nous avait appris majoritairement du procédural, moins de l'orienté objet). J'ai su tout ça mais copieusement oublié ^_^
Pour la fonction, Je viens de modifier le bool en void : effectivement ça tourne impeccablement bien.

Sujet résolu donc : merci infiniment à tous pour le temps passé à me répondre :ccool:
04/09/2010, 20h27
hiura

Citation:

Envoyé par akima

@hiura : d'accord, je vois. Si j'ai bien compris, dans le ".h" nous pouvons ou non décider de mettre le nom des variable alors ? Sauf que dans certain cas ça passe (pour des variables standard type int, bool, char, etc...) mais dans le cas de variables bizarres (définies par moi ou dans le cas de flux), ça ne marche pas... C'est ça ?

J'ai pas bien compris tes cas «bizarres». Mais il y a pas de règles étranges contrairement à la l'allemand et toutes ces exceptions. :aie:

Ce que j'ai écris en dessus s'applique de manière globale, il n'y a pas de cas particulier.
05/09/2010, 12h12
akima

Citation:

Envoyé par hiura

J'ai pas bien compris tes cas «bizarres». Mais il y a pas de règles étranges contrairement à la l'allemand et toutes ces exceptions. :aie:

Ce que j'ai écris en dessus s'applique de manière globale, il n'y a pas de cas particulier.

Ah d'accord, c'est noté. :ccool: