Discussion :

[r0d]

Allez, encore un petit

Nous avons une classe MyOuput dont le rôle consiste à afficher des valeurs sur la console. Pour diverses raisons spécifiques au cahier des charges, une fonction print() existe pour chaque type que nous souhaitons accepter. Pour d'autres raisons variées, encore spécifiques au cahier des charges, nous décidons de créer une couche d'abstraction supplémentaire, un wrapper, qui lui va gérer le problème en utilisant une fonction template:

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 <string>
using namespace std;
 
struct MyOutput
{
	void print(const string & value) const { cout << "string: " << value << endl; }
	void print(bool value) const { cout << "bool: " << value << endl; }
};
 
struct Wrapper
{
	template <typename T>
	void print(const T & value) const { my_output_.print(value); }
 
private:
	MyOutput my_output_;
};
 
int main()
{
	Wrapper my_wrapper;
	my_wrapper.print("test");
	my_wrapper.print(false);
 
	getchar();
	return 0;
}

Questions:
Quel est l'output de ce programme?
Pourquoi?

[Ehonn]

Encore plus vicieux ^^

Tel quel, le code affiche un booléen pour "test", car "test" est un char * et non un std::string. Un char * est plus facilement convertible en bool (ou int) par la promotion d'entier qu'en std::string (convertion implicite avec un constructeur qui a un seul argument).

C++ "traîne" derrière lui son héritage C. Cela peut être commode (réutilisation de code) mais est aussi incroyablement dangereux, comme ici.
Pour éviter ceci, il faut utiliser uniquement std::string.

Et donc le code suivant :

Code :

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

my_wrapper.print("test");

devrait être :

Code :

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

my_wrapper.print(std::string("test"));

ou en C++14 (il me semble) :

Code :

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

my_wrapper.print("test"s);

ou en C++11 avec le « user-defined literals » qui va bien :

Code :

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

my_wrapper.print("test"_s);

Demander ça à l'utilisateur n'est pas raisonnable et donc il faut fournir une surcharge pour char * :

Code :

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

void print(char const * const value) const { std::cout << "string: " << value << std::endl; }

PS : Il manque tous les std:: aux cout et endl.

[r0d]

Encore plus vicieux ^^

Et encore excellente réponse de ta part

Un char * est plus facilement convertible en bool

Histoire d'ajouter une précision, c'est parce qu'un char * est un pointeur. Donc mon exemple fonctionne avec n'importe quel type de pointeur en fait.
A noter que le wrapper et l'histoire de template ne sont là, encore une fois, que pour brouiller les pistes.

PS : Il manque tout les std:: au cout.

Damned! Je vais corriger ça tout de suite. Merci

[ternel]

Quitte à préciser que char* est un pointeur, rajoutons que bool est un entier (si si...) et que tout "non-0" est vrai.
Comme 0 est une adresse invalide, strictement jamais attribuée, le code affichera nécessairement "bool: 1", c'est à dire print(true)

Les chemins de conversions envisageable pour cette surcharge est:
const char* > int > bool
const char* > implicite std::string(const char*)

Avec, comme indiqué, la règle que sera préférée les conversions à la construction.

[ternel]

Ça me rappelle une règle de codage que j'ai eu un jour:

Bien que les strings soient sexys, il a toujours quelqu'un pour refuser d'en utiliser.

[Médinoc]

Quitte à préciser que char* est un pointeur, rajoutons que bool est un entier (si si...) et que tout "non-0" est vrai.

Attention, j'ai vu récemment que cela n'était valable que pour un Booléen valide (obtenu en le construisant, ou par cast/affectation etc.), et donc garanti contenir seulement 0 ou 1: Un Booléen obtenu par truandage (ou non-initialisation) peut être non-nul et considéré faux, car certains compilos ne testent que le bit de poids faible.

Si int a=33;, alors (bool)a est valide*, tandis que *reinterpret_cast<bool*>(&a) causera un comportement indéfini.

*Si ça marche comme pour les flottants, reinterpret_cast<bool>(a) devrait également faire la conversion valide.

[ternel]

d'un autre côté, rencontrer des problèmes quand on en est au *cast*, c'est un peu normal.