C++ - Types of Literals in c++

Types of Literals in C++

Introduction

In C++, literals refer to constant values that are directly written into the code. They represent fixed values used to initialize variables or in expressions. There are different types of literals in C++ based on the type of data they represent. These include integer literals, floating-point literals, character literals, string literals, and more.

1. Integer Literals

Integer literals represent whole numbers. C++ allows integer literals to be written in various number systems: decimal, octal, hexadecimal, and binary.

Syntax

integerLiteral = [base] number;

Examples

• Decimal: An integer literal in base 10. Example: 10
• Octal: An integer literal in base 8, prefixed with 0. Example: 012
• Hexadecimal: An integer literal in base 16, prefixed with 0x or 0X. Example: 0xA
• Binary: An integer literal in base 2, prefixed with 0b or 0B (available from C++14). Example: 0b1010

Integer Literal Example

int decimal = 10;    // Decimal literal
int octal = 012;      // Octal literal
int hexadecimal = 0xA;  // Hexadecimal literal
int binary = 0b1010;  // Binary literal (C++14)

2. Floating-Point Literals

Floating-point literals represent real numbers with fractional parts. They can be written in either fixed-point or scientific notation.

Syntax

floatingPointLiteral = number [exponent] [suffix];

Examples

• Fixed-point notation: Example: 3.14
• Scientific notation: Example: 1.23e4 (which equals 12300.0)
• Suffix: You can specify the precision using the suffix f for float, l for long double.

Floating-Point Literal Example

float f = 3.14f;    // Float literal
double d = 2.71828;   // Double literal
long double ld = 1.23e4l;  // Long double literal

3. Character Literals

Character literals represent single characters enclosed in single quotes. These literals are typically used to initialize variables of type char.

Syntax

characterLiteral = 'character';

Examples

• Character literal: A single character enclosed in single quotes. Example: 'A'
• Escape sequences: Special characters such as newline, tab, etc., are represented using escape sequences. Example: '\n' (newline), '\\' (backslash).

Character Literal Example

char letter = 'A';     // Character literal
char newline = '\n';    // Escape sequence

4. String Literals

String literals represent a sequence of characters enclosed in double quotes. They are typically used for text processing and can be assigned to variables of type std::string or char[].

Syntax

stringLiteral = "string";

Examples

• String literal: A sequence of characters enclosed in double quotes. Example: "Hello, World!"
• Escape sequences in strings: Strings can contain special characters like newlines or tabs. Example: "Hello\nWorld" represents a string with a newline.

String Literal Example

std::string greeting = "Hello, World!";  // String literal
std::string multiline = "Hello\nWorld";  // String with newline

5. Boolean Literals

Boolean literals represent the truth values true and false. They are used to initialize variables of type bool.

Syntax

booleanLiteral = true | false;

Examples

• True: Represents the value true. Example: true
• False: Represents the value false. Example: false

Boolean Literal Example

bool isTrue = true;   // Boolean literal
bool isFalse = false;  // Boolean literal

6. Null Pointer Literal

The null pointer literal represents a pointer that does not point to any valid object or function. It is represented by nullptr in C++11 and later.

Syntax

nullPointerLiteral = nullptr;

Example

int* ptr = nullptr;  // Null pointer literal

7. Wide Character and Wide String Literals

Wide character literals are used to represent characters that are wider than the usual char type. They are enclosed in L'' (for a single character) or L"" (for a string).

Syntax

wchar_tLiteral = L'character';
wchar_tStringLiteral = L"string";

Examples

• Wide character literal: Example: L'A'
• Wide string literal: Example: L"Hello"

Wide Character Literal Example

wchar_t wideChar = L'A';   // Wide character literal
wchar_t* wideStr = L"Hello";     // Wide string literal

Literals are fundamental elements in C++ that allow developers to directly represent constant values in code. By using different types of literals, you can represent integer values, floating-point numbers, characters, strings, and boolean values, making your programs more readable and expressive.