Conversion de types

pour d'autres significations, voient le stéréotype .

Dans le de l'informatique, la conversion de types ou le stéréotype se rapporte à changer une entité d'un type de données en des autres. Ceci est fait pour tirer profit de certains dispositifs de type hiérarchies. Par exemple, des valeurs d'un ensemble plus limité, tel que des nombres entiers, peuvent être stockées dans un format plus compact et plus tard être converties en format différent permettant des opérations pas précédemment possibles, comme la division avec la valeur de plusieurs décimales décimales de l'exactitude. Dans des langages de programmation orientés objectivement du , conversion de types permet à des programmes de traiter des objets d'un type en tant qu'un de leurs types d'ancêtre pour simplifier l'interaction avec eux.

Il y a deux types de conversion : implicite et explicite. La limite pour conversion de types implicite est la coercition de de . La forme la plus commune de conversion de types explicite est connue en tant que bâti de de . Conversion de types explicite peut également être réalisé avec des routines de conversion séparément définies telles qu'un constructeur de l'objet de surchargé par .

Conversion de types implicite

Conversion de types implicite, également connue sous le nom de coercition , est une conversion de type automatique par le compilateur . Quelques langues laissent, ou même exigent, des compilateurs pour fournir la coercition.

Dans une expression du type mixte, des données d'un ou plusieurs sous-types peuvent être converties en Supertype comme nécessaire au temps d'exécution de sorte que le programme fonctionne correctement. Par exemple, ce qui suit est code légal du langage C :

lang=" de double d ; long l ; international i ; si (d > i) d = I ; si (I > l) l = I ; si (*= 2 de == de d l) d ;

Bien que le d , le l et le i appartiennent à différents types de données, ils seront automatiquement convertis en types de données égaux chaque fois que une comparaison ou une tâche est exécutée. Ce comportement devrait être employé avec prudence, car les conséquences fortuites peuvent surgir. Des données peuvent être perdues quand des représentations à point mobile sont converties en représentations intégrales car les composants partiels des valeurs à point mobile seront tronqués (arrondi vers le bas). Réciproquement, la conversion d'une représentation intégrale en à point mobile peut également perdre la précision, puisque le type à point mobile peut ne pouvoir pas représenter le nombre entier exactement (par exemple, le flotteur de pourrait être un type de précision simple d'IEEE 754 , qui ne peut pas représenter le nombre entier 16777217 exactement, alors qu'un type à 32 bits de nombre entier peut). Ceci peut mener aux situations telles que stocker la même valeur de nombre entier dans deux variables du type international et dactylographier simples qui renvoient faux si comparé pour l'égalité.

Conversion de types explicite

Il y a plusieurs genres de conversion explicite.

; vérifié : Avant que la conversion soit exécutée, un contrôle d'exécution est fait pour voir si le type de destination peut tenir la valeur de source. Sinon, une condition d'erreur est augmentée. ; non réprimé : Aucun contrôle n'est exécuté. Si le type de destination ne peut pas tenir la valeur de source, le résultat est non défini. ; configuration binaire : Les données ne sont pas interprétées du tout, et sa représentation crue de peu est copiée in extenso. Ceci peut également être réalisé par l'intermédiaire du crénelage .

Chaque langage de programmation a ses propres règles sur la façon dont des types peuvent être convertis. Généralement les objets et les types de données fondamentaux peuvent être convertis par .

Fonte de charge statique

Dans le C++ l'opérateur du static_cast de change des expressions d'une statique en objets et valeurs des autres statiques.

lang=" de static_cast (objet) ;

Le type paramètre doit être un type de données pour au lequel il y a une méthode connue pour convertir l'objet de , si ce soit un builtin ou par une fonction de bâti. Ce peut être une référence ou un agent recenseur.

L'opérateur de static_cast peut être employé pour des opérations telles que le

Convertir les types de données numériques tels que des enums en ints ou des ints en flotteurs.

Cependant, les conversions de static_cast ne sont pas nécessairement tout sûr qu'aucun type d'exécution contrôle n'est qui peut causer le bâti entre les types de données incompatibles, par exemple les indicateurs faits. Cependant, ceci est vérifié à au moment de la compilation pour empêcher mouler évidemment des incompatibles. En outre, parfois le static_cast entre l'indicateur à baser à l'indicateur à dériver produira un résultat incorrect, en raison du modèle de disposition d'objet.

Conversions en Eiffel

Le langage de programmation d'Eiffel a un véritable mécanisme de conversion permettant à n'importe quel type de définir des conversions à et de n'importe quel autre type. À la différence des mécanismes de bâti de C-modèle il est conçu pour être type-sûr.

Le mécanisme généralise aux types arbitraires que les conventions se sont appliquées par la plupart des langages de programmation aux conversions automatiques entre les types arithmétiques, par exemple NOMBRE ENTIER à VRAI. Puisque ces types eux-mêmes sont définis par des classes, les conversions entre elles ne sont pas " langue-défini ; magic" ; mais spécifique dans la correspondance classe car elles seraient pour n'importe quels autres types.

L'idée fondamentale est qu'un procédé de création (constructeur) peut être spécifié en tant qu'étant également un procédé de conversion. Par exemple une classe de DATE peut avoir la forme

la DATE de classe créent make_from_tuple,… d'autres procédures de création… converti make_from_tuple dispositif … make_from_tuple (t : Mois de TUPLE : CORDE, année : NORMAL) faire … Instructions d'initialiser les champs du courant objet de jour, de mois et d'année… extrémité … extrémité

Alors il est possible de créer un objet de DATE par un procédé normal de création

créer my_date.make_from_tuple (" ; January" ; , 2000) -- là où b, c, dénote un tuple avec les valeurs données

mais parce que le make_from_tuple est également spécifié comme procédé de conversion, une tâche plate fera également, avec le même effet :

my_date : = " ; January" ; , 2000

ou dans un appel

routine_expecting_a_date_argument (" ; January" ; , 2000)

Le mécanisme peut être employé pour définir des conversions non seulement des tuples comme dans cet exemple mais entre deux classes quelconques, par exemple

la classe VRAIE créent make_from_integer converti make_from_integer dispositif make_from_integer (n : Le NOMBRE ENTIER) font… extrémité … extrémité

Cette technique suppose que le programmeur a le contrôle du texte de la classe de cible (DATE et VRAI dans ces exemples). Si ce n'est pas le cas, il est possible de définir une fonction de création (au lieu d'un procédé de création) dans la classe de source.

Les principes principaux, pour garantir la sûreté et la clarté du mécanisme, sont celui

il n'est pas autorisé pour avoir un procédé de conversion d'A à B et une fonction de conversion de B à A (car ceci ferait des tâches telles que l'ambigu ci-dessus).

si B se conforme à A -- la signification de lui est un sous-type, par exemple B est une classe qui hérite de la classe A -- alors il n'est pas autorisé pour faire convertir B également en A.

Voir également

Type faisant des calembours de
Article sur le type bâti chez cplusplus.

Random links: