## C# Literals

C# Literals are the fixed value used by a variable that is predefined and cannot be modified during the execution of the code. These are the convenient form of constant values like other variables but their values cannot be changed. The value used by a variable can be integer, decimal, floating type or string.

// 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 known 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 are used for unsigned numbers while or 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

### Example:

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# program to illustrate the use of Integer Literals
using System;

class Techappss{

// 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.

### Example:

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# program to illustrate the use of
// floating-point literals
using System;

class Techappss {

// 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# program to illustrate the use of char literals
using System;

class Techappss {

// 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\nTechappss\t!");
}
}
a
a
Hello

Techappss    !

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

### Example:

String s1 = "Hello Techappss!";

String s2 = @"Hello Techappss!";

### Program:

// C#  program to illustrate the use of String literals
using System;

class Techappss {

// Main Method
public static void Main(String[] args)
{

String s = "Hello Techappss!";
String s2 = @"Hello Techappss!";

// If we assign without "" then it
// treats as a variable
// and causes compiler error
// String s1 = Techappss;

Console.WriteLine(s);
Console.WriteLine(s2);
}
}

### Output:

Hello Techappss!
Hello Techappss!

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

bool b = true;
bool c = false;

### Program:

/ C# program to illustrate the use
// of boolean literals
using System;

class Techappss {

// 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);
}
}

True
False