Conversion de type en C : implicite et explicite

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 :

• Casting de type implicite
• Conversion de type explicite

Casting de type implicite

La conversion implicite de types signifie la conversion de types de données sans en altérer le sens d'origine. Ce type de conversion est essentiel lorsque vous souhaitez modifier les types de données sans changer la signification des valeurs stockées. 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 en « float » et les additionne 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 vers un type de données plus grand est également appelée promotion de type. Dans l'exemple ci-dessus, on peut aussi dire que la valeur de s est convertie en 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 d'un entier long en entier entraînera une perte de données.ping de 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 entier. Comme les variables « a » et « b » sont de types différents, le langage C n'autorise pas l'utilisation de cette expression et génère une erreur. Dans certaines versions de C, l'expression sera évaluée, mais le résultat ne sera pas celui attendu.
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.

FAQ