Problème de définition.

Bonjour à tous.

J'ai un programme assez complexe, dans lequel j'ai une quinzaine d'occasions de vouloir utiliser exit() après avoir affiché un message.

Voici le code de base pour ce genre de sorties

Code:

---

1 2 3 4

if (!condition) { cerr << "erreur grave!" << endl; exit(-4); }

---

Plutôt que d'avoir quinze fois ce genre de choses, j'essaie d'obtenir: if (!condition) leave(-4) << "erreur grave!" << endl;Pour se faire, un peu naïvement, je raiie cerr en mettant l'appel à exit() dans le destructeur.
Sauf que, ca ne compile pas avec g++ 4.4.5:

Citation:

---

Envoyé par g++ -Wall -Wextra -Werror

In function ‘int main()’:
error: no match for ‘operator<<’ in ‘leaver(1) << "salut"’

---

Voici mon programme de démonstration:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

#include <iostream> #include <cstdlib> class leaver { private: int flag; public: explicit leaver(int i) : flag(i) {} ~leaver() {::exit(flag);} };   template <typename T> leaver& operator<<(leaver& leaver, T const& t) { std::cerr << t; return leaver; }   int main() { leaver(1) << "salut"<< std::endl; return 0; }

---

Quelqu'un a-t-il une suggestion?

En fait, je suis juste bouché.
Ca fait deux bonnes heures que j'essaie d'écrire ceci:

Code:

---

int& ref = 2;

---

Je m'explique:

Puisque leaver est une classe, et leaver(int) son constructeur, leaver(1) crée une valeur de ce type.

template <typename T> leaver& operator<<(leaver& leaver, T const& t); demande en argument une référence non constante.

donc, avec leaver(1) << 1;, je tente de donner une valeur (temporaire, donc) à une référence non constante.

gcc me dit qu'il ne connait pas de template valable, mais il aurai pu être plus gentil.

Moi je ne comprends pas parceque ce code marche chez moi (VS2012) https://github.com/artofsequence/uti...tilcpp/log.hpp

Et qu'il est similaire.

(meme si c'est pas une bonne idee et que je vais m'empresser de le remplacer par boost.log bientot)


J'ai bien essaye ca sur gcc (http://coliru.stacked-crooked.com/):

Code:

---

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

#include <iostream> #include <cstdlib>   class leaver { private: int flag; public: explicit leaver(int i) : flag(i) {} ~leaver() {::exit(flag);}   template <typename T> leaver& operator<<( const T& t) { std::cerr << t; return *this; }     };       int main() { leaver(1) << "salut"<< std::endl; return 0; }

---

Mais j'obtiens plein d'erreurs, la premiere etant:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

+ g++-4.8 -std=c++11 -O2 -Wall -pedantic -pthread main.cpp main.cpp: In function 'int main()': main.cpp:23:22: error: no match for 'operator<<' (operand types are 'leaver' and '<unresolved overloaded function type>') leaver(1) << "salut"<< std::endl; ^ main.cpp:23:22: note: candidates are: main.cpp:12:9: note: template<class T> leaver& leaver::operator<<(const T&) leaver& operator<<( const T& t) { ^ main.cpp:12:9: note: template argument deduction/substitution failed: main.cpp:23:30: note: couldn't deduce template parameter 'T' leaver(1) << "salut"<< std::endl; ^ In file included from /usr/include/c++/4.8/iostream:39:0,

---

Bonjour

Tu essayes de modifier un temporaire.
Soit tu instancies :

Code:

---

1 2 3 4 5 6

int main() { leaver l(1); l << "salut\n"; return 0; }

---

Soit tu passes ton leaver par référence sur membre constant (comme il n'est pas modifié) :

Code:

---

1 2 3 4 5 6

template <typename T> leaver const & operator<<(leaver const & leaver, T const & t) { std::cerr << t; return leaver; }

---

Code:

---

1 2 3 4 5

int main() { leaver(1) << "salut\n"; return 0; }

---

Pour endl, c'est une fonction qui prend un std::ostream donc je pense qu'il faut que ton leaver hérite d'un std::ostream.

Ok donc c'est pour ca qu'en fait ma version marche mais pas avec std::endl.

Code:

---

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

#include <iostream> #include <cstdlib>   class leaver { private: int flag; public: explicit leaver(int i) : flag(i) {} ~leaver() {::exit(flag);}   template <typename T> leaver& operator<<( const T& t) { std::cerr << t; return *this; }     };       int main() { leaver(1) << "salut\n"; return 0; }

---

Au passage, les temporaires ne sont pas const hein...

Citation:

---

Envoyé par Klaim

Moi je ne comprends pas parceque ce code marche chez moi (VS2012) https://github.com/artofsequence/uti...tilcpp/log.hpp

---

VS2012 peut appeler une fonction qui prend une référence alors qu'on lui donne un temporaire. C'est (à priori) pas standard.

Citation:

---

Envoyé par Ehonn

VS2012 peut appeler une fonction qui prend une référence alors qu'on lui donne un temporaire. C'est (à priori) pas standard.

---

GCC aussi comme je viens de le demontrer...

Une version amelioree qui fait presque ce que tu veux...

Code:

---

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

#include <iostream> #include <cstdlib>   class leaver { private: int flag; public: explicit leaver(int i) : flag(i) {} ~leaver() { std::cerr << std::endl; ::exit(flag); }   template <typename T> leaver& operator<<( T&& t) { std::cerr << std::forward<T>(t); return *this; }   };       int main() { leaver(1) << "salut"; return 0; }

---

A priori std::endl etant une fonction il faudrait prendre carement un pointeur de fonction avec sa signature pour que

Code:

---

leaver(0) << std::endl

---

passe.



EDIT> A verifier dans le standard mais il me semble bien que les temporaires ne sont aps const, c'est les acces qu'on a aux temporaires qui ont besoin de l'etre. Voir http://stackoverflow.com/questions/6...does-this-work

Lorsque je dis «modifier un temporaire» c'est modifier le temporaire lui même (pas une copie). Pour moi, c'est un peu comme si tu essayais de récupérer l'adresse d'un temporaire.

Oui, mais tu as mis la déclaration dans la classe (les règles changent (?)).
Si tu le sors et prend une référence sur un leaver; ça ne compile pas :

Code:

---

1 2 3 4 5

template <typename T> leaver& operator<<(leaver & l, const T& t) { std::cerr << t; return l; }

---

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

main.cpp: In function ‘int main()’: main.cpp:22:12: erreur: no match for ‘operator<<’ (operand types are ‘leaver’ and ‘const char [7]’) leaver(1) << "salut\n"; ^ main.cpp:22:12: note: candidate is: main.cpp:16:9: note: template<class T> leaver& operator<<(leaver&, const T&) leaver& operator<<(leaver & l, const T& t) { ^ main.cpp:16:9: note: template argument deduction/substitution failed: main.cpp:22:15: note: cannot convert ‘leaver(1)’ (type ‘leaver’) to type ‘leaver&’ leaver(1) << "salut\n"; ^

---

Citation:

---

Envoyé par Ehonn

Lorsque je dis «modifier un temporaire» c'est modifier le temporaire lui même (pas une copie). Pour moi, c'est un peu comme si tu essayais de récupérer l'adresse d'un temporaire.

---

Dans toute la discussion il n'est pas question de copie du temporaire. Recuperer l'adresse d'un temporaire donne UB. Modifier la valeure d'un temporaire pendant qu'il est vivant n'est pas UB et est valide (voir le lien stackoverflow). En revanche, donner un nom a l'objet est invalide si on y accede pas en lecture seule (const ref ou via une copie).

Citation:

---

Oui, mais tu as mis la déclaration dans la classe (les règles changent (?)).
Si tu le sors et prend une référence sur un leaver; ça ne compile pas :

---

Si j'ai bien compris, dans le cas de la fonction externe, on donne un nom a l'objet, ce qui fait que dans ce cas precis le temporaire a un nom on dois y acceder en lecture seule (on peut forcer via un const cast mais alors UB).

Du coup c'est logique: dans la fonction membre l'objet n'a pas de nom, tout ce qui se passe dans les membres ne peut se passer que le temps de vie de l'objet, donc c'est valide.

J'ai utilise du code comme ca dans plein de projets sur plusieurs annees avec plusieurs compilo et OS differents (linux et windows) et ca a toujours marche. Pendant longtemps je pensais qu'un temporaire etait toujours const mais c'est pas exactement ca (et bien explique dans le lien stackoverflow).

Merci pour ces explications :)

Un temporaire est un objet comme un autre, on peut en faire ce qu'on veut, la subtilité c'est qu'il va être détruit sous peu et qu'il faut donc prendre des précautions.

Par exemple le code que tu donne plus haut pour operator<< Ehonn (le premier) est un gros risque d'UB. En effet je peux lui passer un temporaire, mais il va me retourner une référence invalide car le temporaire sera détruit à la sortie.

On peut récupérer un temporaire via une const ref et le modifier en castant, le risque est que rien ne prévaut l'utilisateur de ne pas passer un objet qui est vraiment constant, ce qui donnerait un UB.

De même on peut prendre adresse d'un temporaire, il n'y a aucun problème tant qu'on ne l'utilise que quand le temporaire est en vie.

Ce qu'on ne peut pas faire c'est modifier un objet réellement constant et prendre l'adresse d'autre chose qu'une lvalue.

Cela dit, en trichant un peu, on s'en sort aussi pour endl.
il suffit de retourner cerr et non le leaver dans <<.

Je m'en suis donc sorti avec ceci:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

#include <iostream> #include <cstdlib> class leaver { private: int flag; public: explicit leaver(int i) : flag(i) {} ~leaver() {::exit(flag);}   template <typename T> std::ostream& operator<<(T const& t) const {return std::cerr << t;} };   int main() { leaver(1) << "salut" << " a " << "tous" << std::endl; return 0; }

---

Ca remplit mon besoin, ca me suffira.

Dans le cas où j'aurai voulu m'entêter à retourner le leaver, il aurait fallu une surcharge de operator<< pour prendre les fonctions en argument.

Citation:

---

Envoyé par signature de endl

template< class CharT, class Traits >
std::basic_ostream<charT,traits>& endl( std::basic_ostream<CharT, Traits>& os);

---

Merci pour le coup de main!

Note que si le premier argument est std::endl, ca compilera pas...

Sinon tu peux aussi écrire la surcharge pour prendre en compte les manipulateurs de flux.

La signature a utilisé est celle qui correspond au charT et traits du flux que tu utilise (regarde dans la norme/doc la déclaration de cerr pour les avoirs). Et l'utilisation du manipulateur se fait juste en l'appelant sur ton flux.

Si tu veux des exemples, en fouillant dans la norme/doc tu devrais voir comment les flux standard font.

Cependant, si tu veux faire les choses proprement, tu définis un vrai flux en héritant du std::basic_ostream qui va bien, et tu te débrouilles pour l'attacher au buffer utilisé par std::cerr (en décrochant std::cerr ou non). Ainsi tu auras automatiquement tout ce qu'il faut.

C'est tout à fait vrai.

C'est juste que je n'en ai pas besoin, dans mon cas.

En fait, j'ai laissé le endl,mais j'aurai pu le placer silencieusement dans mon destructeur.

C'est juste un critere d'esthétique.

je pense plus cohérent pour le lecteur d'avoir le endl explicite.

Code:

---

1 2 3 4 5 6 7

if(error) { leaver(-1) << "erreur: fichier invalide" << std::endl; } //me semble moins déroutant que ceci: if(error) { leaver(-1) << "erreur: fichier invalide"; }

---

Citation:

---

Envoyé par leternel

C'est tout à fait vrai.

C'est juste que je n'en ai pas besoin, dans mon cas.

En fait, j'ai laissé le endl,mais j'aurai pu le placer silencieusement dans mon destructeur.

C'est juste un critere d'esthétique.

je pense plus cohérent pour le lecteur d'avoir le endl explicite.

Code:

---

1 2 3 4 5 6 7

if(error) { leaver(-1) << "erreur: fichier invalide" << std::endl; } //me semble moins déroutant que ceci: if(error) { leaver(-1) << "erreur: fichier invalide"; }

---

---

Perso je prefere avoir un flush explicite dans le destructeur de leaver et laisser l'utilisateur faire des sauts de ligne avec '\n' . Ca n'a rien de choquant je trouve.

Don tu trouves redondant de devoir écrire :

Code:

---

{ std::cerr << "blabla" << std::endl; exit(x); }

---

Mais dès que tu enlève un ";" et un"{}", tu trouves plus ça redondant ?

Quitte à faire tu pourrais faire une fonction qui fait tout ca d'un coup, à l'appel tu pourrais avoir :

Code:

---

exit(x,"blabla");

---

C'est pas ce qui serait le moins redondant ?

En effet, une macro serait plus efficace pour pouvoir changer l'implementation dans le future si besoin.

Code:

---

#define LOG_EXIT( error_code__ , expr__ ) leaver( error_code__ ) << expr

---

Utilisation:

Code:

---

LOG_EXIT( error_code, "Arg! Objet " << object.id() << " n'est pas valide!" );

---

Si tu dois changer l'implementation, la macro restera valide.

La macro était possible, certes, mais je voulais pouvoir m'en sortir sans.

Je serai aussi partisan de la macro pour ce cas simple.
Vouloir bannir les macros à tout prix est ridicule amha. On y a accès, c'est puissant, autant s'en servir.

Code:

---

1 2 3

#define EXIT_IF(cond, code) if(!(cond)) exit(code)   EXIT_IF(1!=2, 2);

---

Btw, c'est assez semblable à un ASSERT en fait.

Surtout que la le but c'est de rendre le code a la fois lisible et facile a changer plus tard.