Comment convertir des types de données en C++
En C++, il existe deux manières de modifier les types de données :
Conversion de type implicite
Selon les règles prédéfinies par le compilateur de code C++, la conversion de type implicite est la conversion de type effectuée automatiquement par le compilateur sans nécessiter de déclencheur externe de la part de l'utilisateur. Ce type de conversion a généralement lieu dans un programme lorsqu'il existe plusieurs types de données et que le type de données de l'expression ne correspond pas au type de données de la variable impliquée dans cette expression.
Pour éviter la perte de données lors de la conversion, le compilateur remplace par défaut le type de données peu précis par le type de données de précision supérieure. Par exemple, il convertira un entier en flottant plutôt que de changer le flottant en entier pour éviter la perte de données. C'est ce qu'on appelle la promotion. Voici le diagramme de priorité pour les différents types de données.
Commande de conversion de type
L'ordre correct pour la conversion de type est donné comme suit :
bouffon -- > caractère -- > entier court -- > entier -- > entier non signé -- > long -- > non signé long -- > très longtemps -- > flotter -- > double -- > longue double
La variable de type basse précision est convertie en type de données haute précision pour éviter la perte de données.
Exemple 1
Dans cet exemple, l'ajout est effectué sur la variable de différents types de données à l'aide de la conversion de type implicite.
#include
en utilisant espace de noms norme ;
int principal ( ) {
int nombre = 100 ;
carboniser personnage = 'C' ;
cout << '100 + 'C' = ' << nombre + personnage << fin ;
flotter Val = nombre + 'c' ;
cout << 'val flottant (100 + 'c') = ' << Val << fin ;
int était = 7890 ;
long n'était pas = était ;
cout << 'var_int = ' << n'était pas ;
retour 0 ;
}
Ici, un entier et un caractère de la table ASCII, ainsi qu'un nombre flottant et le caractère « c » sont ajoutés. L'entier est conservé dans le troisième segment en tant que type de données long et les types de données sont modifiés par le compilateur lui-même en fonction de ses règles prédéfinies.
La somme de 100 et « C » renvoie 167 car le « C » équivaut à 67 en nombres et 100+'c » renvoie 199 car le « c » minuscule équivaut à 99. La variable int est stockée dans un type de données long.
Exemple 2
Dans cet exemple, le caractère D est converti en flottant pour effectuer l'opération de division.
#includeen utilisant espace de noms norme ;
int principal ( ) {
carboniser X = 'D' ;
flotter float_var ;
float_var = flotter ( X ) / 'c' ;
// Conversion explicite d'un int en float.
cout << 'La valeur de float_var est : ' << float_var << fin ;
retour 0 ;
}
La valeur d'entrée se présente sous la forme de caractère D qui est stocké dans le type de données float et ensuite divisé par le caractère C. Ces caractères sont transformés en valeurs numériques et une opération de division est effectuée sur eux, renvoyant la valeur en float.
Conversion de type explicite
L’utilisateur doit modifier manuellement le type de données avec la conversion de type explicite du C++, souvent appelée conversion de type. Ce type de conversion est effectué pour éviter la conversion de type implicite. Il existe deux méthodes pour effectuer un transtypage de type explicite en C++ :
- Conversion à l'aide de l'opérateur d'affectation
- Conversion à l'aide de l'opérateur Cast
Conversion de type à l'aide de l'opérateur d'affectation en C++
La conversion de type à l'aide de l'opérateur d'affectation est effectuée de manière forcée, c'est-à-dire qu'un type de données est converti manuellement en un autre. Ceci est accompli en utilisant l'opérateur d'affectation « = », qui attribue la valeur de l'opérande de droite à la variable sur son côté gauche.
Exemple
Ce programme calcule l'aire du cercle en utilisant la conversion de type.
#inclure
en utilisant espace de noms norme ;
int principal ( )
{
int rayon ;
cout <> rayon ;
flotter zone = M_PI * rayon * rayon ;
cout << 'Aire d'un cercle de rayon' << rayon << ' = ' << zone ;
}
L'opérateur d'affectation est utilisé pour attribuer la valeur flottante à la zone, qui consiste en la valeur du rayon dans un type de données entier.
L'aire du cercle est renvoyée dans le type de données float, tandis que le rayon est saisi dans le type de données entier. Ainsi, le type de données de la variable est modifié via la conversion de type à l'aide de l'opérateur d'affectation.
Conversion de type à l'aide de l'opérateur Cast en C++
La conversion de type est effectuée à l'aide d'un opérateur de conversion, qui force un type de données à changer en un autre type en fonction des besoins du programme.
Il existe quatre opérateurs de diffusion différents :
- static_cast
- const_cast
- dynamique_cast
- réinterpréter_cast
1 : cast_statique
static_cast est l'opérateur de conversion utilisé pour convertir explicitement les flottants et les caractères en entiers, etc. Il s'agit de l'opérateur de diffusion le plus basique. Il peut convertir des types de données de nature similaire. Il peut convertir des pointeurs d'une forme à une autre et peut donc également être utilisé pour la gestion de la mémoire.
Syntaxe
static_cast ( expression ) Exemple
Ce programme est conçu pour convertir une variable double en un type de données int à l'aide de static_cast. Cela supprimera toute partie décimale dans la sortie.
en utilisant espace de noms norme ;
int principal ( )
{
// déclare une variable
double p ;
p = 2 905 * 1 235 * 24 675 ;
flotter résultat ;
cout << ' Avant d'utiliser le casting statique :' << fin ;
cout << ' La valeur de p = ' << p << fin ;
// utilise static_cast pour convertir le type de données
résultat = static_cast ( p ) ;
cout << ' Après avoir utilisé le casting statique : ' << fin ;
cout << ' La valeur du résultat = ' << résultat << fin ;
retour 0 ;
}
Initialement, une variable double p est chargée de valeurs qui sont multipliées les unes par les autres et stockées dans le résultat. Le résultat contient le résultat avant et après l'opérateur static_cast :
Avant d'utiliser l'opérateur static_cast, le résultat est affiché en points décimaux, tandis qu'après avoir utilisé cet opérateur, il est affiché en type de données entier.
2 : const_cast
L'opérateur const_cast est utilisé pour convertir une valeur constante d'un objet en type non constant. Il est utilisé lorsqu'un objet constant est déclaré et nous devons occasionnellement modifier sa valeur.
Syntaxe
const_cast ( expression ) Exemple
Dans cet exemple, l'opérateur const_cast est utilisé pour supprimer temporairement le qualificatif de constante et permet d'apporter des modifications à la variable en fonction des besoins :
en utilisant espace de noms norme ;
int principal ( ) {
const int X = 70 ;
const int * et = & X ;
cout << 'L'ancienne valeur est' << * et << ' \n ' ;
int * Avec = const_cast ( et ) ;
* Avec = 90 ;
cout << 'La nouvelle valeur est' << * et ;
retour 0 ;
}
Le qualificatif de constante est affecté à une variable int x ce qui signifie que cette variable ne peut pas être modifiée directement. Après cela, int *y qui est un pointeur est utilisé pour accéder au x, mais il ne peut toujours pas être modifié et sa valeur d'origine est affichée à l'aide de cout. À l'aide de l'opérateur const_cast, un pointeur z est créé qui n'est pas constant, il est utilisé pour accéder à la valeur de x le rendant modifiable. Il modifie la valeur attribuée à z avec 90, ce qui modifie indirectement la valeur de x.
Initialement, la valeur de la variable constante x est 70, qui est modifiée en utilisant l'opérateur const_cast, ce qui en fait 90.
3 : diffusion_dynamique
avec la hiérarchie de l'héritage, également appelée downcast de type sécurisé. Le downcasting est le processus de conversion d’une référence ou d’un pointeur en une classe dérivée à partir d’une référence ou d’un pointeur de classe de base.
Syntaxe
dynamique_cast ( expression ) Exemple
Dans cet exemple, l'opérateur Dynamic_cast est utilisé pour vérifier le type de classe polymorphe et permet d'accéder aux membres de la classe de base et dérivés.
#inclure
en utilisant espace de noms norme ;
classe TBase
{
publique :
flotter base_g = 9.81 ;
virtuel vide factice ( )
{
} ;
} ;
classe TDérivé : publique TBase
{
publique :
int local_g = 9.78 ;
} ;
int principal ( )
{
TBase * base = nouveau TDérivé ;
TDérivé * dérivé ;
dérivé = dynamique_cast ( base ) ;
cout < base_g << fin ;
cout < local_g << fin ;
obtenirchar ( ) ;
retour 0 ;
}
Deux classes sont définies comme classes de base et classes dérivées. Une base de pointeur de type TBase* est créée et affectée à un objet alloué dynamiquement de type TDerived. Un objet de classe dérivée peut être affecté à un pointeur de classe de base dans cette instance de polymorphisme. Le Dynamic_cast vérifie si le pointeur accède à l'objet valide de TDerived, si le cast obtient un résultat réussi, la classe dérivée obtiendra un résultat valide sinon elle renverra une valeur nulle.
4 : réinterpréter_cast
Le reinterpret_cast transforme un pointeur d'un type de données en un pointeur d'un type de données différent. Il ne vérifie pas si les types de données des pointeurs sont identiques ou non. Cet opérateur de casting doit être utilisé et manipulé avec précaution.
Exemple
Dans cette illustration, le pointeur d'un type de données est réinterprété en pointeur d'un autre type de données à l'aide de reinterpret_cast :
en utilisant espace de noms norme ;
int principal ( )
{
int * q = nouveau int ( 70 ) ;
carboniser * ch = réinterpréter_cast ( q ) ;
cout << * q << fin ;
cout << * ch << fin ;
cout << q << fin ;
cout << ch << fin ;
retour 0 ;
}
Initialement, un entier est affecté à la valeur 70. Le pointeur q pointe vers cet entier alloué dynamiquement. Le reinterpret_cast est utilisé pour réinterpréter le pointeur q en tant que pointeur de caractère ch, ce qui signifie que la mémoire initialement attribuée à q est désormais traitée comme s'il s'agissait d'un caractère. À l’aide de la commande cout, il imprime la valeur attribuée à q et ch. Puisque ch est traité comme un pointeur de caractère, il renverra une valeur de caractère.
Il imprime la valeur pointée vers ch en utilisant *ch. Cependant, puisque ch est traité comme un pointeur de caractère, cette ligne interprétera la mémoire comme un caractère. Il imprime l'adresse mémoire stockée dans le pointeur ch en utilisant ch. C'est la même adresse mémoire que q car il s'agit simplement d'une réinterprétation de la même mémoire.
Initialement, l'entier stocke 70. Plus tard, celui-ci est manipulé entre le pointeur q et le pointeur ch. Les sorties 2 et 4 sont les mêmes car la deuxième valeur est réinterprétée à l'aide de reinterpret_cast.
Note : Il est suggéré de ne pas utiliser cet opérateur de conversion tant que cela n'est pas nécessaire, car il fait de l'objet un produit non portable.
Conclusion
Le processus de modification du type de données d’une variable en une autre est connu sous le nom de conversion de type ou conversion de type en C++. Ceci est fait pour effectuer des opérations mathématiques sur les variables de différents types de données, en rendant leurs types de données compatibles les uns avec les autres. La conversion de type optimise le code. Il existe des conversions de types implicites et explicites en C++. La conversion de type implicite est effectuée par le compilateur lui-même à l'aide d'un ensemble de règles prédéfinies, tandis que la conversion de type explicite est effectuée par le programmeur à l'aide d'opérateurs d'affectation et d'opérateurs de conversion.