C++, Qt, OpenGL, CUDA

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.

^ Chapitre précédent ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ Chapitre suivant ^

====== Conversion de types ======

===== Conversion implicite et explicite =====

on a vu qu'il était possible que le compilateur puisse faire des converison automatiquement (on dit qu'elles sont implicite : http://en.cppreference.com/w/cpp/language/implicit_cast). Par exemple, quand on écrit :

<code cpp>
long int l { 123 };
</code>

La littérale "123" est de type ''int'', la valeur est d'abord convertie en long int avant d'être affectée à la variable l (en pratique, le compilateur sait faire directement cette conversion, cela n'a pas d'impact sur les performances)

Dans d'autres cas, la conversion va produire un avertissement (par exemple quand on perd des informations - narrowing ou arrondi) ou s'il n'existe pas de conversion implcite possible.

<code>
unsigned int u { -1 };     // avertissement, narrowing
int i { "hello, world!" }; // erreur, pas de conversion implicite d'une chaîne en entier
</code>

Dans un conversion explicite (cast), on ajouter un code qui indique que l'on souhaite faire la conversion. Plusieurs opérateur de cast : 

  * static_cast, vérifié à la compilation, entre types compatibles ;
  * dynamic_cast, vérifié à la compialtion entre classes parent (vu plus loin, avec l'héritage) ;
  * reinterpret_cast, sans vérificatio (donc très dangeureux), également pour l'héritage.

Donc pour le moment, seul qui intéresse : static_cast. Fonction template, il faut indiquer le type que l'on souhaite obtenir comme argument template et la valeur à convertir comme argument de fonction. En cas de cast explicite, le compilateur ne génère pas d'avertissement, il considère que l'on sait ce que l'on fait.

<code>
int i { static_cast<int>(-1) }; // ok, pas de narrowing
auto i = static_cast<int>(-1);  // ok, pas de narrowing
</code>

Il existe une ancienne syntaxe que l'on rencontre encore souvent (plus courte à écrire), mais qui ne fait pas de vérification, donc a éviter. http://en.cppreference.com/w/cpp/language/explicit_cast

<code>
int i { int(-1) }; // ok, pas de narrowing
auto i = int(-1);  // ok, pas de narrowing
</code>

===== Constructeur de conversion =====

Lorsque l'on écrit un constructeur qui peut prendre 1 argument (donc avec 1 paramètre ou plusieurs paramètres dont des paramètres par défaut), peut être implicitement utilisé par le compilateur pour faire une conversion.

<code>
struct A {
    A(int i) : i_(i) {}
};

int main() {
    A a { 123 }; // ok, conversion implicite, équivalent à :
                 // A a { A(123) }
};
</code>

Par défaut, il est préférable de bloquer les convesion implicite, sauf si cela a clairement un sens au niveau sémantique. Par exemple, si on écrit une classe Arme, qui prend un int pour les dégats, cela n'a pas de sens d'écrire : Arme a { 10 }; (on ne comprend pas à quoi correspond la valeur 10). Par contre, pour un complexe, écrire complex c { 10 } a un sens puisque 10 est un nombre complexe particulier (c'est un réel, donc un nombre complexe de la forme a+i*0)

Pour interdir l'appel d'un constructeur implicitement, il faut ajouter le mot clé ''explicit'' :

<code>
struct A {
    explicit A(int i) : i_(i) {}
};

int main() {
    A a { 123 };                 // erreur, implcite conversion
    A a { static_cast<A>(123) }; // ok, conversion explicite
};
</code>

===== Opérateur de conversion =====

Opération inverse : convertir un type dans un autre. http://en.cppreference.com/w/cpp/language/cast_operator

<code>
class A {
    operator int();
};
</code>

autorise à écrire :

<code>
A a {};
int i { a }; // ok, conversion avec l'opérateur int()
</code>

^ Chapitre précédent ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ Chapitre suivant ^

{{tag> Cours C++}}
C++, Qt, OpenGL, CUDA

Outils d'utilisateurs

Outils du Site

Outils de la Page
