Bonjour, je voudrais savoir comment initialiser un objet ifsteam ou ofstream 

example:

ifstream n;
n // là on initialise

merci de votre réponce

std::ifstream n("filename.ext");

j'avais compris mais moi je crée l'objet est plus tard, je l'initialise 

example:

ifstream n;

//plein de code

n // on l'initialise 

   std::ifstream n;
   n = std::ifstream("filename.ext");

PS : 

AntoineBarbier12 a écrit:

mais moi je crée l'objet est plus tard, je l'initialise 

-
Edité par rouloude 12 juin 2021 à 17:58:24

merci, mais moi quand je fais ça ca affiche une erreur:

/Library/Developer/CommandLineTools/usr/include/c++/v1/streambuf:490:64: error:

base class 'std::__1::ios_base' has private copy constructor

le code:

open.h:

#ifndef OPEN_H
#define OPEN_H
#include <iostream>
#include <string>
#include <fstream>
using namespace std;




class OPEN {
public:
	OPEN(string file_c, char m);
	string read(int nb);
	string read();
	string readline();
	string nbWords();
	void write();
private:
	char mode;
	string n_file;
	ofstream file_w;
	ifstream file_r;


};



OPEN::OPEN(string file_c, char m) {
	n_file = file_c;
	mode = m;
	if(m == 'w') {
		
		file_w  = std::ofstream(file_c.c_str());
		if(! file_w) {
			goto error;
		}

	}
	if(m == 'r') {
		
		file_r = std::ifstream(file_c.c_str());

		if(! file_r) {
			goto error;
		}
	}

	error:
		throw string("ERREUR: UNE ERREUR EST PARVENU");
	
}

string OPEN::read() {
	if(mode != 'r') {
		throw string("ERREUR: vous n'êtes pas en mode lecture");
		exit(1);
	}
	string body;
	string line;


	while(getline(file_r, line)) {
		body += line;
	}

	return body;
}

string OPEN::readline() {
	if(mode != 'r') {
		throw string("ERREUR: vous n'êtes pas en mode lecture");
		exit(1);
	}

	static string line = " ";
	if(getline(file_r, line)){}
	else {
		line = "";
		cout << "INFO: vous ne pouvez plus lire: vous êtes à la fin du fichier\n" <<endl;
	}
	return line;
}


#endif

open_test.cpp:

#include "open.h"
using namespace std;

int main(int argc, char const *argv[])
{
	OPEN n("test_open.txt", 'r');
	return 0;
}

-
Edité par TheSmiley 12 juin 2021 à 18:02:08

AntoineBarbier12 a écrit:

j'avais compris mais moi je crée l'objet est plus tard, je l'initialise 

example:

ifstream n;

//plein de code

n // on l'initialise 

C'est une très mauvaise pratique. https://cpp.developpez.com/faq/cpp/?page=Les-fonctions#Ou-dois-je-declarer-mes-variables-locales

Maintant vu le code, la solution pourrait etre open() tout simplement. Mais ... pourquoi cette surcouche? C'est une idée de prof?

Rien, que l'invariant dynamique me hérisse le poil. Pourquoi avoir une fonction de lecture sur des flux qui peuvent se manipuler en écriture et rejeter si le le mode d'ouverture ne correspond pas? Keep It Simple (and Stupid).  C'est comme avoir une fonction pédaler sur un véhicule pour se prendre une exception quand en fait on a un camion...

> goto error;

Mais non! Throw direct! Voyons. Quelle idée. Tu es en C++ maintenant, oublie tout ce que tu as appris ailleurs.

-
Edité par lmghs 12 juin 2021 à 18:08:55

mon example ne correspond pas à mon code, et je veux juste savoir la question qui est dans le titre .  Mon code est sans doute horrible mais ifstream::open ne correspond pas à ce que je veux faire .

PS: je modiferais des petites choses y compris le mode

-
Edité par TheSmiley 12 juin 2021 à 18:15:27

AntoineBarbier12 a écrit:

Mon code est sans doute horrible mais ifstream::open ne correspond pas à ce que je veux faire .

Si tu le dis... https://fr.wikipedia.org/wiki/Probl%C3%A8me_XY

Toujours est-il que si tu restes en C++98 tu n'auras pas le choix.

Honnêtement si ce n'est pas un exercice tu vas juste rajouter une couche de complexité qui n'apporte rien.

-
Edité par lmghs 13 juin 2021 à 17:25:06

Antoine,

Comme te le dit Rouloude et LMGHS, C'est pas prévue pour !

rouloude a écrit:

...

AntoineBarbier12 a écrit:

mais moi je crée l'objet est plus tard, je l'initialise 

Est-ce vraiment une bonne idée ?

lmghs a écrit:

C'est une très mauvaise pratique. https://cpp.developpez.com/faq/cpp/?page=Les-fonctions#Ou-dois-je-declarer-mes-variables-locales

Enfin, C'est toi qui voit !

Cordialement

PS: C'est plus dificille de suivre 2 conversations sur le même sujet!

AntoineBarbier12 a écrit:

mon example ne correspond pas à mon code, et je veux juste savoir la question qui est dans le titre .  Mon code est sans doute horrible mais ifstream::open ne correspond pas à ce que je veux faire

Ta question est bien : comment initialiser un objet ifstream ou ofstream?

Deux manières existent qui sont exactement la réponse à ta question.
- n = std::ifstream("filename.ext"); mais ça ne fonctionne qu'à partir du C++11.
- n.open("filename.ext"); qui marche depuis très longtemps.

Si j'ai bien compris tu souhaites la réponse à ta question mais tu ne veux pas que ça soit open() et tu n'as pas le C++11.
Je pense que l'on est bien au-delà du problème XY.

Salut,

Déjà, pourquoi vourais tu pouvoir avoir une classe qui contienne à la fois un flux en entrée et un flux en sortie?

Soit, tu veux extraire certaines données de ton flux, et tu l'ouvre en entrée (ifstream), soit, tu  veux y injecter des données, et tu l'ouvre en sortie (ofstream)

Ensuite, pourquoi voudrais tu garder ce flux (d'entré OU de sortie selon le cas) ouvert en permanence?

Il faut, en effet, savoir que le système d'exploitation va -- typiquement -- poser un "verrou" sur les fichiers qui sont ouverts (que ce soit en lecture ou en écriture) de manière à éviter que deux applications différentes n'essayent d'y accéder en même temps (que ce soit l'une en écriture pendant que l'autre le modifie, les deux pour le modifier ou même les deux en lecture).

Dés lors, il est souvent préférable (en fonction de l'usage auquel tu destine ton flux bien sur) de n'ouvrir ton flux que le temps nécessaire à y faire ce que tu veux faire dedans (en essayant, autant que possible, de regrouper un maximum de choses à faire) et de le refermer dés que ce qu'il y a à faire est terminé.

Pour y arriver "relativement" facilement, tu dois absolument essayer de comprendre et d'appliquer trois principes de base (qui te seront très utiles dans bien d'autres circonstances):

• le sempiternel SRP (Single Responsability Principle ou principe de la responsabilité unique, le S de SOLID): chaque donnée, chaque type de donnée, chaque  fonction ne doit faire qu'une seule chose, mais doit la faire correctement: plutot que d'avoir une classe OPEN, tu devrais plutôt envisager -- si tu tiens à travailler avec des classes -- la création d'une classe Loader (ou Reader, si tu préfères) qui se chargera de charger les informations et d'une classe Writer (ou Saver) qui se chargera de l'écriture (mais des fonctions libres iraient aussi très bien )
• La non moins sempiternelle loi de Déméter: l'utilisateur n'a pas à savoir que tes classes Loader et Saver (ou Reader et Writer) utilisent explicitement des flux en interne.  Tout ce qu'il doit savoiir à leur sujet, c'est qu'elles sont destinées à fournir des services bien particuliers (leur nom nous donne une vague idée des services que l'on peut en attendre) et qu'elles ont besoins d'une chaine de caractères représentant le nom du fichier à utiliser (*).
• le DIP (Dependancy Inversion Principle ou principe d'inversion des dépendances; le D de SOLID); auquel on fait sans doute moins souvent référence: il est souvent plus facile de s'assurer qu'une donnée soit transmise par paramètre à  une fonction que de forcer cette donnée à être une donnée membre (un "attribut") de la classe.

Ainsi, si tu tiens vraiment à travailler avec des classes, la classe Reader (tu lui donnes, bien sur, le nom que tu veux) pourrait ressembler à  quelque chose comme

class Reader{
public:
    /* il faut donner le nom du fichier qui sera lu par l'instance
     * de la classe, et c'est en gros la seule information
     * qui soit absolument spécifique à toutes les instances
     */
     Reader(std::string const & filename):filename_{filename}{
     }
     /* l'utilisateur voudra obtenir un "ensemble de données
      * à la lecture du fichier
      */
     AllDatas read(){
         // on crée la donnée
         // et on l'initialise tout de suite dans la foulée
         std::ifstream ifs{filename_}; 
         if(! ifs){
             // si, pour une raison ou une autre, on n'arrive
            // pas à ouvrir le fichier, ca ne sert à rien
            // d'aller plus loin
            throw std::runtime_error("unable to open file");
         }
         // si on arrive ici, c'est que l'ouverture s'est bien
        // passée
        /* tout ce qu'il faut faire pour exécuter la lecture
         */
        /* on va créer la donnée qui sera mise à jour */
        AllData ad;
        /* on appelle une fonction qui s'occupe de la lecture 
         * proprement dite en lui fournissant le flux et
         * la donnée à mettre à jour
         */
        read(ifs, ad):
        return ad;
     }
private:
     /* la fonction qui va effectivement s'occuper de
      * la lecture (inaccessible à l'utilisateur)
      */
     void read(std::isteam & ifs, AllData & ad){
         /* ca, c'est ton job  */
     }
    /* le nom du fichier qui devra être utilisé */
    std::string filename_;
};

Ta classe Writer sera sensiblement identique, à ceci près que tu devras transmettre la donnée que tu veux faire enregistrer.  Elle ressemblera donc à quelque chose comme

class Writer{
public:
    Writer(std::string const & filename):filename_{filenmae}{
    }
    void write(AllData const & ad){
        /* on ouvre le fichier, on lance une exception
         * si cela échoue
         */
        std::ofsteam ofs{filename_};
        if(! ofs)
            throw std::runtime_error("unable to open file");
        write(ofs, ad);
    }
private:
    void write(std::ostream & ofs, AllDatas const & ad){
        /* ca, c'est ton job  */
    }
    std::string filename_;
};

Et je le rappelle: on pourrait parfaitement faire cela sous la forme de fonctions libres -- éventuellement dans un espace de noms (grâce au respect du DIP) en exposant deux fonctions proches de

namespace MonEspaceDeNoms{
    /* ca, ce sont les fonctions dont l'utilisateur a connaissance
     */
    AllData read(std::string const & filename);
    void write(std::string const & filname, AllData const & ad);
}
/* et les fonctions qui nous amènent au résultat */

namespace MonEspaceDeNoms{
    void read(std::istream & ifs, AllData & ad){
        /* ca, c'est ton job */
    }
    void write(std::ostream & ifs, AllData const & ad){
        /* ca, c'est ton job */
    }
    /* l'implémentation des fonctions dont l'utilisateur a connaissance
     */
    AllData read(std::string const & filneame){
        /* juste une adaptation de ce que l'on a fait
         * pour la classe Reader
         */
        std:ifstream ifs{filename};
        if(!ifs)
            throw std::runtime_error("Unable to open file");:
        AllData ad;
        read(ifs, ad);
        return ad;
    }

    void write(std::string const & filneame, AllDatas const & ad){
        /* juste une adaptation de ce que l'on a fait
         * pour la classe Writer
         */
        std:ofstream ofs{filename};
        if(!ifs)
            throw std::runtime_error("Unable to open file");
        write(ofs, ad);
    }
}