Types and Data

#include <array>
#include <iostream>
#include <map>
#include <string>
#include <vector>

int main() {
    std::vector<int> nums{3, 1, 4};
    nums.push_back(1);
    std::cout << nums.size() << ' ' << nums[0] << '\n'; // 4 3

    std::array<double, 3> point{1.0, 2.0, 3.0};
    std::cout << point.at(2) << '\n';  // at() checks the index

    std::map<std::string, int> stock;
    stock["apple"] = 5;
    stock["banana"] = 2;
    for (const auto& [name, qty] : stock) {   // C++17 structured bindings
        std::cout << name << ": " << qty << '\n';
    }
    if (stock.contains("apple")) { /* C++20 */ }
}

operator[] on a vector does no bounds checking, and an out-of-range index is undefined behavior. Use at() or check the size when you aren't sure. Also note that operator[] on a std::map inserts a default-constructed value when the key is missing, which can surprise you during lookups.

Classes

A class bundles data (member variables) with behavior (member functions). Making the data private means only the class itself can modify it, so it can guarantee that its objects always stay in a valid state.

#include <stdexcept>
#include <string>
#include <utility>

class Account {
public:
    explicit Account(std::string owner, long long balance = 0)
        : owner_{std::move(owner)}, balance_{balance} {   // member initializer list
        if (balance_ < 0) throw std::invalid_argument("negative balance");
    }

    void deposit(long long amount) { balance_ += amount; }
    long long balance() const { return balance_; }         // const member function
    const std::string& owner() const { return owner_; }

private:
    std::string owner_;
    long long balance_;
};

// Account a{"Kim", 1000};
// a.deposit(500);   // a.balance() == 1500

Constructors initialize members through the member initializer list after the colon. explicit stops a single-argument constructor from being used for implicit conversions you didn't ask for. Member functions that don't modify the object are marked const, which lets you call them on const objects and references.

Structs and enum class

The only language difference between struct and class is the default access: members of a struct are public. By convention, struct is used for plain bundles of data with no invariants to protect. For enumerations, prefer enum class: its enumerators are scoped and don't convert silently to integers.

#include <string>

enum class Color { Red, Green, Blue };

struct Pixel {
    int x = 0;
    int y = 0;
    Color color = Color::Red;
};

std::string to_string(Color c) {
    switch (c) {
        case Color::Red:   return "red";
        case Color::Green: return "green";
        case Color::Blue:  return "blue";
    }
    return "unknown";
}

// Pixel p{10, 20, Color::Blue};          // aggregate initialization
// int raw = static_cast<int>(p.color);   // explicit when you need the number

Summary

• Use the <cstdint> fixed-width types when integer size matters.
• Store text in std::string; accept read-only text as const std::string& or std::string_view.
• Reach for std::vector first, std::array for fixed sizes, and std::map or std::unordered_map for key-value data.
• Use a class with private members for types that enforce invariants, and a struct for plain data.
• Prefer enum class over plain enum.