Discussion :

[Noncolodei]

Bonjour !

Je cherche un méthode pour pouvoir transmettre un fichier à une fonction, comme une variable.

Par exemple :

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
 
#include <fstream>
#include <iostream>
 
using namespace std;
 
ifstream firstFile("file1.txt"); 
ifstream secondFile("file2.txt"); 
 
int main()
{
 fonction (firstFile);
 fonction (secondFile);
}
 
void fonction (/*??? */ file)
{
 char chaine[255];
 file >> chaine;	                  
 while (!entree.eof()) 	      
 {
     cout << chaine[i]<<endl;    
     entree >> chaine[i];}	     
 } 			                  	      
 return 0;
}

Là où j'ai mis des points d'interrogations, je me demande donc si il y a un "type"(comme "int", "char" etc) pour transmettre le fichier ou si je dois m'y prendre autrement...
Donc, pour que la fonction fonctionne avec le fichier 1 et le fichier 2 sans devoir faire 2 fonction différentes...

J'espère que je me suis bien exprimé et que je ne raconte pas des inepties...

Merci d'avance !

[poukill]

Il n'y a pas de type "fichier" en C++. Par contre, on a les flux d'entrées / sorties. (cf FAQ)

Voici ce que tu cherches à faire, grosso modo :

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
 
#include <fstream>
#include <iostream>
#include <string>
 
void fonction (std::ifstream& file)
{
	std::string chaine;
	while (file >> chaine)
	{
		std::cout << chaine << std::endl;
	}
}
 
int main()
{
	std::ifstream firstFile("file1.txt");
	std::ifstream secondFile("file2.txt");
 
	fonction (firstFile);
	fonction (secondFile);
 
	return 0;
}

Les flux se passent par référence !

Bonne continuation,

Poukill

[Goten]

Et accessoirement on test pas la fin d'un fichier via eof() :p

[Sylvain Togni]

Ben si, eof est l'abréviation de End-Of-File

Par contre celui qui s'en sert de condition d'arrêt d'une boucle s'expose à une boucle infinie à la moindre erreur de lecture (ce que tu voulais dire je suppose). On écrira donc plutôt

Code :

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

1
2
3
4
5
	std::string chaine;
	while (file >> chaine)
	{
		std::cout << chaine << std::endl;
	}

[Goten]

En effet, j'ai pas était assez précis : on ne test pas la fin d'un fichier sur eof comme condition de sortie d'une boucle .

[Noncolodei]

Merci beaucoup pour votre aide ! C'est tout à fait ça qu'il me fallait :-D

Merci aussi pour la correction :-)

@+

[koala01]

Salut, et bienvenue sur le forum

Une petite précision qui a son importance en passant:

De manière générale, les variables globales, c'est mal...

Et c'est d'autant plus vrai lorsqu'il s'agit de fichiers, car cela signifie que le fichier est "verrouillé" par l'application jusqu'à ce qu'elle finisse... Ce qui n'est pas vraiment souhaitable

De plus, lorsque l'on décide néanmoins d'avoir recours à une variable globale, c'est généralement en suivant la (très mauvaise) logique selon laquelle le fait que la variable soit globale nous évite d'avoir à la passer en paramètre aux différentes fonctions...

En effet, une variable globale est, par définition, ... accessible à l'ensemble des fonctions...

Cherchez l'erreur dans le fait d'envisager de la transmettre en paramètre à une fonction

ton code d'origine

Code :

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

1
2
3
4
5
6
7
8
ifstream firstFile("file1.txt"); 
ifstream secondFile("file2.txt"); 
 
int main()
{
 fonction (firstFile);
 fonction (secondFile);
}

devrait donc, au minimum être modifié en

Code :

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

1
2
3
4
5
6
7
8
9
int main()
{
    ifstream firstFile("file1.txt"); 
    ifstream secondFile("file2.txt");
    fonction (firstFile);
    fonction (secondFile);
    /* idéalement, main renvoie 0 ;) */
    return 0;
}

Cela n'empêchera pas que file1.txt et file2.txt soient verrouillés durant toute la durée de l'application, mais, au moins, cela justifiera de les passer en paramètre (et te donnera la bonne habitude d'éviter les variables globales comme la peste )

[Noncolodei]

Merci pour la bienvenue ;-)

Je suis tout à fait d'accord avec toi, mais ce n'est pas vraiment moi qui choisit cela... En effet, j'ai un énoncé, mais je l'ai peut être mal interprété :

- Tout d'abord, votre programme chargera en mémoire le dictionnaire ainsi que l'ensemble des lettres (...)
- Ensuite, le jeu peut commencer.(...)

J'en ai donc déduit qu'il fallait mettre les fichiers en mémoire dès le début, et non au fur et à mesure qu'on les utilisait (ici il y a deux fichiers pour les lettres, et un fichier pour le dictionnaire). Qu'en pensez-vous ?

(ENONCE DU PROJET en complet (le paragraphe parlant des fichiers est sur la deuxième page))

Merci en tous cas pour votre aide !

PS : Musson, ce n'est pas au milieu de nulle part en Belgique ! Que pensez-vous de Clairefontaine ? ^^

[koala01]

Merci pour la bienvenue ;-)

Je suis tout à fait d'accord avec toi, mais ce n'est pas vraiment moi qui choisit cela... En effet, j'ai un énoncé, mais je l'ai peut être mal interprété :



J'en ai donc déduit qu'il fallait mettre les fichiers en mémoire dès le début, et non au fur et à mesure qu'on les utilisait (ici il y a deux fichiers pour les lettres, et un fichier pour le dictionnaire). Qu'en pensez-vous ?

Et tu as eu tord: cela veut juste dire que la première chose à faire, c'est de lire le fichier

Fais en outre attention au fait qu'ouvrir un fichier ne signifie absolument pas que le fichier est chargé en mémoire

Pour charger un fichier en mémoire, cela peut très bien prendre une forme générique proche de

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
/* la signature de la fonction, pour pouvoir l'utiliser */
Type readFile(std::string const& filename);
int main()
{
    std::string filename1("fichier1.txt");
    std::string filename2("fichier2.txt");
    Type first = readFile(filename1);
    Type second = readFile(filename2);
    /* suite du programme */
}
/* la définition de la fonction */
Type readFile(std::string const& filename)
{
    /* nous ouvrons le fichier nommé filename */
    ifstream ifs(filename.c_str());
    /* toute la lecture du fichier */
    return var;
} /* le fichier est automatiquement fermé, car ifs est détruit lorsque l'on
   * quitte la fonction
   */

En outre, du coté de ton prof, il y a des coups de pied queque part qui se perdent...

Le SESE (Single Entry, Single Exit) ne doit absolument pas être obligatoire, bien qu'il soit généralement préférable de l'utiliser si, vraiment, il est naturel d'y recourir