Types, Variables, const and auto

The building blocks

C++ has fundamental types: bool, char, integers (short, int, long, long long, with unsigned variants), floating point (float, double) and void. Sizes are platform-dependent within limits; use fixed-width types from <cstdint> (std::int32_t, std::uint64_t) when exact sizes matter. Prefer brace initialisation (int count{0};), which prevents narrowing conversions such as silently turning a double into an int. Uninitialised local variables hold indeterminate values, and reading them is undefined behaviour, so always initialise. const marks values that must not change; constexpr marks values (and functions) that can be computed at compile time. auto deduces a variable's type from its initialiser, reducing noise for long type names such as iterators, while keeping static typing. Use std::string for text, not C-style char arrays. Integer overflow of signed types is undefined behaviour, a common source of bugs in competitive programming; use long long when values can exceed about 2.1 billion.

Initialisation, const, constexpr and auto

Brace initialisation rejects narrowing at compile time.

#include <cstdint>
#include <string>
#include <vector>

int main() {
    int count{0};                    // always initialise
    double price{499.5};
    // int rounded{price};           // error: narrowing conversion rejected by braces
    int rounded = static_cast<int>(price);   // explicit, visible conversion

    const std::string shop{"GeekMart"};      // cannot be modified
    constexpr int maxItems = 100;            // compile-time constant
    std::int64_t bigTotal = 3'000'000'000;   // digit separators (C++14)

    std::vector<std::string> names{"Asha", "Ravi"};
    auto first = names.front();              // std::string (a copy)
    auto& firstRef = names.front();          // reference, no copy
    auto it = names.begin();                 // std::vector<std::string>::iterator
    return 0;
}

auto drops references and const

auto x = v.front(); makes a copy. Write auto& or const auto& when you want a reference, especially in range-based for loops over containers of large objects.

Quick check: What does brace initialisation such as `int x{3.7};` do?

• Silently truncates to 3
• Rounds to 4
• Fails to compile because it is a narrowing conversion
• Creates a double