Casting de type en C : conversion de type, implicite, explicite avec exemple

Qu’est-ce que le transtypage en C ?

Le transtypage consiste à convertir un type de données en un autre. On l'appelle également conversion de données ou conversion de type en langage C. C'est l'un des concepts importants introduits dans la programmation « C ».

La programmation « C » fournit deux types d'opérations de conversion de type :

1. Casting de type implicite
2. Conversion de type explicite

Casting de type implicite

La conversion de type implicite signifie la conversion des types de données sans perdre leur signification originale. Ce type de transtypage est essentiel lorsque vous souhaitez modifier les types de données sans changer la signification des valeurs stockées à l'intérieur du variable.

La conversion de type implicite en C se produit automatiquement lorsqu'une valeur est copiée dans son type de données compatible. Lors de la conversion, des règles strictes de conversion de type sont appliquées. Si les opérandes sont de deux types de données différents, alors un opérande ayant un type de données inférieur est automatiquement converti en un type de données supérieur. Ce type de conversion de type peut être vu dans l'exemple suivant.

#include<stdio.h>
int main(){
	short a=10; //initializing variable of short data type
	int b; //declaring int variable
	b=a; //implicit type casting
	printf("%d\n",a);
	printf("%d\n",b);
}

Sortie :

10
10

1. Dans l'exemple donné, nous avons déclaré une variable de type de données court avec une valeur initialisée à 10.
2. Sur la deuxième ligne, nous avons déclaré une variable de type de données int.
3. Sur la troisième ligne, nous avons attribué la valeur de la variable s à la variable a. Sur la troisième ligne, la conversion de type implicite est effectuée lorsque la valeur de la variable s qui est de type de données court est copiée dans la variable a qui est de type de données int.

Conversion de caractère en Int

Prenons l'exemple de l'ajout d'un caractère décodé en ASCII avec un entier :

#include <stdio.h>
main() {
   int  number = 1;
   char character = 'k'; /*ASCII value is 107 */
   int sum;
   sum = number + character;
   printf("Value of sum : %d\n", sum );
}

Sortie :

 Value of sum : 108

Ici, le compilateur a effectué une promotion entière en convertissant la valeur de « k » en ASCII avant d'effectuer l'opération d'addition proprement dite.

Hiérarchie de conversion arithmétique

Le compilateur procède d’abord à la promotion d’un caractère en entier. Si les opérandes ont encore des types de données différents, ils sont alors convertis vers le type de données le plus élevé qui apparaît dans le diagramme hiérarchique suivant :

Considérez l'exemple suivant pour comprendre le concept :

#include <stdio.h>
main() {
   int  num = 13;
   char c = 'k'; /* ASCII value is 107 */
   float sum;
   sum = num + c;
   printf("sum = %f\n", sum );}

Sortie :

 sum = 120.000000

Tout d'abord, la variable c est convertie en entier, mais le compilateur convertit num et c dans « float » et les ajoute pour produire un résultat « float ».

Points importants sur les conversions implicites

• Le type implicite de conversion de type est également appelé conversion de type standard. Nous n'avons besoin d'aucun mot-clé ou d'instructions spéciales dans la conversion de type implicite.
• La conversion d'un type de données plus petit en un type de données plus grand est également appelée promotion de type. Dans l'exemple ci-dessus, nous pouvons également dire que la valeur de s est promue au type entier.
• La conversion de type implicite se produit toujours avec les types de données compatibles.

Nous ne pouvons pas effectuer de transtypage implicite sur les types de données qui ne sont pas compatibles les uns avec les autres, tels que :

1. La conversion de float en int tronquera la partie fraction, perdant ainsi la signification de la valeur.
2. La conversion de double en float arrondira les chiffres.
3. La conversion de long int en int entraînera la suppression des bits de poids fort en excès.

Dans tous les cas ci-dessus, lorsque nous convertissons les types de données, la valeur perdra sa signification. Généralement, la perte de sens de la valeur est avertie par le compilateur.

Programmation en « C » fournit une autre façon de transtypage qui est le transtypage de type explicite.

Conversion de type explicite

Dans la conversion de type implicite, le type de données est converti automatiquement. Il existe certains scénarios dans lesquels nous devrons peut-être forcer la conversion de type. Supposons que nous ayons une variable div qui stocke la division de deux opérandes déclarés comme type de données int.

 int result, var1=10, var2=3;
result=var1/var2;

Dans ce cas, après la division effectuée sur les variables var1 et var2 le résultat stocké dans la variable « résultat » sera sous un format entier. Chaque fois que cela se produit, la valeur stockée dans la variable « résultat » perd son sens car elle ne prend pas en compte la partie fractionnaire qui est normalement obtenue dans la division de deux nombres.

Pour forcer la conversion de type dans de telles situations, nous utilisons un cast de type explicite.

Cela nécessite un opérateur de casting de type. La syntaxe générale des opérations de conversion de type est la suivante :

(type-name) expression

Ici,

• Le nom du type est le type de données standard du langage « C ».
• Une expression peut être une constante, une variable ou une expression réelle.

Écrivons un programme pour démontrer comment transtyper en C avec un transtypage explicite.

#include<stdio.h>
int main()
{
	float a = 1.2;
	//int b  = a; //Compiler will throw an error for this
	int b = (int)a + 1;
	printf("Value of a is %f\n", a);
	printf("Value of b is %d\n",b);
	return 0;
}

Sortie :

Value of a is 1.200000
Value of b is 2

1. Nous avons initialisé une variable 'a' de type float.
2. Ensuite, nous avons une autre variable « b » de type de données entier. Étant donné que les variables « a » et « b » sont de types de données différents, « C » ne permettra pas l'utilisation d'une telle expression et générera une erreur. Dans certaines versions de « C », l'expression sera évaluée mais le résultat ne sera pas souhaité.
3. Pour éviter de telles situations, nous avons transtypé la variable 'a' de type float. En utilisant des méthodes de conversion de type explicites, nous avons réussi à convertir float en type de données entier.
4. Nous avons imprimé la valeur « a » qui est toujours un flottant
5. Après le transtypage, le résultat sera toujours un entier « b ».

De cette façon, nous pouvons implémenter un casting de type explicite dans la programmation C.

Résumé

• Le transtypage est également appelé conversion de type
• Cela signifie convertir un type de données en un autre.
• La conversion d'un type de données plus petit en un type plus grand est également appelée promotion de type.
• Il existe deux types de conversion de type : la conversion de type implicite et explicite en C.
• La conversion de type implicite fonctionne automatiquement lorsque le type de données compatible est trouvé.
• La conversion de type explicite nécessite un opérateur de conversion de type.

Gardez à l'esprit les règles suivantes pour la pratique de la programmation lorsque vous traitez différents types de données afin d'éviter toute perte de données :

• Les types entiers doivent être convertis en float.
• Les types float doivent être convertis en double.
• Les types de caractères doivent être convertis en entiers.