Fundamental data types

C++ comes with built-in support for several types of data, often called built-in types or fundamental types.

void is a special type that represents the absence of a value.

You cannot create a variable of type void (e.g., void x; will cause an error).
It is most commonly used as a return type for functions that perform an action but return nothing to the caller.

Data types don't have a fixed size in the C++ standard; their size depends on the compiler and architecture (e.g., 32-bit vs 64-bit).

sizeof operator: A unary operator that tells you how many bytes of memory a specific type or variable consumes.
Example: sizeof(int) might return 4 on most modern systems.

Integers can be signed (hold both positive and negative numbers) or unsigned (positive only).

By default, int is signed.
Range: A signed \(n\)-bit integer has a range of \(-(2^{n-1})\) to \(2^{n-1}-1\).
Integer Overflow: If you try to store a number outside this range, the result is undefined behavior.

Unsigned integers use the unsigned keyword and can only store non-negative values (\(0\) to \(2^n - 1\)).

The Trap: When an unsigned integer goes below zero, it "wraps around" to the largest possible value for that type.
Best Practice: Use signed integers for almost everything, even if the value will never be negative. Use unsigned only for bit manipulation or when required by a specific library.

Because int can be different sizes on different systems, C++ provides types with guaranteed sizes in the <cstdint> header.

Examples: std::int16_t (2 bytes), std::int32_t (4 bytes).
std::size_t: A special unsigned type used to represent the size or length of objects. It is guaranteed to be large enough to hold the size of the largest object your system can create.

Floating point types represent real numbers (e.g., 3.14159).

Types: float (single precision), double (double precision), and long double.
Scientific Notation: C++ uses e to represent powers of 10. 1.2e3 is \(1.2 \times 10^3 = 1200\).
Precision Issues: Floating point numbers are approximations. Comparisons like if (0.1 + 0.2 == 0.3) will often fail due to tiny rounding errors.

The bool type holds one of two values: true or false.

When converted to integers, true becomes 1 and false becomes 0.
std::boolalpha: A manipulator used with std::cout to print "true" or "false" instead of "1" or "0".

The if statement allows for conditional execution.

Syntax: if (condition) { /* code */ }
If the condition evaluates to true (any non-zero value), the code block executes.
Else: An optional else block executes if the condition is false.

The char type stores a single character.

Characters are actually stored as small integers (usually based on the ASCII table).
Literals: Always use single quotes for chars ('a') and double quotes for strings ("a").
Example: 'a' is stored as the value 97.

Sometimes you need to convert a value from one type to another.

Implicit Conversion: The compiler does it automatically (e.g., assigning an int to a double).
Explicit Conversion (static_cast): The programmer manually converts the type.
- Syntax: static_cast<new_type>(expression)
- Use case: Converting a char to an int to see its ASCII value, or preventing data loss warnings when converting a double to an int.