Twitter iPhone pliant OnePlus 11 PS5 Disney+ Orange Livebox Windows 11

Fstream n'en fais qu a ca tete : pb de link

13 réponses
Avatar
NonoSoft
Voici mon post : http://www.developpez.net/forums/viewtopic.php?t=103975

On m'a dis d'ecrire ici pour avoir peu etre une réponse.

10 réponses

1 2
Avatar
NonoSoft
Le post est assez long c'est pourquoi je n'est pas fait de copier coller.


"Fabien LE LEZ" a écrit dans le message de news:

On Fri, 25 Jul 2003 15:30:11 +0200, "NonoSoft"
wrote:

Voici mon post : http://www.developpez.net/forums/viewtopic.php?t3975


Si tu espères avoir une réponse, fais un copier-coller de ton post ici
plutôt que de donner une URL que personne n'ira voir. En tant qu'à
faire, enlève les fautes d'orthographe.


--
Tout sur fr.* (FAQ, etc.) : http://www.usenet-fr.net/fur/
et http://www.aminautes.org/forums/serveurs/tablefr.html
Archives : http://groups.google.com/advanced_group_search
http://www.usenet-fr.net/fur/usenet/repondre-sur-usenet.html



Avatar
Fabien LE LEZ
On Sat, 26 Jul 2003 09:57:27 +0200, "NonoSoft"
wrote:

Le post est assez long c'est pourquoi je n'est pas fait de copier coller.


Mauvaise idée.
Autre mauvaise idée : répondre à l'envers. En français, on lit de haut
en bas ; il convient donc de placer sa réponse après le bout de
message auquel on répond. Cf
<http://www.giromini.org/usenet-fr/repondre.html>.


--
Tout sur fr.* (FAQ, etc.) : http://www.usenet-fr.net/fur/
et http://www.aminautes.org/forums/serveurs/tablefr.html
Archives : http://groups.google.com/advanced_group_search
http://www.usenet-fr.net/fur/usenet/repondre-sur-usenet.html

Avatar
NonoSoft
"NonoSoft" a écrit dans le message de news:
3f2130ce$0$5880$
Voici mon post : http://www.developpez.net/forums/viewtopic.php?t3975

On m'a dis d'ecrire ici pour avoir peu etre une réponse.




Apparement tu est tres précis en ce qui concerne les regles des NG.

Bon alors voici les post :

Voila une methode de ma classe doit ecrire une chiane de caractére dans un
fichier texte.
Rien de plus simple :

Code:

#include <fstream.h>


void CCle::Ecrire()
{
ofstream monFichier;
monFichier.open("c:tmp");
monFichier << Cle;
monFichier.close();
}



Ce code fonctionne tres bien hors de ma classe mais la quand je compile j'ai
:

Code:

[Warning] In function `CCle::Ecrire(void)':
[Linker error] undefined reference to `ostream::operator<<(char const *)'
[Linker error] undefined reference to `fstreambase::close(void)'
...



D'ou vien le problème ?
Et quel est la différence entre fstream.h et fstream ?


Fredou1982


essai plutot

Code:

#include <fstream>
using namespace std;



Christophe Brun


nonosoft a écrit:
Et quel est la différence entre fstream.h et fstream ?


La bibliothèque des flots du C++ a évolué avec le temps. fstream.h est
l'ancienne version (obsolète) est fstream est la version actuelle, qui
utilise la bibliothèque de flots de la Standard Template Library.
Voir la réponse de Fredou1982 pour la manière de traiter l'include.

nonosoft

J'ai bien modifié le <fstream.h> en <fstream> et j'ai ajouté le using
namespace std;.
Pourtant j'obtien les memes erreurs

Fredou1982

bon essaye comme ça on sait jamais.
tu travail sur qu'elle compilateur (BC++, VC++, DEV...)?

Code:

include <fstream>
using namespace std;


void CCle::Ecrire()
{
ofstream monFichier ("c:tmp");
monFichier << Cle;
monFichier.close();
}




Comme ça moi ça marche tres bien...
Bon courage


nonosoft

J'utilise DEV C++ 4.
Chez moi ca marche tres bien aussi avec juste ce code mais quand je le met
dans ma classe j'ai ces erreur de link.

Fredou1982

Regarde ce poste ça peux t'aider :
http://www.developpez.net/forums/viewtopic.php?t3930



nonosoft

j'ai déja lu ce sujet.
Mais il ne m apporte pas de reponse a ma question
_________________


Fredou1982

ah ok desole la je suis à cours d'idee.
Des que j'en sais plus je te tiens au courant sinon bonne continuation


Christophe Brun

NB : le compilateur mentionne un operator<<( char const* ) qui n'est
normalement pas défini dans l'interface standard de basic_ostream. Celui qui
est défini est operator<<( const char*). Je soupçonne le problème de venir
de là.

Donc sur le code :
Code:

ofstream monFichier ("c:tmp");
monFichier << Cle;


est-ce que tu peux nous montrer la définition de Cle?


nonosoft

Oui : Cle est un char*
Code:

char * Cle;


Christophe Brun

Alors je donne ma langue au chat.
Ce qui est certain, c'est que l'erreur ne vient pas du code que tu nous
montres.
Il faut trouver où tu as du char const* dans ton code. L'avantage, c'est que
si le const char* est un animal commun, le char const* ne se manifeste que
très rarement (en fait, je n'en ai encore jamais vu dans du code de
production).

Une chose m'etonne encore, mais c'est peut-être la façon normale de passer
des messages pour ton compilateur : le compilo parle de warning dans la
méthode CCle::Ecrire, puis suivent deux erreurs de link. Les erreurs de link
ne sont pas des warnings, mais des ... erreurs. Est-il possible que les ':'
suivant l'annonce du warning nous mettent sur une fausse piste et que
l'endroit où est référencée la méthode ostream::operator<<(char const*)
n'ait rien à voir avec CCle::Ecrire ?

nonosoft


Honnettement je ne sais pas d'ou viens le problème.
Il n'y a aucun char const* dans mon code.
De plus d'habitude DEV C++ fait les différence entre les warning et les vrai
erreurs.

Voici le projet complet :
http://perso.wanadoo.fr/nonosoft/EasyCrypt%208.0.zip

Peut etre que l'erreur viens de la configuration du projet.


Christophe Brun


Je n'ai pas GCC, je ne peux donc rien vérifier de ce côté. Mais tu devrais
aller faire un tuur sur fr.comp.lang.c++.moderated. On y trouve pas mal
d'utilisateurs avertis de gcc, ainsi que Gabriel Dos Reis qui, si j'ai bien
compris, en a développé de gros morceaux. Peut-être pourront-ils t'éclairer
?

nonosoft


Merci a tous d'avoir tenté des resoudre ce problème mais je me suis
resseigné sur plusieur chat et le NG que vous m'avez indiqué et personne n'a
l'air de comprendre ce problème.
Je vais tenté de recompiler mon prog avec VC++.
Sinon je remplacerais les fstream par de fopen/ fread/ fwrite

Encore merci a tous

Avatar
Jonathan Mcdougall
Voila une methode de ma classe doit ecrire une chiane de caractére dans un
fichier texte.
Rien de plus simple :

Code:

#include <fstream.h>


Non standard, préférer <fstream>

# include <fstream>

void CCle::Ecrire()
{
ofstream monFichier;


std::ofstream monFichier;

monFichier.open("c:tmp");
monFichier << Cle;
monFichier.close();
}



Ce code fonctionne tres bien hors de ma classe mais la quand je compile j'ai
:

Code:

[Warning] In function `CCle::Ecrire(void)':
[Linker error] undefined reference to `ostream::operator<<(char const *)'
[Linker error] undefined reference to `fstreambase::close(void)'


Veux-tu dire que

# include <fstream>

int main()
{
std::ofstream ofs("file");
ofs << "salut";
ofs.close();
}

fonctionne, mais que

# include <fstream>

class C
{
public:
void f()
{
std::ofstream ofs("file");
ofs << "salut";
ofs.close();
}
};

int main()
{
C c;
c.f();
}

ne compile pas?


Et quel est la différence entre fstream.h et fstream ?


fstream.h est un header non standard, datant de l'avant
standardisation. Les headers standards n'ont plus l'extension .h
(iostream.h est devenu iostream tout court..) et leur code est compris
dans le namespace std.

Donc un code non standard

# include <iostream.h>

int main()
{
cout << "non standard";
}

devient

# include <iostream>

int main()
{
std::cout << "non standard";
}


Je croix qu'il serait temps pour toi de t'acheter un bon livre, voit
www.accu.org pour des recommendations.


Jonathan

Avatar
Fabien LE LEZ
On Sat, 26 Jul 2003 21:19:22 -0400, Jonathan Mcdougall
wrote:

Non standard, préférer <fstream>


A condition d'avoir un compilo récent...


--
Tout sur fr.* (FAQ, etc.) : http://www.usenet-fr.net/fur/
et http://www.aminautes.org/forums/serveurs/tablefr.html
Archives : http://groups.google.com/advanced_group_search
http://www.usenet-fr.net/fur/usenet/repondre-sur-usenet.html

Avatar
James Kanze
Jonathan Mcdougall writes:

|> >Et quel est la différence entre fstream.h et fstream ?

|> fstream.h est un header non standard, datant de l'avant
|> standardisation.

C-à-d il y a bien peu d'années. Toutes les dernières versions
des compilateurs que je connais le supportent, mais parfois, on est
obligé à supporter d'anciens compilateurs aussi. (G++ ne le
supporte correctement que depuis un an ou deux. L'implémentation
dans la dernière version de Sun CC dont je me suis servi est d'un
ordre de grandeur plus lente que <fstream.h>, etc.)

|> Les headers standards n'ont plus l'extension .h
|> (iostream.h est devenu iostream tout court..)

iostream.h n'est pas devenu iostream. C'est une des raisons pourquoi
on a changé les noms : le contenu n'est pas le même. Surtout,
<iostream> ne définit pas streambuf, istream, ostream ni les
opérateurs >> et << (au moins que ton implémentation d'iostream
inclut d'autres en-têtes, ce qui est permis).

|> et leur code est compris dans le namespace std.

|> Donc un code non standard

Disons pré-standard:-). (Non standard résonne trop péjoratif
pour quelque chose qu'on est parfois obligé à faire, et surtout,
trop critique du code écrit il y a plusieurs années.)

|> # include <iostream.h>

|> int main()
|> {
|> cout << "non standard";
|> }

|> devient

|> # include <iostream>

Tu oublies le :

#include <ostream>

Sans ça, ton code n'est pas correct, et il existe des compilateurs
(d'après ce qu'on me dit) où il ne compile pas.

|> int main()
|> {
|> std::cout << "non standard";
|> }

--
James Kanze mailto:
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
11 rue de Rambouillet, 78460 Chevreuse, France +33 1 41 89 80 93
Avatar
Jonathan Mcdougall
On 27 Jul 2003 21:36:07 +0200, James Kanze wrote:

Jonathan Mcdougall writes:

|> >Et quel est la différence entre fstream.h et fstream ?

|> fstream.h est un header non standard, datant de l'avant
|> standardisation.

C-à-d il y a bien peu d'années. Toutes les dernières versions
des compilateurs que je connais le supportent, mais parfois, on est
obligé à supporter d'anciens compilateurs aussi. (G++ ne le
supporte correctement que depuis un an ou deux. L'implémentation
dans la dernière version de Sun CC dont je me suis servi est d'un
ordre de grandeur plus lente que <fstream.h>, etc.)


D'accord, mais je n'en vois pas une raison pour recommander leur
utilisation.

|> Les headers standards n'ont plus l'extension .h
|> (iostream.h est devenu iostream tout court..)

iostream.h n'est pas devenu iostream. C'est une des raisons pourquoi
on a changé les noms : le contenu n'est pas le même. Surtout,
<iostream> ne définit pas streambuf, istream, ostream ni les
opérateurs >> et << (au moins que ton implémentation d'iostream
inclut d'autres en-têtes, ce qui est permis).


C'était une façon de parler. Si l'op demande la différence entre
fstream et fstream.h, il ne veut surement pas entendre une telle
réponse.

Tu oublies le :

#include <ostream>

Sans ça, ton code n'est pas correct, et il existe des compilateurs
(d'après ce qu'on me dit) où il ne compile pas.


Théoriquement oui, mais pratiquement, pas à ma connaissance.


Jonthan

Avatar
Gabriel Dos Reis
writes:

| > >Tu oublies le :
|
| > > #include <ostream>
|
| > >Sans ça, ton code n'est pas correct, et il existe des compilateurs
| > >(d'après ce qu'on me dit) où il ne compile pas.
|
| > Théoriquement oui, mais pratiquement, pas à ma connaissance.
|
| On m'a parlé dans le temps d'un cas réel.

Il me semble qu'une version de la bibliothèque vendue par Dinkumware à
un moment donné avait un tel comportement. Je ne l'ai jamais essayé
moi-même.

| Le but de diviser les iostream
| en tant d'en-têtes différents, c'était bien pour qu'on n'inclut que ce
| dont on a besoin, sans s'encombrer du reste. Si <iostream> fait partie
| de cette philosophie, logiquement, c'est une mauvaise implémentation qui
| fournira tout.

C'est un point de vue. Un autre est de considérer que cela n'a aucune
utilité pratique de casser quelque chose comme

#include <iostream>
using namespace std;

int main() { cout << "Hello World" << endl; }

Oui, je sais ce que tu vas dire.


| Si le but d'<iostream>, c'était d'avoir une façon simple
| à avoir tout, je me pose deux questions : 1) pourquoi on n'a pas exigé
| alors qu'il inclut toute la reste, et 2) pourquoi est-ce qu'on n'a pas
| créé aussi un en-tête pour n'avoir que cin, cout, etc. (Après tout,
| c'est extrèmement rare d'utiliser cin, cout ou cerr dans le même fichier
| source que << ou >>.) En somme, je dirais que c'est un défaut (assez
| mineur, j'avoue) d'une bibliothèque que de définir tout istream, ostream
| et les opérateurs dans <iostream>.

Il avertir le monde, parce que de nos jours, je ne connais pas
d'implémentation moderne qui n'accepte pas le programme ci-dessous.
Si tu en connais, j'aimerais le savori afin de mettre ma base de
données à jour.

| En revanche, en ce qui concerne <fstream>, tu as probablement raison.
| L'en-tête <fstream> doit définir filebuf, ifstream et ofstream. Classes
| qui dérivent de streambuf, istream et d'ostream, respectivement. Alors,
| je vois mal comment il pourrait définir des classes qui en dérivent sans
| avoir les définitions des classes de base, donc, sans inclure
| <streambuf>, <istream> et <ostream>.

Un peu d'imagination, que diable. La définition de ces classes peut
très bien se trouver dans des endroits sépararés de <istream>,
<ostream> et le reste.

<xxx/istream-def>
// contient la définition de std::istream
// le contenu est différent de <istream>

<xxx/ostream-def>
// contient la définition de std::ostream
// le contenu est différent de <ostream>

<fstream>
#include <xxx/istream-def>
#include <xxx/ostream-def>
// ... ajoute la reste


Alors <fstream> peut, de manière interne, n'inclure que ces entêtes
(internes) avec le résultat qu'il n'a pas à inclure l'intégralité de
<istream> ou <ostream> dans <fstream>.

-- Gaby
Avatar
NonoSoft
"NonoSoft" a écrit dans le message de news:
3f2130ce$0$5880$
Voici mon post : http://www.developpez.net/forums/viewtopic.php?t3975

On m'a dis d'ecrire ici pour avoir peu etre une réponse.




Voila j'ai trouvé la solution a ce problème de link.
J'ai installé les version beta de DEV C++ 4.9.8.0 et
miracle ca marche.
Donc le problème venait bien du compilateur lui meme.
Merci a tous.

Avatar
kanze
Gabriel Dos Reis wrote in message
news:...
writes:

| > >Tu oublies le :

| > > #include <ostream>

| > >Sans ça, ton code n'est pas correct, et il existe des
| > >compilateurs (d'après ce qu'on me dit) où il ne compile pas.

| > Théoriquement oui, mais pratiquement, pas à ma connaissance.

| On m'a parlé dans le temps d'un cas réel.

Il me semble qu'une version de la bibliothèque vendue par Dinkumware à
un moment donné avait un tel comportement. Je ne l'ai jamais essayé
moi-même.


Je ne l'ai pas vu moi-même non plus. Mais il me semble que quand on m'en
a parlé, c'était sur un Apple, et que ce n'était pas Dinkumware.

Si j'avais eu à implémenter une bibliothèque d'après la norme, ça aurait
sûrement été nécessaire, parce que j'office, j'aurais essayé à faire en
sort que chaque en-tête ne comprend que le minimum vital.

| Le but de diviser les iostream en tant d'en-têtes différents,
| c'était bien pour qu'on n'inclut que ce dont on a besoin, sans
| s'encombrer du reste. Si <iostream> fait partie de cette
| philosophie, logiquement, c'est une mauvaise implémentation qui
| fournira tout.

C'est un point de vue. Un autre est de considérer que cela n'a aucune
utilité pratique de casser quelque chose comme

#include <iostream>
using namespace std;

int main() { cout << "Hello World" << endl; }

Oui, je sais ce que tu vas dire.


Tu crois. Ce que je dis, c'est que je n'étais pas là, que j'y prêtais
assez peu d'attention aux aspects bibliothèques à la fois, et que je ne
sais pas si l'intention de <iostream>, c'était lié à l'intention de ne
pas inclure tout, ou c'était de fournir en en-tête alternatif avec tout.
D'après ce qu'il y a écrit dans la norme, j'aurais une tendance à croire
le premier, mais ça ne m'étonnerait pas qu'en fait, différents gens
avaient de différentes intentions, sans s'en rendre compte.

Il est certain que l'argument de ne pas casser du code aurait été plus
solide si on n'avait pas changé le nom, ni mis la bibliothèque dans
std::. Mais je suis d'accord qu'il n'est pas tout à fait sans valeur
quand même. Il est rélativement trivial à écrire un script qui remplace
tous les ".h>" avec ">" dans les include, et qui insère une ligne de
using après la dernière include (ou juste avant la première ligne
non-vide non-commentaire qui n'est pas une include). Déterminer qu'il
faut aussi inclure <istream> est nettement plus complex.

| Si le but d'<iostream>, c'était d'avoir une façon simple à avoir
| tout, je me pose deux questions : 1) pourquoi on n'a pas exigé alors
| qu'il inclut toute la reste, et 2) pourquoi est-ce qu'on n'a pas
| créé aussi un en-tête pour n'avoir que cin, cout, etc. (Après tout,
| c'est extrèmement rare d'utiliser cin, cout ou cerr dans le même
| fichier source que << ou >>.) En somme, je dirais que c'est un
| défaut (assez mineur, j'avoue) d'une bibliothèque que de définir
| tout istream, ostream et les opérateurs dans <iostream>.

Il avertir le monde, parce que de nos jours, je ne connais pas
d'implémentation moderne qui n'accepte pas le programme ci-dessous. Si
tu en connais, j'aimerais le savori afin de mettre ma base de données
à jour.


Comme tu sais, je n'ai pas accès à énormement de compilateurs.

| En revanche, en ce qui concerne <fstream>, tu as probablement
| raison. L'en-tête <fstream> doit définir filebuf, ifstream et
| ofstream. Classes qui dérivent de streambuf, istream et d'ostream,
| respectivement. Alors, je vois mal comment il pourrait définir des
| classes qui en dérivent sans avoir les définitions des classes de
| base, donc, sans inclure <streambuf>, <istream> et <ostream>.

Un peu d'imagination, que diable. La définition de ces classes peut
très bien se trouver dans des endroits sépararés de <istream>,
<ostream> et le reste.

<xxx/istream-def>
// contient la définition de std::istream
// le contenu est différent de <istream>

<xxx/ostream-def>
// contient la définition de std::ostream
// le contenu est différent de <ostream>

<fstream>
#include <xxx/istream-def>
#include <xxx/ostream-def>
// ... ajoute la reste


C'est un détail de l'implémentation. En ce qui concerne <fstream>, sans
un truchement du compilateur, il faut qu'il inclut la définition de
std::istream, std::ostream et de std::streambuf.

Alors <fstream> peut, de manière interne, n'inclure que ces entêtes
(internes) avec le résultat qu'il n'a pas à inclure l'intégralité de
<istream> ou <ostream> dans <fstream>.


Selon la norme, std::istream est défini dans <istream>, et non ailleurs.
La norme donne le droit à une implémentation d'inclure d'autres en-têtes
standard depuis un en-tête standard. Elle ne lui donne pas le droit à
faire n'importe quoi. Si j'inclus <iostream>, ou <fstream>, je ne sais
pas d'office (d'après la norme) si <istream> a été inclu. Mais si
std::istream est défini, je sais (d'après la norme) que <istream> a été
inclu, et que donc les autres opérateurs << définis dans <istream> sont
disponibles. Ou bien, j'ai le contenu de <istream>, ou bien, je ne l'ai
pas, mais je ne peux pas en avoir la moitié. (Mais la régle « as if »
fonctionne comme d'habitude, évidemment.)

--
James Kanze GABI Software mailto:
Conseils en informatique orientée objet/ http://www.gabi-soft.fr
Beratung in objektorientierter Datenverarbeitung
11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16

1 2