Littéraux C#

Les littéraux en C# sont la valeur fixe utilisée par une variable prédéfinie qui ne peut pas être modifiée lors de l'exécution du code. Il s'agit d'une forme pratique de valeurs constantes comme les autres variables, mais leurs valeurs ne peuvent pas être modifiées. La valeur utilisée par une variable peut être entière, décimale, flottante ou chaîne. Il existe différents types de littéraux en C# avec différentes formes. Il existe différents types de littéraux en C#.

1. Litéraux entiers
2. Chaînes littérales
3. Littéraux de caractères
4. Litéraux à virgule flottante
5. Litéraux booléens

Top 5 des types de littéraux en C#

Voici les différents types de littéraux en C#.

1. Littéraux entiers

Le littéral de type entier peut être octal, décimal ou hexadécimal. Le préfixe est utilisé pour spécifier s'il est décimal, octal ou hexadécimal. U et u sont également utilisés comme suffixe avec des littéraux de type entier pour les nombres non signés, et l et L sont utilisés pour les nombres longs. Chaque littéral est de type entier par défaut.

• Litéraux décimaux : 0 à 9 chiffres sont autorisés dans le type décimal des littéraux. Aucun préfixe n'est requis pour le type décimal des littéraux.

int x = 100 ;  // type décimal

• Litéraux octaux : 0 à 7 chiffres sont autorisés dans le type octal des littéraux. 0 est utilisé comme préfixe pour spécifier la forme des littéraux de type octal.

int x = 072 ;  //type octal

• Litéraux hexadécimaux : Dans le type de littéraux hexadécimaux, les chiffres de 0 à 9 et les caractères de A à f sont autorisés. Les deux types de caractères majuscules et minuscules sont autorisés dans ce cas. 0X ou 0x est utilisé comme préfixe pour spécifier la forme du type hexadécimal des littéraux.

int x = 0x123f;   //type hexadécimal

2. Littéraux de chaîne

Les littéraux de type chaîne sont placés entre (« »)/guillemets doubles et peuvent également être commencés par @" ». Les lignes longues peuvent être divisées en plusieurs lignes avec des chaînes littérales et séparées par des espaces.

string s= "Hi";   // string literals

3. Littéraux de caractères

Vous entourez les littéraux du type de caractère entre («)/guillemets simples. Il existe trois façons de spécifier des caractères littéraux.

• Citation simple : Les littéraux des caractères peuvent être spécifiés sous forme de caractère unique à l'aide d'un guillemet simple.
• Représentation Unicode : Les caractères littéraux peuvent être spécifiés à l'aide de la représentation Unicode 'uxxxx', où xxxx sont les nombres hexadécimaux.
• Séquence d'échappement : Nous connaissons certains caractères d'échappement sous le nom de caractères littéraux.

char c = '\n';

Voici quelques littéraux de séquence d'échappement expliqués avec leur signification.

Escape Sequence	Meaning
\	Character
’	Character
’’	Character
?	Character
a	Alert
b	Backspace
n	Newline
f	Form feed
v	Vertical tab
xhh	Hexadecimal number

Séquence d'échappement

Signification

\

Caractère

’

Caractère

’’

Caractère

?

Caractère

a

Alerte

b

Retour arrière

n

Nouvelle ligne

f

Saut de page

v

Onglet vertical

xhh

Nombre hexadécimal

4. Floating Point Literals

In the floating type of literal, there is an integer part, a fractional part, a decimal part, and an exponent part. The floating type literal is of double type. You can use F or f as a suffix to specify the value because you cannot assign it directly to the float variable.

5. Boolean Literals

In the Boolean type of literals, true and false will be the only two values.

Examples of C# Literals

Below are the examples that show how we can implement all the above literals in C#

Example #1 – Integer Literal

Code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Literals
{
class Program
{
static void Main(string[] args)
{
int x = 212;   // decimal literal
int y = 0145;  // octal literal
int z = 0x4b;  // hexadecimal literal
Console.WriteLine(x);
Console.WriteLine(y);
Console.WriteLine(z);
Console.ReadLine();
}
}
}

Output:

Explanation: In the above example, there are various forms of integer-type literals. You use no prefix for the decimal form, use 0 to specify the octal form, and use 0x to specify the hexadecimal number. Using prefixes, we can define the form of integer type literal. In this code, first, there is a literal of decimal type with no prefix, a second type is an octal form with 0 as a prefix, and last, we have a hexadecimal type with 0x as a prefix.

Example #2 – Floating Point Literal

Code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Literals
{
class Program
{
static void Main(string[] args)
{
double x = 187.231;
double y = 0141.361;
double z = 374159E-4F;
Console.WriteLine(x);
Console.WriteLine(y);
Console.WriteLine(z);
Console.ReadLine();
}
}
}

Output:

Explanation: The above example implements floating-point literals. It can be a decimal number, fractional, or any exponent. So we can represent it either in decimal or in exponential form. The floating type literal is of double type. You can use F or f as a suffix to specify the value because you cannot assign it directly to the float variable.

Example #3 – Character Literals

Code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Literals
{
class Program
{
static void Main(string[] args)
{
char c = 'b';
char ch = '\u0071';
Console.WriteLine(c);
Console.WriteLine(ch);
Console.WriteLine("\nHello World\t!");
Console.ReadLine();
}
}
}

Output:

Explanation: The above example implements character-type literals. The above code shows all three forms of character type. We can specify the character using a single quote, Unicode representation, and escape sequence. We have multiple types of escape characters with their meanings. In this code, the first single quote character is specified where the second one has Unicode representation, and then, at last, we have escape form type of character literals.

Example #4 – String Literal

Code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Literals
{
class Program
{
static void Main(string[] args)
{
String s1 = "This is C# programming";
String s2 = @"This is C# programming";
Console.WriteLine(s1);
Console.WriteLine(s2);
Console.ReadLine();
}
}
}

Output:

Explanation: The above example implements string literals. There are two ways to specify string literals, as shown in the code. To implement the string, use double quotes first, then follow with the @ symbol.

Example #5 – Boolean Type Literal

Code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Literals
{
class Program
{
static void Main(string[] args)
{
bool x = true;
bool y = false;
Console.WriteLine(x);
Console.WriteLine(y);
Console.ReadLine();
}
}
}

Output:

Explanation: In the example provided, the implementation of Boolean type literals, which consist of two true or false values, can be seen.

Conclusion

So literals are the fixed values. In C#, there are different types of literals with specific form types. It can be of integer, Boolean, string, or a character literal.

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!