C++ Literals

Literals are constant values that are directly inserted into the source code. They represent specific data values and are used to initialize variables or express values within expressions.

Types of Literals in C++

1. Integer Literals:

Decimal: Represents integers in base 10 (e.g., 10, -25).
Octal: Represents integers in base 8 (e.g., 012, 037).
Hexadecimal: Represents integers in base 16 (e.g., 0x1A, 0xFF).
Binary: Represents integers in base 2 (e.g., 0b1010, 0b1111).
Suffixes:
- u or U: unsigned integer
- l or L: long integer
- ul or UL: unsigned long integer

2. Floating-Point Literals:

Decimal: Represents real numbers with a decimal point (e.g., 3.14, -2.5).
Scientific Notation: Represents real numbers using exponents (e.g., 3.14e2, -2.5E-3).
Suffixes:
- f or F: float
- l or L: long double

3. Character Literals:

Single-Quoted: Represents a single character (e.g., 'a', 'z').
Escape Sequences:
- \n: newline
- \t: tab
- \r: carriage return
- \b: backspace
- \f: form feed
- \\: backslash
- \?: question mark
- \': single quote
- \": double quote

4. String Literals:

Double-Quoted: Represents a sequence of characters (e.g., "Hello, world!").
Escape Sequences: Same as character literals.
Wide String Literals:
- Preceded by L (e.g., L"Wide string").
- Uses wide characters for Unicode support.

5. Boolean Literals:

true and false represent Boolean values.

6. Pointer Literals:

nullptr represents a null pointer.

Example:

        
            int decimal_int = 10;

            int octal_int = 012;

            int hex_int = 0xA;

            int binary_int = 0b1010;

            float float_num = 3.14f;

            double double_num = 2.71828;

            char character = 'A';

            char newline_char = '\n';

            std::string str = "Hello, world!";

            std::wstring wstr = L"Wide string";

            bool is_true = true;

            bool is_false = false;

            int* ptr = nullptr;