La conversion fonctionne (C++)

Lors de la conversion par les constructeurs, décrites dans la section précédente, les objets d'un type peuvent être convertis implicitement à un type spécial de classe.cette section décrit les moyens par lesquels vous pouvez fournir des conversions explicites d'un type donné de classe à un autre type.La conversion d'un type de classe est souvent obtenu à l'aide de fonctions de conversion.les fonctions de conversion utilisent la syntaxe suivante :

Grammaire

• conversion-fonction-nom:
  conversion-type-nom **()**d'opérateur

• conversion-type-nom:
  PTR-opérateur de type-spécificateur-listeopt

L'exemple suivant spécifie une fonction de conversion que le convertit un type Money de taper double:

// spec1_conversion_functions1.cpp
struct Money {
   operator double() { return _amount; }

private:
    double _amount;
};

int main() {
   Money Account;
   double CashOnHand = Account;
}

L'initialisation d' CashOnHand avec Account fait de taper une conversion de type Accountdouble.

Les fonctions de conversion sont souvent appelées « opérateurs de cast » car elles (avec des constructeurs) sont les fonctions appelées lorsqu'un cast est utilisé.L'exemple suivant utilise un cast, ou la conversion explicite, pour imprimer la valeur actuelle d'un objet de type Money:

cout << (double)Account << endl;

Les fonctions de conversion sont héritées des classes dérivées.Les opérateurs de conversion masquent uniquement des opérateurs de conversion de classe de base qui convertissent exactement au même type.par conséquent, une fonction définie par l'utilisateur d' opérateur int ne masque pas une fonction définie par l'utilisateur d' opérateur abrégée dans une classe de base.

Seule une fonction définie par l'utilisateur de conversion est appliquée en exécutant les conversions implicites.S'il n'y a aucune fonction définie explicitement de conversion, le compilateur ne trouve pas les types intermédiaires dans lesquels un objet peut être converti.

S'il requiert une conversion qui provoque une ambiguïté, une erreur est générée.Les ambiguïtés surviennent lorsque plusieurs conversions définies par l'utilisateur est disponible ou si une conversion définie par l'utilisateur et une conversion prédéfinie existent.

Exemple

l'exemple suivant montre une déclaration de classe avec une ambiguïté potentielle :

// spec1_conversion_functions2.cpp
#include <string.h>
#include <stdio.h>

struct String {
   // Define constructor that converts from type char *.
   String( char *szBuffer ) {
      strcpy_s( _text, szBuffer );
   }

   // Define conversion to type char *.
   operator char *() {
      return _text;
   }

   int operator==( const String &s )  {
      return !strcmp( _text, s._text );
   }

private:
   char _text[80];
};

int main() {
   String s( "abcd\0" );
   char *ch = "efgh";

   // Cause the compiler to select a conversion.
   return s == ch; // C2666
}

Dans l'expression s == ch, le compilateur n'avez deux possibilités et aucun moyen de déterminer qui est correct.Elle peut convertir ch à un objet de type String à l'aide de le constructeur puis exécuter la comparaison à l'aide de operator==défini par l'utilisateur.Elle peut convertir s à un pointeur de type char * à l'aide de la fonction de conversion puis effectuer une comparaison des pointeurs.

Dans la mesure où aucun de choix n'est « plus correct » à l'autre, le compilateur ne peut pas déterminer la signification de l'expression de comparaison, et il génère une erreur.

Voir aussi

Référence

Conversions