# C# | Literals

• Difficulty Level : Medium
• Last Updated : 05 Nov, 2020

The fixed values are called as Literal. Literal is a value that is used by the variables. Values can be either an integer, float or string, etc.

```// Here 100 is a constant/literal.
int x = 100;

```

Literals can be of the following types:

• Integer Literals
• Floating-point Literals
• Character Literals
• String Literals
• Null Literals
• Boolean Literals

Integer Literals: A literal of integer type is know as the integer literal. It can be octal, decimal, binary, or hexadecimal constant. No prefix is required for the decimal numbers. A suffix can also be used with the integer literals like U or u are used for unsigned numbers while l or L are used for long numbers. By default, every literal is of int type. For Integral data types (byte, short, int, long), we can specify literals in the ways:

• Decimal literals (Base 10): In this form, the allowed digits are 0-9.
```int x = 101;

```
• Octal literals (Base 8): In this form, the allowed digits are 0-7.
```// The octal number should be prefix with 0.
int x = 0146;

```
• Hexa-decimal literals (Base 16): In this form, the allowed digits are 0-9 and characters are a-f. We can use both uppercase and lowercase characters. As we know that c# is a case-sensitive programming language but here c# is not case-sensitive.
```// The hexa-decimal number should be prefix
// with 0X or 0x.
int x = 0X123Face;

```
• Binary literals (Base 2): In this form, the allowed digits are only 1’s and 0’s.
```// The binary number should be prefix with 0b.
int x = 0b101

```

Examples:

```07778    // invalid: 8 is not an octal digit
045uu    // invalid: suffix (u) is repeated
0b105    // invalid: 5 is not a binary digit
0b101    // valid binary literal
456      // valid decimal literal
02453    // valid octal literal
12356    // valid int literal
304U     // valid unsigned int literal
3078L    // valid long literal
965UL    // valid unsigned long literal

```

Program:

## C#

 `// C# program to illustrate the use of Integer Literals` `using` `System;`   `class` `Geeks{`   `    ``// Main method` `    ``public` `static` `void` `Main(String[] args)` `    ``{ ` `      `  `        ``// decimal-form literal` `        ``int` `a = 101;`   `        ``// octal-form literal` `        ``int` `b = 0145;`   `        ``// Hexa-decimal form literal` `        ``int` `c = 0xFace;` `      `  `        ``// binary-form literal` `        ``int` `x = 0b101;` `        `  `        ``Console.WriteLine(a);` `        ``Console.WriteLine(b);` `        ``Console.WriteLine(c);` `        ``Console.WriteLine(x);` `    ``}` `}`

```101
145
64206
5

```

Floating-point Literals: The literal which has an integer part, a decimal point, a fractional part, and an exponent part is known as the floating-point literal. These can be represented either in decimal form or exponential form.

Examples:

```Double d = 3.14145       // Valid
Double d = 312569E-5      // Valid
Double d = 125E             // invalid: Incomplete exponent
Double d = 784f            // valid
Double d = .e45           // invalid: missing integer or fraction

```

Program:

## C#

 `// C# program to illustrate the use of` `// floating-point literals` `using` `System;`   `class` `Geeks {`   `    ``// Main Method` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``// decimal-form literal` `        ``double` `a = 101.230;`   `        ``// It also acts as decimal literal` `        ``double` `b = 0123.222;`   `        ``Console.WriteLine(a);` `        ``Console.WriteLine(b);` `    ``}` `}`

Output:

```101.23
123.222

```

Note: By default, every floating-point literal is of double type and hence we can’t assign directly to float variable. But we can specify floating-point literal as float type by suffixed with f or F. We can specify explicitly floating-point literal as the double type by suffixed with d or D, of course, this convention is not required.

Character Literals: For character data types we can specify literals in 3 ways:

• Single quote: We can specify literal to char data type as single character within single quote.
```char ch = 'a';

```
• Unicode Representation: We can specify char literals in Unicode representation ‘\uxxxx’. Here xxxx represents 4 hexadecimal numbers.
```char ch = '\u0061';// Here /u0061 represent a.

```
• Escape Sequence: Every escape character can be specified as char literals.
```char ch = '\n';

```

Example :

## C#

 `// C# program to illustrate the use of char literals` `using` `System;`   `class` `Geeks {`   `    ``// Main Method` `    ``public` `static` `void` `Main(String[] args)` `    ``{`   `        ``// character literal within single quote` `        ``char` `ch = ``'a'``;`   `        ``// Unicode representation` `        ``char` `c = ``'\u0061'``;`   `        ``Console.WriteLine(ch);` `        ``Console.WriteLine(c);`   `        ``// Escape character literal` `        ``Console.WriteLine(``"Hello\n\nGeeks\t!"``);` `    ``}` `}`

```a
a
Hello

Geeks    !

```

String Literals: Literals which are enclosed in double quotes(“”) or starts with @”” are known as the String literals.

Examples:

```String s1 = "Hello Geeks!";

String s2 = @"Hello Geeks!";

```

Program:

## C#

 `// C#  program to illustrate the use of String literals` `using` `System;`   `class` `Geeks {`   `    ``// Main Method` `    ``public` `static` `void` `Main(String[] args)` `    ``{`   `        ``String s = ``"Hello Geeks!"``;` `        ``String s2 = ``@"Hello Geeks!"``;`   `        ``// If we assign without "" then it` `        ``// treats as a variable` `        ``// and causes compiler error` `        ``// String s1 = Geeks;`   `        ``Console.WriteLine(s);` `        ``Console.WriteLine(s2);` `    ``}` `}`

Output:

```Hello Geeks!
Hello Geeks!

```

Boolean Literals: Only two values are allowed for Boolean literals i.e. true and false.

Example:

```bool b = true;
bool c = false;

```

Program:

## C#

 `// C# program to illustrate the use` `// of boolean literals` `using` `System;`   `class` `Geeks {`   `    ``// Main Method` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``bool` `b = ``true``;` `        ``bool` `c = ``false``;`   `        ``// these will give compile time error` `        ``// bool d = 0;` `        ``// bool e = 1;` `        ``// Console.WriteLine(d);` `        ``// Console.WriteLine(e);`   `        ``Console.WriteLine(b);` `        ``Console.WriteLine(c);` `    ``}` `}`

Output:

```True
False

```

My Personal Notes arrow_drop_up
Recommended Articles
Page :