Maison > développement back-end > C++ > Pourquoi `a = b` fonctionne-t-il alors que `a = a b` échoue lorsque `a` et `b` sont `short` en C# ?

Pourquoi `a = b` fonctionne-t-il alors que `a = a b` échoue lorsque `a` et `b` sont `short` en C# ?

DDD
Libérer: 2025-01-23 08:57:09
original
738 Les gens l'ont consulté

Why Does `a  = b` Work While `a = a   b` Fails When `a` and `b` are `short` in C#?

C# short Arithmétique : une subtilité

Ajout de deux short variables directement en C#, comme ceci :

<code class="language-csharp">short a, b;
a = 10;
b = 10;
a = a + b; // Error: Cannot implicitly convert type 'int' to 'short'</code>
Copier après la connexion

produit une erreur du compilateur. La raison ? La somme de deux valeurs short est implicitement promue en int. L'attribution d'un int à une variable short nécessite une conversion explicite, qui manque dans ce code.

Étonnamment, l'opérateur d'affectation composé = fonctionne sans erreur :

<code class="language-csharp">a += b; // Works correctly</code>
Copier après la connexion

Pourquoi la différence ?

Le = Secret de l'opérateur

L'opérateur = n'est pas simplement du sucre syntaxique ; c'est une fonctionnalité linguistique soigneusement conçue. Bien que fonctionnellement équivalent à a = a b, le compilateur le traite différemment. La spécification C# stipule que les opérateurs d'affectation composée effectuent une conversion implicite du résultat de l'opération vers le type de l'opérande de gauche.

Essentiellement, a = b est implicitement traité comme a = (short)(a b). Le compilateur insère automatiquement le cast nécessaire dans short, évitant ainsi l'erreur d'incompatibilité de type.

Ce casting implicite est un aspect crucial de la conception de C#. Sans cela, de nombreuses opérations arithmétiques courantes impliquant des types entiers plus petits nécessiteraient une conversion explicite, ajoutant une complexité significative au code.

En bref (jeu de mots intentionnel)

Le problème principal est la promotion de type implicite de short short à int. L'opérateur = contourne intelligemment ce problème en incorporant une conversion implicite, ce qui en fait un moyen pratique et efficace d'effectuer des opérations arithmétiques sur des types entiers plus petits sans conversions de type explicites.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

source:php.cn
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal