基于范围的 for 循环

for (auto& x : container) {
    // 对 x 的操作直接作用于容器元素
}

// 用户写的代码
for (auto& x : container) {
    std::cout << x;
}

// 编译器等价展开（简化版）
{
    auto&& __range = container;
    for (auto __begin = begin(__range), __end = end(__range);
         __begin != __end; ++__begin) {
        auto& x = *__begin;
        std::cout << x;
    }
}

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

struct Employee {
    std::string name;
    std::string title;
    int age;
    double salary;
};

int main() {
    // 飞翔科技产品部员工
    std::vector<Employee> team = {
        {"孔蓝", "高级产品经理", 28, 32000.0},
        {"赵鸣", "内容运营",      26, 18888.0},
        {"孙鹤", "产品助理",      23,  8888.0},
    };

    std::cout << "===== 产品部名册 =====" << std::endl;

    // ---- 方式1：const auto& —只读遍历，不拷贝 ----
    std::cout << "\n[只读遍历 — const auto&]" << std::endl;
    for (const auto& emp : team) {
        std::cout << emp.name << " | " << emp.title
                  << " | " << emp.age << " 岁"
                  << " | ¥" << emp.salary << std::endl;
    }

    // ---- 方式2：auto& —需要修改元素 ----
    std::cout << "\n[修改遍历 — auto&]" << std::endl;
    for (auto& emp : team) {
        emp.salary *= 1.10;  // 全员涨薪 10%
    }
    for (const auto& emp : team) {
        std::cout << emp.name << " 涨薪后: ¥" << emp.salary << std::endl;
    }

    // ---- 方式3：auto —值拷贝（不推荐用于大对象） ----
    std::cout << "\n[值拷贝 — auto（仅适合小类型）]" << std::endl;
    for (auto name_only : {"孔蓝", "赵鸣", "孙鹤"}) {
        std::cout << "  " << name_only << std::endl;
    }

    // ---- 方式4：C 风格数组 ----
    std::cout << "\n[遍历 C 数组]" << std::endl;
    int bonus[] = {3000, 2000, 1000};
    for (const auto& b : bonus) {
        std::cout << "奖金: ¥" << b << std::endl;
    }

    return 0;
}

#include <iostream>
#include <cstddef>

// 简易环形缓冲区
template <typename T, std::size_t N>
class RingBuffer {
public:
    void push(const T& value) {
        data_[write_pos_] = value;
        write_pos_ = (write_pos_ + 1) % N;
        if (full_) {
            read_pos_ = (read_pos_ + 1) % N;
        }
        full_ = (write_pos_ == read_pos_);
    }

    // 迭代器——让范围 for 能遍历
    class Iterator {
    public:
        Iterator(const T* data, std::size_t pos, std::size_t start, std::size_t count)
            : data_(data), pos_(pos), start_(start), count_(count) {}

        const T& operator*() const { return data_[pos_]; }
        Iterator& operator++() {
            pos_ = (pos_ + 1) % N;
            ++count_;
            return *this;
        }
        bool operator!=(const Iterator& other) const {
            return count_ != other.count_;
        }

    private:
        const T* data_;
        std::size_t pos_;
        std::size_t start_;
        std::size_t count_;
    };

    Iterator begin() const {
        return Iterator(data_, read_pos_, read_pos_, 0);
    }
    Iterator end() const {
        std::size_t total = full_ ? N : write_pos_;
        return Iterator(data_, write_pos_, read_pos_, total);
    }

private:
    T data_[N]{};
    std::size_t read_pos_  = 0;
    std::size_t write_pos_ = 0;
    bool full_ = false;
};

int main() {
    RingBuffer<int, 5> rb;

    // 推送数据
    for (int i = 1; i <= 7; ++i) {
        rb.push(i * 10);
    }

    std::cout << "环形缓冲区遍历（容量5，推入7个）:" << std::endl;
    for (const auto& val : rb) {
        std::cout << "  " << val;
    }
    std::cout << std::endl;
    std::cout << "（只保留最后 5 个：30 40 50 60 70）" << std::endl;

    return 0;
}