Discussion :

[Sylvain Rousseau]

Bonjour,

Voici un petit code d'exemple dont je ne comprends pas l'exécution :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 
class myClass {
public :
  operator void*() const { return (void*)this;}
};
 
void main() {
 
  myClass myClass1;
  if ( myClass1 )
    int i = 0;
 
}

Si je trace ce code, alors l'exécution du test if ( myclass1 ) entraîne l'appelle de l'opérateur de transtypage (void*) de la classe myClass.
Si j'implémente myClass::operator bool() alors c'est l'opérateur de
transtypage (bool) de la classe myClass qui est appelé.

Quelqu'un pourrait m'expliquer pourquoi le compilateur génère un appel à l'opérateur de transtypage (void*) de la classe myClass si myClass::operator bool() n'existe pas ?

Merci pour votre aide.

Sylvain

[3DArchi]

Salut,
Il me semble que l'article The Safe Bool Idiom l'explique assez bien. En résumé :

Any rvalue of arithmetic, enumeration, pointer, or pointer to member type, can be implicitly converted to an rvalue of type bool

[screetch]

un const void* serait le bienvenu (c'est pas le problème évidemment)

c'est parce que un void* peut etre casté uniquement en un bool
tandis qu'un bool peut lui etre casté vers un int, meme un float, sans problème.
exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
struct Test
{
    operator bool () const { return true; }
};
 
int main(int argc, char *argv[])
{
    Test t;
    float f = t;
    return 0;
}

donc il est conseillé de ournir un opérateur vers (const)void* pour la conversion en bool, et un opérateur ! pour le test d'invalidité (pour couvrir les cas if(blabla) et if(!blabla)

[JolyLoic]

A noter que dans la prochaine version du C++, on pourra définir un tel opérateur comme explicit, ce qui fait qu'on pourra simplement retourner un bool et arrêter tous ces contournements (remarque : L'opérateur de conversion en void* n'est pas la méthode la plus sûre actuellement).

[Sylvain Rousseau]

Merci pour vos réponses, c'est plus clair maintenant.

Une précision : JolyLoic, tu veux dire que dans la version ultérieure de C++, le mot clé "explicit" employé sur l'opérateur de transtypage implique que cela sera le constructeur de transtypage qui sera appelé lors d'une conversion implicite et non l'opérateur de transtypage ?

Cordialement

Sylvain

[JolyLoic]

Non, je veux dire que si on a :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
class A
{
public:
  explicit operator bool() {...}
};
 
A a;
if (a) {...} // Ok
bool b1 = a; // Ok
bool b2 = !a; // Ok
bool b3 = c && a; // Ok
int i1 = a; // Pas ok
int i2 = a+1; // Pas ok

Sans le explicit (la situation courante), toutes les lignes seraient ok, et appelleraient l'opérateur de conversion, ce qui n'est probablement pas souhaité, et a causé tout un tas de contournements.

Pour plus de détails : http://www.open-std.org/jtc1/sc22/wg...2007/n2437.pdf

[Sylvain Rousseau]

Merci pour tant de pédagogie !