C # Coulage de type

C # est un langage sensible. En C #, lorsque nous devons stocker les données d'un type dans un autre type de variable, cela nous donne une erreur en disant que nous devons faire comprendre cette variable. Le type de la variable est modifié par la coulée de type. Lorsque nous déclarons une variable, nous lui attribuons un type que nous passons plus tard au type dont nous avons besoin. Le moulage de type est très utile lorsque nous devons stocker le résultat dans un type de variable différent. Le casting de type a deux approches - l'une est que le compilateur le fait automatiquement et l'autre est ce que le programmeur doit faire.

Méthodes de coulée de type

Le casting de type a deux méthodologies que nous couvrirons en détail avec des exemples:

Casting de type implicite

Dans la dactylographie implicite, nous convertissons les plus petits en plus grands types. Comme dans le type de données «double», nous attribuons une valeur entière. La coulée de type implicite est effectuée par le compilateur et c'est une méthode automatique que la machine fait. Les types plus petits et plus grands sont classés en fonction du nombre d'octets qu'ils réservent dans l'allocation de mémoire.

char, int, long, flotteur, double

Le compilateur peut taper le «char» à «int» et ainsi de suite. Le plus grand type de données peut stocker les plus petits.

Casting de type explicite

Dans la dactylographie explicite, nous attribuons le type plus grand au type plus petit. Nous devons faire manuellement cette dactylographie. Dans ce type de coulée, le plus petit type stocke le résultat des plus grands types. La séquence de l'ordre est la suivante:

Double, flottant, long, int, char

Le type de données «double» est le plus grand. Pour stocker «Double» dans «int», nous ferons un casting de type explicite.

Syntaxe:

(to_type) var_0;

L'attribut «à_type» est le type auquel nous voulons changer la variable et autour de cela avec des parenthèses. Le «var_0» est le nom de la variable dont nous voulons changer le type. En utilisant la syntaxe, changeons le type d'une variable comme (float) var_0. Disons que «var_0» est une variable «entière» et nous le changeons en «flottant» en faisant son type coulant avec (float).

Méthodes intégrées

La coulée de type peut être accomplie en utilisant les techniques intégrées de C #. La méthode intégrée qui est convertie.Totype_name () est utilisé. Ici, le «type_name» est le nom du type de données que nous voulons pour une variable. Écrivez le nom de cette variable à l'intérieur de la parenthèse comme converti.Tostring (var_2). Il convertit le «var_2» en un type «String».

Exemple 1:

Dans cet exemple de code, nous découvrirons la dactylographie implicite que le complice lui-même fait. Nous allons faire comprendre les plus petits types en plus grands types.

Utilisation du système;
Programme de classe_1

statique void main ()
int Value_0 = 76;
Float Value_1 = 78.9f;
double valeur_2 = valeur_1;
Long Value_3 = Value_0;
Console.WriteLine ("Casting de type implicite de Float à Double" + Value_2);
Console.WriteLine ("Casting de type implicite de int à long" + valeur_3);

La déclaration d'une variable de type entier et d'une variable de point flottante se fait dans la première instruction du code. Ensuite, initialisez deux autres variables - l'une a un type «double» et l'autre a un type «long». Ici, nous voulons changer le type de «flotteur» en «double». C'est fait par le compilateur. Nous stockons simplement le nom de la variable qui a un type «flottant» dans la variable «double» comme «double valeur_2 = valeur_1». La variable «Value_1» a un type «flottant» et est un type plus petit. Le «Value_2» a un type «double» et c'est le type plus grand. Nous stockons simplement la valeur flottante dans la variable «double». Le compilateur le convertit en double. Dans l'instruction suivante, nous attribuons le nom de variable ayant un type de données «entier» à la variable de type «long». Par conséquent, le compilateur fait une coulée de type implicite en entier à long. Ensuite, affichez à la fois les variables, le type «double» et le type «long» avec un message en utilisant la console.Méthode écrite de ligne. Ici, nous concatenons le message et la variable pour représenter le résultat sur la console.

Exemple 2:

Ici, nous modifions le type de variable par dactylographie explicite.

Utilisation du système;
Classe Program_2

statique void main ()
float var_1 = 45.333f;
int var_2 = (int) var_1;
double var_3 = 77777.654336;
float var_4 = (float) var_3;
Console.WriteLine ("Coulage de type explicite de float à int" + var_2);
Console.WriteLine ("Casting de type explicite de Double à Float" + Var_4);

Initialisons quatre variables différentes. La première variable «var_1» a un type de données flottantes. Le second appartient à un type entier. Ici, nous attribuons la variable de type flotteur «var_1» à la variable de type entier «var_2» et cela se fait par casting de type explicite. Écrivez le type que nous voulons utiliser la parenthèse, (int) var_1. Cela montre que nous voulons modifier le type de «var_1» comme un entier. La troisième variable du type de données «double» est déclarée et une valeur à virgule flottante lui est attribuée. De plus, la coulée de type explicite est appliquée sur «var_4». La quatrième variable montre le message et les valeurs de la console avec l'utilisation de la console.WriteLine (). La valeur «flottante» est modifiée en «entier» en obtenant la valeur avant la partie décimale. Et la valeur de «double» est mise à jour en valeur «flottante» après le coulage de type. Il représente la première partie avant le point décimal et seulement deux valeurs de point décimal après l'arrondissement.

Exemple 3:

Ce code explique la dactylographie de la variable en utilisant les méthodes intégrées en C #.

Utilisation du système;
programme de classe_3

statique void main ()
Float Value_0 = 25.764f;
Console.WriteLine ("du flotteur à l'octet" + converti.Tobyte (valeur_0));
Console.WriteLine ("From Float to String" + Converti.ToString (value_0));
Console.WriteLine ("From Float to Double" + Converti.Todouble (valeur_0));
Console.WriteLine ("From Float to Boolean" + converti.Toboolean (valeur_0));
Console.Writeline ("de float à décimal" + converti.Todecimal (valeur_0));
Console.WriteLine ("de float à int" + converti.ToInt32 (valeur_0));

Tout d'abord, déclarez une variable flottante et initialisez-la avec une valeur de point flottante. Ensuite, utilisez la console.Fonction WriteLine () pour afficher le texte et les valeurs converties. Dans cette fonction, en appelant le converti.Tobyte (valeur_0), il convertit la valeur «flottante» en «octet» après l'arrondir. Le toString () convertit le type de données requis en «chaîne» sans rien changer. Il stocke la valeur en tant que chaîne. La méthode todouble () chanegs le type «float» au type «double». Ensuite, convertissez le «flotteur» en «booléen», «décimal» et «entier». Nous utilisons les méthodes toboolean (), todécimal () et toinT32 (). Nous pouvons modifier le type de données de toute variable par l'utilisation de ces fonctions intégrées.

Conclusion

Nous avons discuté de la façon de faire la dactylographie en langue C #. La modification du type d'une variable est connue sous le nom de casting de type. Il existe deux techniques de dactylographie - l'une est un casting de type implicite où le compilateur modifie automatiquement le type de données, et l'autre est un coulage de type explicite que nous faisons manuellement. Le casting de type explicite a deux méthodologies: l'une consiste en mentionnant le type de données entre parenthèses et en la plaçant devant la variable dont nous voulons changer le type. L'autre consiste à utiliser les fonctions intégrées qui sont appliquées pour modifier le type de variables. L'article explique tout sur la dactylographie avec des exemples pratiques.