C++ STL Vectors Explained — Usage, Internals and Pitfalls

#include <iostream>
#include <vector>

int main() {
    std::vector<int> scores;

    // Print size and capacity before adding anything
    std::cout << "Initial state:\n";
    std::cout << "  size:     " << scores.size()     << "\n";
    std::cout << "  capacity: " << scores.capacity() << "\n\n";

    // Watch capacity grow in steps as we push elements in
    for (int i = 1; i <= 10; ++i) {
        scores.push_back(i * 10);

        // capacity jumps only when the buffer needs to be reallocated
        std::cout << "After push_back(" << i * 10 << "):"
                  << "  size=" << scores.size()
                  << "  capacity=" << scores.capacity() << "\n";
    }

    // Accessing elements is identical to a raw array — O(1)
    std::cout << "\nFirst score  (index 0): " << scores[0]     << "\n";
    std::cout << "Last score  (back()): "   << scores.back()  << "\n";
    std::cout << "Safe access (at(2)):  "   << scores.at(2)   << "\n";

    return 0;
}

#include <iostream>
#include <vector>
#include <string>
#include <chrono>

// A simple Player struct to demonstrate emplace_back vs push_back
struct Player {
    std::string name;
    int         level;
    float       health;

    Player(std::string n, int lvl, float hp)
        : name(std::move(n)), level(lvl), health(hp) {
        // In a real codebase you might load assets here — construction is NOT free
    }
};

void fillWithoutReserve(int playerCount) {
    std::vector<Player> roster;
    // No reserve() — vector will reallocate multiple times
    for (int i = 0; i < playerCount; ++i) {
        // push_back constructs a temporary Player, then moves it in
        roster.push_back(Player("Warrior_" + std::to_string(i), i % 60 + 1, 100.0f));
    }
    std::cout << "Without reserve — final capacity: " << roster.capacity() << "\n";
}

void fillWithReserve(int playerCount) {
    std::vector<Player> roster;
    roster.reserve(playerCount); // single allocation up front
    for (int i = 0; i < playerCount; ++i) {
        // emplace_back constructs the Player DIRECTLY inside the buffer — no temporary
        roster.emplace_back("Warrior_" + std::to_string(i), i % 60 + 1, 100.0f);
    }
    std::cout << "With reserve    — final capacity: " << roster.capacity() << "\n";
    std::cout << "First player: " << roster.front().name
              << "  level " << roster.front().level << "\n";
    std::cout << "Last  player: " << roster.back().name
              << "  level " << roster.back().level  << "\n";

    // Done adding — release wasted capacity (a hint, not guaranteed)
    roster.shrink_to_fit();
    std::cout << "After shrink_to_fit capacity: " << roster.capacity() << "\n";
}

int main() {
    const int PLAYER_COUNT = 500;
    fillWithoutReserve(PLAYER_COUNT);
    fillWithReserve(PLAYER_COUNT);
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>   // std::remove_if
#include <string>

struct LogEntry {
    std::string message;
    int         severity;  // 1=info, 2=warning, 3=error
};

void printLog(const std::vector<LogEntry>& log) {
    for (const auto& entry : log) {   // range-for, const ref — no copies
        std::cout << "  [" << entry.severity << "] " << entry.message << "\n";
    }
}

int main() {
    std::vector<LogEntry> eventLog = {
        {"Server started",           1},
        {"Disk usage at 80%",        2},
        {"Failed login attempt",     3},
        {"Health check OK",          1},
        {"Memory pressure detected", 2},
        {"Database unreachable",     3},
        {"Cache warmed up",          1}
    };

    std::cout << "Full log (" << eventLog.size() << " entries):\n";
    printLog(eventLog);

    // Erase-remove idiom: purge all info-level (severity==1) entries
    // std::remove_if shuffles matching elements to the end and returns
    // an iterator to the start of the junk region
    auto junkStart = std::remove_if(
        eventLog.begin(), eventLog.end(),
        [](const LogEntry& e) { return e.severity == 1; }
    );
    // erase() actually removes the junk region from the vector
    eventLog.erase(junkStart, eventLog.end());

    std::cout << "\nAfter removing info entries (" << eventLog.size() << " remain):\n";
    printLog(eventLog);

    // Safe indexed iteration when you need the index
    std::cout << "\nWarnings and errors by index:\n";
    for (std::size_t i = 0; i < eventLog.size(); ++i) {
        std::cout << "  index " << i << ": " << eventLog[i].message << "\n";
    }

    return 0;
}

#include <iostream>
#include <vector>
#include <memory>    // std::unique_ptr
#include <string>

// Base class for a simple shape hierarchy
struct Shape {
    virtual std::string describe() const = 0;
    virtual ~Shape() = default;
};

struct Circle : Shape {
    float radius;
    explicit Circle(float r) : radius(r) {}
    std::string describe() const override {
        return "Circle(r=" + std::to_string(radius) + ")";
    }
};

struct Rectangle : Shape {
    float width, height;
    Rectangle(float w, float h) : width(w), height(h) {}
    std::string describe() const override {
        return "Rect(" + std::to_string(width) + "x" + std::to_string(height) + ")";
    }
};

int main() {
    // --- Scenario 1: store by value (no polymorphism needed) ---
    // Contiguous memory, cache-friendly, zero pointer chasing
    struct Particle { float x, y, z, mass; };

    std::vector<Particle> particles;
    particles.reserve(5);
    particles.emplace_back(Particle{0.0f, 1.0f, 2.0f, 1.5f});
    particles.emplace_back(Particle{3.0f, 0.5f, 1.0f, 2.0f});
    particles.emplace_back(Particle{1.0f, 2.0f, 0.0f, 0.8f});

    std::cout << "Particles (by value — contiguous memory):\n";
    for (const auto& p : particles) {
        std::cout << "  pos=(" << p.x << "," << p.y << "," << p.z
                  << ") mass=" << p.mass << "\n";
    }

    // --- Scenario 2: store by unique_ptr (polymorphism required) ---
    // Each Shape is a separate heap allocation — necessary for virtual dispatch
    std::vector<std::unique_ptr<Shape>> canvas;
    canvas.push_back(std::make_unique<Circle>(5.0f));
    canvas.push_back(std::make_unique<Rectangle>(3.0f, 4.0f));
    canvas.push_back(std::make_unique<Circle>(2.5f));

    std::cout << "\nShapes (by unique_ptr — polymorphism enabled):\n";
    for (const auto& shape : canvas) {
        // Virtual dispatch works correctly because we're going through a pointer
        std::cout << "  " << shape->describe() << "\n";
    }
    // unique_ptr: memory is automatically freed when canvas goes out of scope

    return 0;
}