Cette section discutera de la conversion de type des variables dans le langage de programmation C++. Le transtypage fait référence à la conversion d’un type de données en un autre dans un programme. Le transtypage peut être effectué de deux manières : automatiquement par le compilateur et manuellement par le programmeur ou l'utilisateur. La conversion de type est également connue sous le nom de conversion de type.
Par exemple, supposons que les données données soient de type entier et que nous souhaitions les convertir en type float. Nous devons donc convertir manuellement les données int en type float, et ce type de conversion est appelé Type Casting en C++.
int num = 5; float x; x = float(num); x = 5.0
2sdexemple:
float num = 5.25; int x; x = int(num); Output: 5
Le transtypage de type est divisé en deux types : la conversion implicite ou le transtypage de type implicite et la conversion de type explicite ou le transtypage de type explicite.
Conversion de type implicite ou conversion de type implicite
- C’est ce qu’on appelle la coulée de type automatique.
- Il convertit automatiquement d'un type de données à un autre sans aucune intervention externe telle qu'un programmeur ou un utilisateur. Cela signifie que le compilateur convertit automatiquement un type de données en un autre.
- Tous les types de données sont automatiquement mis à niveau vers le type le plus grand sans perdre aucune information.
- Cela ne peut s'appliquer dans un programme que si les deux variables sont compatibles entre elles.
char - sort int -> int -> unsigned int -> long int -> float -> double -> long double, etc.
Remarque : La conversion de type implicite doit être effectuée à partir de types de données faibles vers des types de données supérieurs. Sinon, cela affecte le type de données fondamental, qui peut perdre de la précision ou des données, et le compilateur peut afficher un avertissement à cet effet.
Programme pour utiliser le casting de type implicite en C++
Créons un exemple pour démontrer le transtypage d'une variable en une autre à l'aide du transtypage de type implicite en C++.
#include using namespace std; int main () { short x = 200; int y; y = x; cout << ' Implicit Type Casting ' << endl; cout << ' The value of x: ' << x << endl; cout << ' The value of y: ' << y << endl; int num = 20; char ch = 'a'; int res = 20 + 'a'; cout << ' Type casting char to int data type ('a' to 20): ' << res << endl; float val = num + 'A'; cout << ' Type casting from int data to float type: ' << val << endl; return 0; } Sortir:
Implicit Type Casting The value of x: 200 The value of y: 200 Type casting char to int data type ('a' to 20): 117 Type casting from int data to float type: 85
Dans le programme ci-dessus, nous avons déclaré une variable de type de données courte x égale 200 et une variable entière y. Après cela, nous attribuons la valeur x au y, puis le compilateur convertit automatiquement la valeur de données courte x en y, ce qui renvoie y est 200.
Dans les expressions suivantes, nous avons déclaré une variable de type int num vaut 20 et la variable de type caractère ch est 'a', ce qui équivaut à une valeur entière de 97. Et puis, nous ajoutons ces deux variables pour effectuer la conversion implicite, qui renvoie le résultat de l'expression est 117.
De même, dans la troisième expression, nous ajoutons la variable entière num est 20 et la variable caractère ch est 65, puis affectons le résultat à la variable float val. Ainsi, le résultat de l’expression est automatiquement converti en type float par le compilateur.
Conversion de type explicite ou conversion de type explicite
- Il est également connu sous le nom de conversion de type manuelle dans un programme.
- Il est généré manuellement par le programmeur ou l'utilisateur pour passer d'un type de données à un autre type dans un programme. Cela signifie qu'un utilisateur peut facilement convertir une donnée en une autre en fonction des exigences d'un programme.
- Il ne nécessite pas de vérifier la compatibilité des variables.
- Dans ce casting, nous pouvons mettre à niveau ou rétrograder le type de données d’une variable à une autre dans un programme.
- Il utilise l'opérateur cast() pour changer le type d'une variable.
Syntaxe du transtypage de type explicite
(type) expression;
taper: Il représente les données définies par l'utilisateur qui convertissent l'expression donnée.
expression: Il représente la valeur constante, la variable ou une expression dont le type de données est converti.
Par exemple, nous avons un nombre à virgule flottante 4,534, et pour convertir une valeur entière, l'instruction est la suivante :
int num; num = (int) 4.534; // cast into int data type cout << num;
Lorsque les instructions ci-dessus sont exécutées, la valeur à virgule flottante sera convertie en un type de données entier à l'aide de l'opérateur cast (). Et la valeur flottante est affectée à un nombre entier qui tronque la partie décimale et affiche seulement 4 comme valeur entière.
java convertir un entier en chaîne
Programme pour démontrer l'utilisation du transtypage de type explicite en C++
Créons un programme simple pour convertir une variable de type en un autre type en utilisant le transtypage explicite dans le langage de programmation C++.
#include using namespace std; int main () { // declaration of the variables int a, b; float res; a = 21; b = 5; cout << ' Implicit Type Casting: ' << endl; cout << ' Result: ' << a / b << endl; // it loses some information cout << '
Explicit Type Casting: ' << endl; // use cast () operator to convert int data to float res = (float) 21 / 5; cout << ' The value of float variable (res): ' << res << endl; return 0; } Sortir:
Implicit Type Casting: Result: 4 Explicit Type Casting: The value of float variable (res): 4.2
Dans le programme ci-dessus, nous prenons deux variables entières, a et b, dont les valeurs sont 21 et 2. Et puis, divisons a par b (21/2) qui renvoie une valeur de type 4 int.
Dans la deuxième expression, nous déclarons une variable de type float res qui stocke les résultats de a et b sans perdre aucune donnée à l'aide de l'opérateur de conversion dans la méthode de conversion de type explicite.
Programme pour convertir des données doubles en type int et float à l'aide de l'opérateur de conversion
Prenons un exemple pour obtenir l'aire du rectangle en convertissant des données doubles en type float et int dans la programmation C++.
#include using namespace std; int main () { // declaration of the variables double l, b; int area; // convert double data type to int type cout << ' The length of the rectangle is: ' <> l; cout << ' The breadth of the rectangle is: ' <> b; area = (int) l * b; // cast into int type cout << ' The area of the rectangle is: ' << area << endl; float res; // convert double data type to float type cout << '
The length of the rectangle is: ' << l << endl; cout << ' The breadth of the rectangle is: ' << b << endl; res = (float) l * b; // cast into float type cout << ' The area of the rectangle is: ' << res; return 0; } Sortir:
The length of the rectangle is: 57.3456 The breadth of the rectangle is: 12.9874 The area of the rectangle is: 740 The length of the rectangle is: 57.3456 The breadth of the rectangle is: 12.9874 The area of the rectangle is: 744.77
Quelques différents types de type casting
Dans la conversion de type, il existe un opérateur de conversion qui force la conversion d'un type de données en un autre type de données en fonction des besoins du programme. C++ propose quatre types différents d'opérateur de conversion :
- Statique_cast
- dynamique_cast
- const_cast
- réinterpréter_cast
Casting statique :
Le static_cast est un simple cast au moment de la compilation qui convertit ou convertit un type de données en un autre. Cela signifie qu'il ne vérifie pas le type de données au moment de l'exécution si la conversion effectuée est valide ou non. Ainsi, le programmeur ou l'utilisateur a la responsabilité de s'assurer que la conversion était sûre et valide.
Le static_cast est suffisamment performant pour pouvoir effectuer toutes les conversions effectuées par le cast implicite. Et il effectue également les conversions entre les pointeurs de classes liées les unes aux autres (upcast -> de dérivé vers la classe de base ou downcast -> de base vers la classe dérivée).
Syntaxe de la distribution statique
static_cast (expression);
Programme pour démontrer l'utilisation du Static Cast
Créons un exemple simple pour utiliser la conversion statique du transtypage de type dans la programmation C++.
#include using namespace std; int main () { // declare a variable double l; l = 2.5 * 3.5 * 4.5; int tot; cout << ' Before using the static cast:' << endl; cout << ' The value of l = ' << l << endl; // use the static_cast to convert the data type tot = static_cast (l); cout << ' After using the static cast: ' << endl; cout << ' The value of tot = ' << tot << endl; return 0; } Sortir:
Before using the static cast: The value of l = 39.375 After using the static cast: The value of tot = 39
Diffusion dynamique
Dynamic_cast est un opérateur de conversion d'exécution utilisé pour effectuer la conversion d'une variable de type en une autre uniquement sur les pointeurs de classe et les références. Cela signifie qu'il vérifie la conversion valide des variables au moment de l'exécution et si la conversion échoue, il renvoie une valeur NULL. La diffusion dynamique est basée sur le mécanisme RTTI (Runtime Type Identification).
Programme pour démontrer l'utilisation du Dynamic Cast en C++
Créons un programme simple pour effectuer le Dynamic_cast dans le langage de programmation C++.
#include using namespace std; class parent { public: virtual void print() { } }; class derived: public parent { }; int main () { // create an object ptr parent *ptr = new derived; // use the dynamic cast to convert class data derived* d = dynamic_cast (ptr); // check whether the dynamic cast is performed or not if ( d != NULL) { cout << ' Dynamic casting is done successfully'; } else { cout << ' Dynamic casting is not done successfully'; } } Sortir:
Dynamic casting is done successfully.
Réinterpréter le type de distribution
Le transtypage de type reinterpret_cast est utilisé pour convertir un pointeur vers tout autre type de pointeur, que les pointeurs donnés appartiennent ou non les uns aux autres. Cela signifie qu'il ne vérifie pas si le pointeur ou les données pointées par le pointeur sont identiques ou non. Et il renvoie également un pointeur vers un type entier ou vice versa.
Syntaxe du type reinterpret_cast
reinterpret_cast expression;
Programme pour utiliser le Reinterpret Cast en C++
Écrivons un programme pour démontrer la conversion d'un pointeur à l'aide de la réinterprétation en langage C++.
#include using namespace std; int main () { // declaration of the pointer variables int *pt = new int (65); // use reinterpre_cast operator to type cast the pointer variables char *ch = reinterpret_cast (pt); cout << ' The value of pt: ' << pt << endl; cout << ' The value of ch: ' << ch << endl; // get value of the defined variable using pointer cout << ' The value of *ptr: ' << *pt << endl; cout << ' The value of *ch: ' << *ch << endl; return 0; } Sortir:
The value of pt: 0x5cfed0 The value of ch: A The value of *ptr: 65 The value of *ch: A
Stars du Cinéma
Le const_cast est utilisé pour modifier ou manipuler le comportement const du pointeur source. Cela signifie que nous pouvons effectuer la const de deux manières : définir un pointeur const sur un pointeur non const ou supprimer ou supprimer le const d'un pointeur const.
Syntaxe du type Const Cast
const_cast exp;
Programme pour utiliser le Const Cast en C++
rendre le script exécutable
Écrivons un programme pour convertir un pointeur source en un pointeur non cast en utilisant const_cast en C++.
#include using namespace std; // define a function int disp(int *pt) { return (*pt * 10); } int main () { // declare a const variable const int num = 50; const int *pt = # // get the address of num // use const_cast to chnage the constness of the source pointer int *ptr = const_cast (pt); cout << ' The value of ptr cast: ' << disp(ptr); return 0; } Sortir:
The value of ptr cast: 500