Discussion :

[ternel]

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 :

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

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:

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

Voici mon programme de démonstration:

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
#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?

[ternel]

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

Code :

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

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.

[Klaim]

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 :

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
 
#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 :

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

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,

[Ehonn]

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.

[Klaim]

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...

[Klaim]

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

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
#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 :

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

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

[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.

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 :

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

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

Code :

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

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";
               ^

[Ehonn]

Bonjour

Tu essayes de modifier un temporaire.
Soit tu instancies :

Code :

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

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 :

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

1
2
3
4
5
6
template <typename T>
leaver const & operator<<(leaver const & leaver, T const & t)
{
	std::cerr << t;
	return leaver;
}

Code :

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

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.

[Klaim]

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

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
 
#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...