std::ofstream fout("test.html",std::ios::out); html_header(fout); // là ça marche fout << html_header; // là j'ai des chiffres dans le fichier.... !
est-ce que quelqu'un sait pourquoi ? Merci Marc
Marc G
"GHU" a écrit dans le message de news: eh76fi$oht$
en ayant encore ouvert un seul oeil, je suppose que tu écris dans le fichier l'adresse de la fonction
c'est probable, mais je croyais que les classes de flux de la stl avaient un opérateur d'insertion surchargé std::ofstream& operator<<(std::ofstream& (*f)(std::ofstream&)) { return (*f)(*this);} ce qui par exemple permet d'écrire fout<<endl; // là ça marche.... alors pourquoi pas avec ma fonction ?
"GHU" <gaetan_helleu@yahoo.fr> a écrit dans le message de news:
eh76fi$oht$1@s1.news.oleane.net...
en ayant encore ouvert un seul oeil, je suppose que tu écris dans le
fichier l'adresse de la fonction
c'est probable,
mais je croyais que les classes de flux de la stl avaient un opérateur
d'insertion surchargé
std::ofstream& operator<<(std::ofstream& (*f)(std::ofstream&))
{ return (*f)(*this);}
ce qui par exemple permet d'écrire
fout<<endl; // là ça marche....
alors pourquoi pas avec ma fonction ?
"GHU" a écrit dans le message de news: eh76fi$oht$
en ayant encore ouvert un seul oeil, je suppose que tu écris dans le fichier l'adresse de la fonction
c'est probable, mais je croyais que les classes de flux de la stl avaient un opérateur d'insertion surchargé std::ofstream& operator<<(std::ofstream& (*f)(std::ofstream&)) { return (*f)(*this);} ce qui par exemple permet d'écrire fout<<endl; // là ça marche.... alors pourquoi pas avec ma fonction ?
Sylvain Togni
Marc G wrote:
en ayant encore ouvert un seul oeil, je suppose que tu écris dans le fichier l'adresse de la fonction
c'est probable, mais je croyais que les classes de flux de la stl avaient un opérateur d'insertion surchargé std::ofstream& operator<<(std::ofstream& (*f)(std::ofstream&)) { return (*f)(*this);} ce qui par exemple permet d'écrire fout<<endl; // là ça marche.... alors pourquoi pas avec ma fonction ?
La fonction doit utiliser std::ostream, pas std::ofstream.
(De manière générale, il est très rare qu'une fonction ait besoin d'un argument de type std::ofstream).
-- Sylvain Togni
Marc G wrote:
en ayant encore ouvert un seul oeil, je suppose que tu écris dans le
fichier l'adresse de la fonction
c'est probable,
mais je croyais que les classes de flux de la stl avaient un opérateur
d'insertion surchargé
std::ofstream& operator<<(std::ofstream& (*f)(std::ofstream&))
{ return (*f)(*this);}
ce qui par exemple permet d'écrire
fout<<endl; // là ça marche....
alors pourquoi pas avec ma fonction ?
La fonction doit utiliser std::ostream, pas std::ofstream.
(De manière générale, il est très rare qu'une fonction ait
besoin d'un argument de type std::ofstream).
en ayant encore ouvert un seul oeil, je suppose que tu écris dans le fichier l'adresse de la fonction
c'est probable, mais je croyais que les classes de flux de la stl avaient un opérateur d'insertion surchargé std::ofstream& operator<<(std::ofstream& (*f)(std::ofstream&)) { return (*f)(*this);} ce qui par exemple permet d'écrire fout<<endl; // là ça marche.... alors pourquoi pas avec ma fonction ?
La fonction doit utiliser std::ostream, pas std::ofstream.
(De manière générale, il est très rare qu'une fonction ait besoin d'un argument de type std::ofstream).
-- Sylvain Togni
Marc G
La fonction doit utiliser std::ostream, pas std::ofstream. merci, ça marche impéccable
j'avais fini par écrire class my_output : public std::ostringstream { /* par exemple */ public : virtual my_output& operator<<(my_output& (*f)(my_output&)) { return (*f)(*this); } }; my_output& html_header(my_output& flux) { flux << "<html>n<head>n</head>n<body>n"; return flux; } et là ça marchait, sans même réfléchir à quel niveau était défini l'opérateur surchargé.... j'ai des progrès à faire... Merci encore Marc
La fonction doit utiliser std::ostream, pas std::ofstream.
merci, ça marche impéccable
j'avais fini par écrire
class my_output : public std::ostringstream { /* par exemple */
public :
virtual my_output& operator<<(my_output& (*f)(my_output&))
{
return (*f)(*this);
}
};
my_output& html_header(my_output& flux)
{
flux << "<html>n<head>n</head>n<body>n";
return flux;
}
et là ça marchait,
sans même réfléchir à quel niveau était défini l'opérateur surchargé....
j'ai des progrès à faire...
Merci encore
Marc
La fonction doit utiliser std::ostream, pas std::ofstream. merci, ça marche impéccable
j'avais fini par écrire class my_output : public std::ostringstream { /* par exemple */ public : virtual my_output& operator<<(my_output& (*f)(my_output&)) { return (*f)(*this); } }; my_output& html_header(my_output& flux) { flux << "<html>n<head>n</head>n<body>n"; return flux; } et là ça marchait, sans même réfléchir à quel niveau était défini l'opérateur surchargé.... j'ai des progrès à faire... Merci encore Marc
mais je voudrais écrire plutôt un truc du genre flux<<un_objet.display; (je peux avoir plusieurs méthodes d'affichage par exemple) je crois que un_objet.display est malheureusement du type std::ostream& (MonObjet::*)(std::ostream&), où un truc du genre :-)) (je doute de ce que j'écris parfois) Marc
mais je voudrais écrire plutôt un truc du genre
flux<<un_objet.display;
(je peux avoir plusieurs méthodes d'affichage par exemple)
je crois que un_objet.display est malheureusement du type std::ostream&
(MonObjet::*)(std::ostream&), où un truc du genre :-)) (je doute de ce que
j'écris parfois)
Marc
mais je voudrais écrire plutôt un truc du genre flux<<un_objet.display; (je peux avoir plusieurs méthodes d'affichage par exemple) je crois que un_objet.display est malheureusement du type std::ostream& (MonObjet::*)(std::ostream&), où un truc du genre :-)) (je doute de ce que j'écris parfois) Marc
mais je voudrais écrire plutôt un truc du genre flux<<un_objet.display; (je peux avoir plusieurs méthodes d'affichage par exemple) je crois que un_objet.display est malheureusement du type std::ostream& (MonObjet::*)(std::ostream&), où un truc du genre :-)) (je doute de ce que j'écris parfois)
Oui, cela ne fonctionnera pas comme ça. Il y a une possibilité de changer l'état du flux à l'aide d'un manipulateur pour qu'ensuite il n'affiche pas la même chose, je crois, mais je ne sais pas exactement comment il faut faire.
Une autre solution est d'utiliser des classes différentes pour chaque méthode d'affichage :
mais je voudrais écrire plutôt un truc du genre
flux<<un_objet.display;
(je peux avoir plusieurs méthodes d'affichage par exemple)
je crois que un_objet.display est malheureusement du type std::ostream&
(MonObjet::*)(std::ostream&), où un truc du genre :-)) (je doute de ce que
j'écris parfois)
Oui, cela ne fonctionnera pas comme ça. Il y a une
possibilité de changer l'état du flux à l'aide d'un
manipulateur pour qu'ensuite il n'affiche pas la même
chose, je crois, mais je ne sais pas exactement comment
il faut faire.
Une autre solution est d'utiliser des classes différentes
pour chaque méthode d'affichage :
mais je voudrais écrire plutôt un truc du genre flux<<un_objet.display; (je peux avoir plusieurs méthodes d'affichage par exemple) je crois que un_objet.display est malheureusement du type std::ostream& (MonObjet::*)(std::ostream&), où un truc du genre :-)) (je doute de ce que j'écris parfois)
Oui, cela ne fonctionnera pas comme ça. Il y a une possibilité de changer l'état du flux à l'aide d'un manipulateur pour qu'ensuite il n'affiche pas la même chose, je crois, mais je ne sais pas exactement comment il faut faire.
Une autre solution est d'utiliser des classes différentes pour chaque méthode d'affichage :
Selon tes souhaits, tu pourrais aussi faire que display() remet à zéro la mode, après s'en être servi.
Dans un environement multi-thread, il faudrait bien entendu s'arranger pour que getIWordIndex soit appelé au moins une fois avant le démarrage des threads. (Normalement, un :
int dummyForInitialization = MonObject::getIWordIndex() ;
à la portée namespace dans une module linkée statiquement ferait l'affaire.)
je crois que un_objet.display est malheureusement du type std::ostream& (MonObjet::*)(std::ostream&), où un truc du genre :-)) (je doute de ce que j'écris parfois)
Je crois surtout que le seul opérateur valid sur « un_object.display », si display est une fonction membre, c'est (). Le résultat de l'expression, en fait, ne se laisse pas décrire dans le système de types du C++ ; elle ne peut donc servir que dans des cas spéciaux documentés.
-- James Kanze (GABI Software) email: Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Selon tes souhaits, tu pourrais aussi faire que display() remet
à zéro la mode, après s'en être servi.
Dans un environement multi-thread, il faudrait bien entendu
s'arranger pour que getIWordIndex soit appelé au moins une fois
avant le démarrage des threads. (Normalement, un :
int dummyForInitialization = MonObject::getIWordIndex() ;
à la portée namespace dans une module linkée statiquement ferait
l'affaire.)
je crois que un_objet.display est malheureusement du type
std::ostream& (MonObjet::*)(std::ostream&), où un truc du
genre :-)) (je doute de ce que j'écris parfois)
Je crois surtout que le seul opérateur valid sur
« un_object.display », si display est une fonction membre,
c'est (). Le résultat de l'expression, en fait, ne se laisse
pas décrire dans le système de types du C++ ; elle ne peut donc
servir que dans des cas spéciaux documentés.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Selon tes souhaits, tu pourrais aussi faire que display() remet à zéro la mode, après s'en être servi.
Dans un environement multi-thread, il faudrait bien entendu s'arranger pour que getIWordIndex soit appelé au moins une fois avant le démarrage des threads. (Normalement, un :
int dummyForInitialization = MonObject::getIWordIndex() ;
à la portée namespace dans une module linkée statiquement ferait l'affaire.)
je crois que un_objet.display est malheureusement du type std::ostream& (MonObjet::*)(std::ostream&), où un truc du genre :-)) (je doute de ce que j'écris parfois)
Je crois surtout que le seul opérateur valid sur « un_object.display », si display est une fonction membre, c'est (). Le résultat de l'expression, en fait, ne se laisse pas décrire dans le système de types du C++ ; elle ne peut donc servir que dans des cas spéciaux documentés.
-- James Kanze (GABI Software) email: Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Marc G
Merci pour ta réponse détaillée C'est vrai qu'entre écrire par exemple cout<<mon_objet.displayHTML où displayHTML serait une méthode et cout<<displayHTML(mon_objet) où displayHTML est une structure la différence est objectivement minime et purement syntaxique ! Je m'excuse si je donne parfois l'impression de poser des questions "cons" mais je débute un peu en programmation C++ "avancée" (si on peut appeler ça comme ça) Nota : J. Kanze vient de me proposer une solution à partir des manipulateurs de flux Marc
Merci pour ta réponse détaillée
C'est vrai qu'entre écrire par exemple
cout<<mon_objet.displayHTML où displayHTML serait une méthode
et
cout<<displayHTML(mon_objet) où displayHTML est une structure
la différence est objectivement minime et purement syntaxique !
Je m'excuse si je donne parfois l'impression de poser des questions "cons"
mais je débute un peu en programmation C++ "avancée" (si on peut appeler ça
comme ça)
Nota : J. Kanze vient de me proposer une solution à partir des manipulateurs
de flux
Marc
Merci pour ta réponse détaillée C'est vrai qu'entre écrire par exemple cout<<mon_objet.displayHTML où displayHTML serait une méthode et cout<<displayHTML(mon_objet) où displayHTML est une structure la différence est objectivement minime et purement syntaxique ! Je m'excuse si je donne parfois l'impression de poser des questions "cons" mais je débute un peu en programmation C++ "avancée" (si on peut appeler ça comme ça) Nota : J. Kanze vient de me proposer une solution à partir des manipulateurs de flux Marc
Marc G
c'est "simple" mais il faut quand même avoir l'habitude de manier des écritures du genre ostream& (MonObject::* const pf[])( ostream&) ce qui n'est pas (encore) mon cas :-(( mais je me suis accroché et j'ai compris. En fait, je ne connaissait pas non plus l'existence de xalloc et iword Merci encore
c'est "simple" mais il faut quand même avoir l'habitude de manier des
écritures du genre
ostream& (MonObject::* const pf[])( ostream&)
ce qui n'est pas (encore) mon cas :-((
mais je me suis accroché et j'ai compris.
En fait, je ne connaissait pas non plus l'existence de xalloc et iword
Merci encore
c'est "simple" mais il faut quand même avoir l'habitude de manier des écritures du genre ostream& (MonObject::* const pf[])( ostream&) ce qui n'est pas (encore) mon cas :-(( mais je me suis accroché et j'ai compris. En fait, je ne connaissait pas non plus l'existence de xalloc et iword Merci encore
Marc G
j'essaye de généraliser ta méthode avec des templates
template <class T> class toHTML { public : toHTML(const T &t) : _t(t) {} friend std::ostream& operator<<(std::ostream&,const toHTML&); private : const T &_t; };
// cette fonction template doit être spécialisée pour les classes // avec une sortie HTML possible template <class T> std::ostream& operator<<(std::ostream &flux,const toHTML<T> &source) { flux<<"sortie HTML non définie"; return flux; }
j'essaye de généraliser ta méthode avec des templates
template <class T>
class toHTML {
public :
toHTML(const T &t) : _t(t) {}
friend std::ostream& operator<<(std::ostream&,const toHTML&);
private :
const T &_t;
};
// cette fonction template doit être spécialisée pour les classes
// avec une sortie HTML possible
template <class T>
std::ostream& operator<<(std::ostream &flux,const toHTML<T> &source)
{
flux<<"sortie HTML non définie";
return flux;
}
j'essaye de généraliser ta méthode avec des templates
template <class T> class toHTML { public : toHTML(const T &t) : _t(t) {} friend std::ostream& operator<<(std::ostream&,const toHTML&); private : const T &_t; };
// cette fonction template doit être spécialisée pour les classes // avec une sortie HTML possible template <class T> std::ostream& operator<<(std::ostream &flux,const toHTML<T> &source) { flux<<"sortie HTML non définie"; return flux; }
