Discussion :

[theo7]

Bonjour,

j'ai coder une classe ou j'essaye qui doit ouvrir un fichier avec fstream :

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
#include <iostream>
#include <fstream>
using namespace std;
 
namespace libxml
{
  class xml
  {
  public:
    string XML_VAR_file;
    int XML_VAR_file_id;
    string XML_VAR_query;
    fstream XML_open_file;
 
    xml(string);
    bool XML_query(string);
    ~xml();
  };
 
  xml::xml(string XML_VAR_file)
  {
    xml::XML_VAR_file = XML_VAR_file;
    xml::XML_open_file.open(xml::XML_VAR_file, ios::ate); // LIGNE 23
  }
  bool xml::XML_query(string)
  {
 
  }
  xml::~xml()
  {
    xml::XML_open_file.close();
  }
}

Seulement, ça me renvois une erreur :

Code :

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

1
2
3
4
5
6
~/Files/Programmes/Cpp/tests $ g++ libxml.cpp -o libxml
 
libxml.cpp: In constructor ‘libxml::xml::xml(std::string)’:
libxml.cpp:23: error: no matching function for call to ‘std::basic_fstream<char,
std::char_traits<char> >::open(std::string&, const std::_Ios_Openmode&)’
/usr/include/c++/4.2/fstream:778: note: candidates are: void std::basic_fstream<_CharT, _Traits>::open(const char*, std::_Ios_Openmode) [with _CharT = char, _Traits = std::char_traits<char>]

Si j'ai bien compris il faut que dans cette ligne :

Code :

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

xml::XML_open_file.open(xml::XML_VAR_file, ios::ate); // LIGNE 23

xml::XML_VAR_file soie un pointeur de constante de char ?
Seulement si je fait un transtypage :

Code :

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

xml::XML_open_file.open((const char*)xml::XML_VAR_file, ios::ate);

Ça m'envoie une autre erreur :

Code :

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

1
2
libxml.cpp: In constructor ‘libxml::xml::xml(std::string)’:
libxml.cpp:23: error: invalid cast from type ‘std::string’ to type ‘const char*’

Quelqu'un aurait la solution ?
Merci

[r0d]

Si j'ai bien compris il faut que dans cette ligne :

Code :

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

xml::XML_open_file.open(xml::XML_VAR_file, ios::ate); // LIGNE 23

xml::XML_VAR_file soie un pointeur de constante de char ?

Oui tu as bien compris

La solution consiste à utiliser la fonction membre c_str() de la classe string:

Code :

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

xml::XML_open_file.open(xml::XML_VAR_file.c_str(), ios::ate);

Sinon, une remarque en passant: il n'est pas nécessaire de mettre l'opérateur de résolution de portée ( xml:: ) lorsque tu es dans la portée en question. Par exemple, le code précédent peut se simplifier ainsi:

Code :

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

XML_open_file.open(XML_VAR_file.c_str(), ios::ate);

Maintenant, peut-être que tu préfères avec.

Autre chose: il est dangereux d'utiliser un "using namespace" dans un header et dans l'espace de nommage global.

[theo7]

Ça marche, merci

[theo7]

En faite ça marche qu'a "moitié" :

Avec ce code, tout vas bien, sauf que je peut pas utiliser XML_file dans d'autres méthodes de la classe :

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
class xml
  {
  public:
    string XML_VAR_file;
    string XML_VAR_query;
 
    xml(string XML_VAR_file)
    {
      fstream XML_file;
      XML_VAR_file = XML_VAR_file;
      XML_file.open(XML_VAR_file.c_str(), ios::app);
 
      cout << "open file : " << XML_VAR_file <<endl;
    }
//[...]
  }

sinon j'ai l'erreur :

Code :

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

‘XML_file’ was not declared in this scope

Et si je déclare XML_file comme ceci :

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
class xml
  { // ligne 4
  public:
    string XML_VAR_file;
    string XML_VAR_query;
    fstream XML_file;
 
    xml(string XML_VAR_file)
    {
      XML_VAR_file = XML_VAR_file;
      XML_file.open(XML_VAR_file.c_str(), ios::app);
 
      cout << "open file : " << XML_VAR_file <<endl;
    }
//[...]
  }

Ça me renvois un gros paquet d'erreurs incompréhensible pour moi :

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
/home/theo7/Files/Programmes/Cpp/tests $ g++ main.cpp -o main
/usr/include/c++/4.2/bits/ios_base.h: In copy constructor ‘std::basic_ios<char, std::char_traits<char> >::basic_ios(const std::basic_ios<char, std::char_traits<char> >&)’:
/usr/include/c++/4.2/bits/ios_base.h:779: error: ‘std::ios_base::ios_base(const std::ios_base&)’ is private
/usr/include/c++/4.2/iosfwd:55: error: within this context
/usr/include/c++/4.2/iosfwd: In copy constructor ‘std::basic_fstream<char, std::char_traits<char> >::basic_fstream(const std::basic_fstream<char, std::char_traits<char> >&)’:
/usr/include/c++/4.2/iosfwd:95: note: synthesized method ‘std::basic_ios<char, std::char_traits<char> >::basic_ios(const std::basic_ios<char, std::char_traits<char> >&)’ first required here 
/usr/include/c++/4.2/streambuf: In copy constructor ‘std::basic_filebuf<char, std::char_traits<char> >::basic_filebuf(const std::basic_filebuf<char, std::char_traits<char> >&)’:
/usr/include/c++/4.2/streambuf:794: error: ‘std::basic_streambuf<_CharT, _Traits>::basic_streambuf(const std::basic_streambuf<_CharT, _Traits>&) [with _CharT = char, _Traits = std::char_traits<char>]’ is private
/usr/include/c++/4.2/iosfwd:86: error: within this context
/usr/include/c++/4.2/iosfwd: In copy constructor ‘std::basic_fstream<char, std::char_traits<char> >::basic_fstream(const std::basic_fstream<char, std::char_traits<char> >&)’:
/usr/include/c++/4.2/iosfwd:95: note: synthesized method ‘std::basic_filebuf<char, std::char_traits<char> >::basic_filebuf(const std::basic_filebuf<char, std::char_traits<char> >&)’ first required here 
libxml.cpp: In copy constructor ‘libxml::xml::xml(const libxml::xml&)’:
libxml.cpp:4: note: synthesized method ‘std::basic_fstream<char, std::char_traits<char> >::basic_fstream(const std::basic_fstream<char, std::char_traits<char> >&)’ first required here 
main.cpp: In function ‘int main(int, char**)’:
main.cpp:13: note: synthesized method ‘libxml::xml::xml(const libxml::xml&)’ first required here

Mon main.cpp :

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
#include <iostream>
#include <fstream>
#include <boost/xpressive/xpressive.hpp>
using namespace boost::xpressive;
using namespace std;
#include "libxml.cpp"
using namespace libxml;
 
 
int main(int argc, char* argv[])
{
 
  xml xmlt = xml("test.xml"); // Ligne 13
 
  return 0;
}

Quelqu'un aurait la solution ?
Merci .

[r0d]

Bonsoir Theo,

je te propose de prendre un peu de recul sur le code que tu as écris. Prenons par exemple:

Code :

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

XML_VAR_file = XML_VAR_file;

Ceci n'a aucun sens.
En c++, le signe '=' est utilisé pour affecter une valeur à une variable. Là c'est comme si tu disais "a = a".

Ensuite, l'erreur:

XML_file’ was not declared in this scope

signifie que la variable XML_file n'est pas déclarée dans la portée. C'est un concept "de base" en c++. Par conséquent, je ne pourrais donc te donner de meilleur conseil que de prendre le temps (beaucoup de temps, j'en conviens, malheureusement) de lire les cours et les tutoriaux disponibles sur ce site (et autres), et tu y trouveras les raisons de ces erreurs.

[theo7]

En c++, le signe '=' est utilisé pour affecter une valeur à une variable. Là c'est comme si tu disais "a = a".

C'etait pour que xml::XML_VAR_file soit egal a l'argument donner a la methode, que je puisse utiliser la variable dans d'autres fonctions de la classe, mais je vais ré-utiliser les xml::, je trouve ça plus lisible

Ensuite, l'erreur:
Citation:
XML_file’ was not declared in this scope
signifie que la variable XML_file n'est pas déclarée dans la portée.

J'avais compris
Mais une variable déclarer juste après class xml{} est accessible dans toutes les methodes non ? Mais lorsque que je déclarais XML_file comme ceci :

Code :

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

1
2
3
4
5
class xml
{
public:
  fstream XML_file;
}

Sa me mettais un gros bloc d'erreur (je l'ai dit dans ma réponse) .

Sinon j'ai trouver une solution, déclarer XML_file hors de la classe :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
  fstream XML_file;
  class xml
  {
  public:
    string XML_VAR_file;
    string XML_VAR_query;
 
 
    xml(string XML_VAR_file);
    {
      xml::XML_VAR_file = XML_VAR_file;
      XML_file.open(XML_VAR_file.c_str(), ios::app);
//[...]

Voila, merci

[AlKoLiK]

Bonjour, j'ai exactement le même problème^^

J'avais trouvé aussi que déclarer le fstream en dehors de la classe résolvait les problémes mais je cherche une solution un peu plus propre ou au moins qu'on puisse m'expliquer pourquoi déclarer le fstream dans le corps de la classe fait tout foirer...

Merci !

[Noxen]

Salut,

Peux-tu re-poster le code (complet) de ta classe dans l'état actuel des choses ?

Sinon, quelques conseils en vrac : choisi des noms de classe, de variable et de méthode qui soient significatifs. Par exemple, au lieu de 'XML_VAR_file', s'il s'agit du nom du fichier xml associé à cet objet, appelle la plutôt '_file_name', c'est suffisant. Le code sera plus dur à débugger s'il n'est pas agréable à lire.

N'abuse pas de xml::variable_membre, c'est une syntaxe qu'on retrouve plutôt pour des méthodes statiques, appelées à l'extérieur de la classe ; si tu veux signifier qu'une méthode est appelée sur ton objet, ou que c'est une de ses variables qui est utilisée, utilise plutôt le pointeur 'this' (this->_file_name). De plus, tu as des "xml" partout, ça alourdi le code, on ne sait pas si ça vient de ta classe xml, de la bibliothèque que tu utilises, etc. (d'ailleurs, xml pour un nom de classe ça me parait imprudent).

Tu peux utiliser les listes d'initialisation, pour instancier directement les objets simples de ta classe avant l'exécution du contenu du constructeur. Évite d'utiliser le même nom pour ta variable membre et pour un paramètre, même si tu peux les différencier avec 'this', ça reste quand même un piège potentiel et une source de confusion.

Si la variable fstream qui te sert à ouvrir le fichier doit être en permanence connue de la classe, tu devrais en faire une variable membre, si le fichier est simplement ouvert, lu et libéré à la création d'un objet, déclares-en simplement un dans le constructeur comme tu l'as déjà fait. S'il n'a pas à être connu et partagé par plusieurs objets, il ne faut pas qu'il soit global. Si en C on commençait par déclarer au tout début du fichier les variables que l'on utiliserait ensuite, en C++ il est expressément recommandé de retarder le plus possible la déclaration des variables ; dans l'idéal, une variable est initialisé au moment de sa déclaration, sinon, c'est un risque pour le programme.

Je remarque que les variables membres de ta classe sont en plublic, il vaut généralement mieux les protéger par private (ou éventuellement protected s'il y a de l'héritage et que c'est opportun).

Voilà, bon courage

[AlKoLiK]

j'ai un problème similaire mais je ne fais rien en rapport avec du XML... voila le code qui pose problème :

#include <fstream>

class MyClass {

public:
MyClass(bool bKernel) {

}
std::fstream fichier;
};

int main() {
MyClass module= new MyClass(true);
return 0;
}

Ce code ne se compile pas. Bizarrement si on déclare le fstream en dehors de la classe (en variable globale), ça marche. Sauf que j'ai besoin d'un fstream pour chaque instance de ma classe

[Noxen]

Code :

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

1
2
3
4
5
6
7
int main()
{
    MyClass * module= new MyClass(true); // new => pointeur
    delete module; // new => delete
    return 0;
}

Pour moi, avec cette modif, ça compile tranquillement

[AlKoLiK]

oui, j'avais trouvé ça aussi mais j'aurais voulu me passer de pointeurs... merci quand même !

[Noxen]

Sans pointeur, c'est faisable aussi :

Code :

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

1
2
3
4
5
6
7
8
 
int main()
{
	MyClass mod(true);
	MyClass mod2(true);
 
	return 0;
}

Par contre, je viens de me rendre compte que les fstream ne semble pas être très tolérants à la copie. C'est-à-dire qu'on ne peut pas créer un fstream à partir d'un autre, il n'y a pas de constructeur par copie, on ne peut pas faire de constructeur par copie de MyClass car il faudrait copier le fstream (sauf à créer un constructeur par copie qui ne copie pas le fstream, mais en crée un nouveau), on ne peut pas faire de vecteurs de MyClass, car il y a copie, on ne peut pas passer MyClass ou un fstream par valeur à une fonction car il y a encore copie, etc.

Je pense que ça répond à une logique (quelque chose comme empêcher 2 flux d'accéder simultanément à un même fichier).

La seule solution serait d'utiliser des références. Par exemple :

Code :

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

1
2
3
4
5
6
7
8
9
 
class MyClass
{
private:
    std::fstream& _file;
public:
    MyClass(fstream& fs): _file(fs) {} // Là je ne sais pas s'il ne faudrait pas un const fstream&
    MyClass(MyClass& M): _file(M._file) {} // Attention : les 2 objets se partagent le même fichier !!!
};

Il n'y a plus de copie de fstream, ça devrait aller. Attention par contre à l'idée d'utiliser des pointeurs.

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
 
class MyClass
{
private:
    std::fstream * _file;
public:
    MyClass(): _file(new fstream) {} // Problèmes à venir
    MyClass(const MyClass& M): _file(M._file) {} // Attention !! les 2 objets partagent le même fstream !!!
    ~MyClass()
    {
        delete _file; // Si l'objet est le seul à avoir ce fstream, ça ira
        // Mais s'ils sont plusieurs, le deuxième objet qui sera détruit tentera de
        // libérer une zone mémoire qui a déjà été libérée => plantage
    }
};

Si on utilise des pointeurs ou des références, il ne faudra pas confier la durée de vie des fstream aux objets MyClass, mais les gérer à l'extérieur. C'est un sujet assez sensible, du moins par rapport à la POO, dans la mesure ou ça ouvre l'implémentation de la classe au code extérieur, réfutant l'encapsulation.

[r0d]

Non mais là, la vérité est ailleurs. Par exemple, le code suivant fonctionne parfaitement:

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
 
#include <fstream>
 
class Dum
{
public:
 
private:
	std::fstream m_file;
};
 
int main( int argc, char* argv[] )
{
	Dum d;
 
	std::cout << "end" << std::endl;
	std::cin.get();
	return 0;
}

[r0d]

Ha oui, effectivement. Le problème dans ton code, AlKoLiK, c'est cette ligne:

Code :

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

MyClass module= new MyClass(true);

Je te laisse comprendre pourquoi

[AlKoLiK]

Ha oui, effectivement. Le problème dans ton code, AlKoLiK, c'est cette ligne:

Code :

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

MyClass module= new MyClass(true);

Je te laisse comprendre pourquoi

euh... je supppose que module aurait dû être déclaré en tant que pointeur ? J'ai un peu tendance à me croire en java quand je programme en c++...

Correct ? ou donne moi un indice

[Noxen]

Il fait allusion à la correction que je t'ai indiquée (points manquants en gras) 5 posts plus haut

[r0d]

euh... je supppose que module aurait dû être déclaré en tant que pointeur ?
Correct ? ou donne moi un indice

Exact.

Il fait allusion à la correction que je t'ai indiquée (points manquants en gras) 5 posts plus haut

J'ai un peu tendance à me croire en java quand je programme en c++...

Et vi, c'est une des raisons pour lesquelles je n'aime pas ces languages interprétés (je pense surtout à java et c#), il y a tout un tas de choses qui sont cachées par le compilo et au final on ne sait pas vraiment ce qu'on fait.

[Noxen]

Et vi, c'est une des raisons pour lesquelles je n'aime pas ces languages interprétés (je pense surtout à java et c#), il y a tout un tas de choses qui sont cachées par le compilo et au final on ne sait pas vraiment ce qu'on fait.

C'est pour ça que je trouve que le C++ est un langage très formateur, il oblige à comprendre réellement ce qui se passe et ce qu'on fait, avec une tolérance minime pour l'ambigüité. En BTS on étudiait la POO sur du VB.net, mais j'étudiais un peu le C++ à côté, et ça m'a beaucoup aidé pour comprendre les handle, etc. dans .net.

[AlKoLiK]

merci pour votre aide