Conversion de type

informatique , la conversion de type , le transtypage la coercition de type [ et la manipulation de types sont différentes méthodes pour transformer une expression d'un type de données à un autre. Par exemple, on peut convertir une valeur entière en une valeur à virgule flottante ou sa représentation textuelle sous forme de chaîne de caractères , et inversement. Les conversions de type peuvent tirer parti de certaines caractéristiques des hiérarchies de types ou des représentations de données . Deux aspects importants d'une conversion de type sont son caractère implicite (automatique) ou explicite ] , et le fait que la représentation de données sous-jacente soit convertie d'une représentation à une autre, ou simplement réinterprétée comme la représentation d'un autre type de données En général, les types de données primitifs et composés peuvent être convertis.

Chaque langage de programmation possède ses propres règles de conversion de types. Les langages à typage fort limitent généralement les conversions implicites et découragent la réinterprétation des représentations, tandis que les langages à typage faible effectuent de nombreuses conversions implicites entre types de données. Ces derniers permettent souvent de forcer le compilateur à interpréter arbitrairement une donnée comme ayant différentes représentations ; il peut s’agir d’une erreur de programmation peu évidente ou d’une méthode technique permettant d’interagir directement avec le matériel sous-jacent.

Dans la plupart des langages, le terme « conversion » désigne une conversion implicite , que ce soit à la compilation ou à l'exécution . Par exemple, dans une expression mêlant entiers et nombres à virgule flottante (comme 5 + 0,1), le compilateur convertit automatiquement la représentation entière en représentation à virgule flottante afin de conserver les fractions. Les conversions de type explicites sont indiquées soit par l'ajout de code (par exemple, en ajoutant des identificateurs de type ou en appelant des fonctions intégrées ), soit par la programmation de routines de conversion que le compilateur utilisera lorsqu'il s'arrêterait en raison d'une incompatibilité de types.

Dans la plupart des langages de type ALGOL , tels que Pascal , Modula-2 , Ada et Delphi , la conversion et le transtypage sont deux concepts bien distincts. Dans ces langages, la conversion désigne le changement, implicite ou explicite, d'une valeur d'un format de stockage de données à un autre, par exemple d'un entier 16 bits à un entier 32 bits. Les besoins en stockage peuvent être modifiés suite à la conversion, avec une possible perte de précision ou une troncature. Le terme « transtypage » , en revanche, désigne le changement explicite de l' interprétation de la séquence binaire représentant une valeur d'un type à un autre. Par exemple, 32 bits contigus peuvent être traités comme un tableau de 32 booléens, une chaîne de 4 octets, un entier non signé 32 bits ou une valeur à virgule flottante simple précision IEEE. Étant donné que les bits stockés ne sont jamais modifiés, le programmeur doit connaître les détails de bas niveau, tels que le format de représentation, l'ordre des octets et les exigences d'alignement, pour effectuer un transtypage pertinent.

Dans la famille de langages C et ALGOL 68 , le terme « cast » désigne généralement une conversion de type explicite (par opposition à une conversion implicite), ce qui peut prêter à confusion : s’agit-il d’une réinterprétation d’une séquence de bits ou d’une véritable conversion de représentation des données ? Plus important encore est la multitude de règles et de méthodes qui régissent le type de données (ou la classe) accessible par un pointeur, ainsi que la manière dont ce pointeur peut être ajusté par le compilateur, notamment dans le cas de l’héritage d’objets (ou de classes).

Ada fournit une fonction de bibliothèque générique Unchecked_Conversion.

Langages de type C

Conversion de type implicite

La conversion implicite de type, également appelée coercition ou jonglage de types , est une conversion de type automatique effectuée par le compilateur . Certains langages de programmation autorisent le compilateur à effectuer cette coercition ; d’autres l’exigent.

Dans une expression de types mixtes, les données d'un ou plusieurs sous-types peuvent être converties en un supertype au moment de l'exécution , selon les besoins , afin que le programme fonctionne correctement. Par exemple, le code suivant est valide en langage C :

i) { d = i; } if (i > l) { l = i; } if (d == l) { d *= 2; } "

double d ; long l ; entier i ;si ( d > i ) { d = i ; }si ( i > l ) { l = i ; }si ( d == l ) { d *= 2 ; }

Bien que d , l et i appartiennent à des types de données différents, ils seront automatiquement convertis en types de données identiques à chaque comparaison ou affectation. Ce comportement doit être utilisé avec précaution, car des conséquences imprévues peuvent survenir. Des données peuvent être perdues lors de la conversion de représentations à virgule flottante en entiers, car les parties fractionnaires des valeurs à virgule flottante seront tronquées (arrondies à zéro). Inversement, la précision peut être perdue lors de la conversion de représentations d'entiers en nombres à virgule flottante, car un type à virgule flottante peut être incapable de représenter exactement toutes les valeurs possibles d'un type entier. Par exemple, un entier peut être un type simple précision IEEE 754 , qui ne peut pas représenter exactement l'entier 16 777 217, contrairement à un entier 32 bits. Cela peut conduire à un comportement contre-intuitif, comme le montre le code suivant :

" , my_int ); printf ( "Le flottant est : %f " , my_float ); printf ( "Leur égalité : %d " , my_int == my_float ); }

Sur les compilateurs qui implémentent les nombres à virgule flottante en simple précision IEEE et les entiers sur au moins 32 bits, ce code donnera cet affichage particulier :

L'entier est : 16777217 Le nombre flottant est : 16777216,000000 Leur égalité : 1

Notez que 1 représente l'égalité dans la dernière ligne ci-dessus. Ce comportement inhabituel est dû à une conversion implicite de ` troncature , c'est-à-dire la suppression de la partie fractionnaire.

sur-ensemble du type d'origine. Les promotions sont couramment utilisées avec les types plus petits que le type natif de l' unité arithmétique et logique (UAL) de la plateforme cible, avant les opérations arithmétiques et logiques, afin de rendre ces opérations possibles, ou plus efficaces si l'UAL peut gérer plusieurs types. En C et C++, cette promotion est effectuée pour les objets de type booléen, caractère, caractère large, énumération et entier court (promus en `int`), ainsi que pour les objets de type flottant (promus en `double`). Contrairement à certaines autres conversions de type, les promotions ne perdent jamais en précision et ne modifient jamais la valeur stockée dans l'objet.
En Java :
aliasing .Dans les langages de programmation orientés objet , les objets peuvent également être convertis vers une classe dérivée : une référence à une classe de base est convertie vers l’une de ses classes dérivées.

`C# et C++`

En C# , la conversion de type peut être effectuée de manière sûre ou non sûre (c'est-à-dire de type C), la première étant appelée conversion de type vérifiée .

C++, un effet similaire peut être obtenu en utilisant la syntaxe de conversion de type C++ .
Eiffel, la notion de conversion de type est intégrée aux règles du système de types. La règle d'affectation stipule qu'une affectation, telle que `a = b` , est valide si et seulement si le type de son expression source (` a`) est compatible avec le type de son entité cible (` b`). Dans cette règle, « compatible avec » signifie que le type de l'expression source est soit conforme au type de la cible , soit convertible en celui-ci. La conformité des types est définie par les règles de polymorphisme de la programmation orientée objet . Par exemple, dans l'affectation ci-dessus, le type de `a` est conforme au type de `b` si la classe sur laquelle `a` est basée est une classe descendante de celle sur laquelle `b` est basée.x:= yyxyxyx

`Rouiller`

Rust ne propose pas de conversion de type implicite (coercition) entre la plupart des types primitifs. Cependant, une conversion de type explicite (casting) peut être effectuée à l'aide du asmot-clé.

, x as u16 );

`assertion de type`

Dans les systèmes de typage statique, un concept apparenté est l' assertion de type , qui indique au compilateur de traiter l'expression d'un certain type, sans tenir compte de sa propre inférence. Une assertion de type peut être sûre (une vérification est effectuée à l'exécution) ou non sûre. Elle ne convertit pas la valeur d'un type de données à un autre.

`Manuscrit`

En TypeScript , une assertion de type est effectuée en utilisant le asmot-clé :

) as HTMLCanvasElement ;

Dans l'exemple ci-dessus, document.getElementByIdla fonction est déclarée comme renvoyant un `T` HTMLElement, mais vous savez qu'elle renvoie toujours un `T` HTMLCanvasElement, qui est un sous-type de ` HTMLElementT` dans ce cas précis. Si ce n'est pas le cas, le code ultérieur qui dépend du comportement de cette HTMLCanvasElementfonction ne fonctionnera pas correctement, car TypeScript n'effectue aucune vérification d'assertion de type à l'exécution.

En TypeScript, il n'existe pas de méthode générale pour vérifier à l'exécution si une valeur est d'un certain type, car la gestion des types à l'exécution n'est pas prise en charge. Cependant, il est possible de définir une fonction permettant à l'utilisateur d'indiquer au compilateur si une valeur est d'un certain type ou non. Cette fonction est appelée garde de type et est déclarée avec un type de retour ` TypeGuard` x is Type, où ` TypeGuard` xest un paramètre `TypeGuard` ou this`Type`, au lieu de `Type` boolean.

Cela permet de contenir les assertions de type non sécurisées dans la fonction de vérification au lieu de les disperser dans tout le code source.

`Aller`

En Go , une assertion de type permet d'accéder à une valeur de type concret à partir d'une valeur d'interface. Cette assertion est sûre : elle provoquera une panique (dans le cas d'une seule valeur de retour) ou renverra la valeur zéro (si deux valeurs de retour sont utilisées) si la valeur n'est pas du type concret recherché.

les types union , qui peuvent contenir une valeur de plusieurs types. Les unions non étiquetées sont disponibles dans certains langages à typage dynamique peu strict, comme C et PL/I , mais aussi dans le Pascal d'origine . Elles permettent d'interpréter la séquence binaire d'un type comme la valeur d'un autre type.

`Problèmes de sécurité`

En piratage informatique , le transtypage consiste à détourner la conversion de type pour modifier temporairement le type de données d'une variable par rapport à sa définition initiale. Cela offre des opportunités aux pirates informatiques car, lors d'une conversion de type, une fois qu'une variable est « transformée » en un type de données différent, le compilateur traitera cette variable modifiée comme le nouveau type de données pour cette opération spécifique.


    
      Plus d articles de Worldlex Wiki
      Revenez a l index pour explorer davantage de pages sur l histoire, la science, la culture, la geographie et la societe en francais.
      Explorer l index