Discussion :

[diFaenza]

Bonjour à tous.
Vous allez trouver ma question idiote mais je n'ai pas trouvé la réponse ni dans la faq ni dans les forums.

Je tente de passer au flux pour mes fichiers (avant, j'étais un adepte de cstdio).
Je ponds donc ceci

Code :

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

1
2
3
  ofstream MyFile("toto.txt");
  MyFile<<"je teste";
  MyFile.close();

Jusque là, que du bonheur.

Par contre, lorsque je veux réouvrir le même fichier avec le même flux dans la même fonction

Code :

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

	ifstream MyFile("toto.txt");

le compilateur me gronde avec un "Declaration multiple pour 'MyFile'"

J'en conclus qu'il n'a pas détruit MyFile.
Donc, comment détruire MyFile?

delete plante et lorsque je tente

Code :

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

MyFile.~ofstream();

ça passe mais j'ai toujours le même message de déclaration multiple.
Je pressens que c'est tout con mais je ripe....

G.

[Alp]

C'est juste que tu utilises le même nom de variable
Bien qu'il s'agisse du même fichier, en mémoire un ifstream et un ofstream sont totalement différents.
L'ofstream s'occupe d'écrire et contient des attributs/fonctions pour ce faire, alors que l'ifstream est pour la lecture seulement.

En gros tu créés 2 objets complètement différents (bien que cela soit pour travailler sur un même fichier) mais avec le même nom de variable. Et ceci n'a pas de sens pour le compilateur.

[diFaenza]

Mais euh... la mémoire est-elle vraiment libérée?

[Alp]

Je ne comprends pas ta question.

Quand tu crées le ofstream nommé MyFile, tu as des informations qui vont se placer en mémoire.
Quand tu veux créer le ifstream nommé MyFile également, cela voudrait dire que tu voudrais donc placer en mémoire d'autres informations (relatives à la lecture dans un fichier), mais avec le même nom que pour le ofstream. Donc tu aurais un même nom pour 2 zones mémoires différentes -> aucun sens.

Par contre, les deux zones mémoires seront bien libérées à la fin de ton bloc d'instructions (normalement quand tu arriveras au premier } qui suit).

Donc même s'il s'agit du même fichier que tu veux traiter, il faut donner 2 noms de variables différents. Car les deux objets que tu vas manipuler sont de nature différente ! L'un est pour écrire des données et l'autre est pour lire des données, même si c'est par rapport au même fichier.

Ce que tu pourrais faire, c'est appeler ton ofstream MyFileOut par exemple, et appeler ton ifstream MyFileIn.

[Garulfo]

Mais euh... la mémoire est-elle vraiment libérée?

Disons qu'il n'y a plus de fichier attaché au manipulateur MyFile.
Tu ne peux réutiliser l'identificateur pour une autre variable d'un type différent puisque celui-ci est dans la portée de la fonction encore.
Ça ne se fait pas en C++: son type ne peut changer en cours de route.
D'ailleurs tu peux réouvrir un fichier sans avoir à redéclarer MyFile c'est donc que le programme sait que c'est un identificateur et connais son type:

Code c++ :

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

1
2
3
4
5
6
7
  ofstream MyFile("toto.txt");
  MyFile<<"je teste";
  MyFile.close();
 
  MyFile.open("titi.txt");
  MyFile << "je reteste" << endl ; // penses à mettre des endl à la fin
  MyFile.close();

[koala01]

Salut,

Pour être précis: une variable (et surtout son identifiant, pour le compilateur) existe du moment de sa déclaration au moment où on passe l'accolade fermante de la paire d'accolade qui entoure la déclaration.

Ainsi, on peut dire que

Code :

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

1
2
3
4
5
6
 
{
    type mavar;//mavar existe à partir d'ici
/*320 lignes... ou plus */
 
}//mavar cesse d'exister ici

Tant que la variable existe, le compilateur refusera que tu déclare une nouvelle variable (quel qu'en soit le type) portant le même nom.

Tu peux donc travailler de deux manière différentes:

Soit, tu utilise un autre nom pour le fichier en lecture sous la forme de

Code :

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

1
2
3
4
5
6
7
ofstream MyFileWrite("toto.txt");
  MyFileWrite<<"je teste";
  MyFileWrite.close();
 
  ifstream MyFileRead("toto.txt");
  std::string str;
  MyFileRead>>str;

Soit tu t'arrange pour que la première variable n'existe plus lorsque tu veux créer ta deuxième variable, sous une forme qui pourrait être

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
void maFonction()
{
    {
        ofstream MyFile("toto.txt");
        MyFile<<"je teste";
        /* l'appel à close n'est plus nécessaire: le fichier est fermé
         * lors de la destruction de MyFile
         */
    }//qui a lieu ici
    {
         ifstream MyFile("toto.txt");
         std::string str;
         MyFileRead>>str;
    }
}

Ceci dit, on peut très sérieusement se poser la question de l'utilité du fait d'écrire dans un fichier et de lire dedans au sein de la même fonction...

Typiquement, l'écriture dans un fichier aura pour but d'assurer une certaine persistance des données, alors que la lecture du fichier aura pour but de... récupérer ces données.

En règle générale, on constatera qu'il y aura une fonction qui se chargera d'une des partie, et une autre qui se chargera de l'autre.

L'exception étant la copie (d'une partie) du contenu d'un fichier dans un autre, où on pourrait trouver un code du genre de

Code :

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

1
2
3
 
std::ifstream ifs("fichier_source.txt");
std::ofstream ofs("fichier_destination.txt");

[loufoque]

Solution : apprendre les bases des bases du C++.