一批测量数据：按先备选择阶段

// Stage 01: read one value, update one accumulator. Original teaching code.
#include <array>
#include <iostream>
int main() {
    // Five existing integers. Positions are 0, 1, 2, 3, 4.
    const std::array<int,5> readings{3,1,4,1,5};
    int total=0;
    for(const int reading:readings) {
        total+=reading; // After each pass: 3, 4, 8, 9, 14.
    }
    if(total!=14 || readings.size()!=5) return 1;
    int empty_total=0;
    for(const int reading:std::array<int,0>{}) empty_total+=reading;
    int single_total=0;
    for(const int reading:std::array<int,1>{5}) single_total+=reading;
    if(empty_total!=0 || single_total!=5) return 2;
    std::cout<<"count="<<readings.size()<<" total="<<total<<'\n';
    std::cout<<"empty="<<empty_total<<" single="<<single_total<<'\n';
}

// Stage 02: functions name a step; references explicitly permit a change.
#include <array>
#include <iostream>
int calibrated(int reading,int offset) {
    return reading+offset; // The caller's reading is not modified.
}
void add_reading(int& total,int reading) {
    total+=reading; // This name refers to the caller's accumulator.
}
int main() {
    const std::array<int,5> readings{3,1,4,1,5};
    int raw=0,adjusted=0;
    for(const int reading:readings) {
        add_reading(raw,reading);
        add_reading(adjusted,calibrated(reading,2));
    }
    int original=3;
    const int copy=calibrated(original,2);
    int zero=0;add_reading(zero,0);
    if(raw!=14 || adjusted!=24 || original!=3 || copy!=5 || zero!=0) return 1;
    std::cout<<"raw="<<raw<<" calibrated="<<adjusted<<'\n';
    std::cout<<"original="<<original<<" returned="<<copy<<'\n';
}

// Stage 03: vector owns values; span borrows a contiguous range and length.
#include <iostream>
#include <span>
#include <vector>
int total_of(std::span<const int> readings) {
    int total=0;
    for(const int value:readings) total+=value;
    return total; // The small teaching inputs keep the sum within int.
}
int main() {
    const std::vector<int> readings{3,1,4,1,5};
    const std::span<const int> view{readings};
    auto independent=readings; // Own a copy of all five values.
    independent[0]+=10;
    if(total_of(view)!=14 || total_of(independent)!=24) return 1;
    if(total_of(std::span<const int>{})!=0) return 2;
    const std::vector<int> single{5};
    if(total_of(single)!=5) return 3;
    // The owner is still alive; no operation reallocates its storage.
    std::cout<<"owner="<<total_of(readings)<<" copy="<<total_of(independent)
             <<" borrowed="<<total_of(view)<<'\n';
}

// Stage 06: read in two passes: ownership first, generic summation later.
#include <algorithm>
#include <concepts>
#include <iostream>
#include <memory>
#include <span>
#include <utility>
#include <vector>
struct ReadingBatch {std::vector<int> readings;};
template<std::integral T>
long long total_of(std::span<const T> readings) {
    long long total=0;
    for(const T value:readings) total+=value;
    return total; // Only the documented small teaching values are supplied; this is not checked arithmetic.
}
int main() {
    auto owner=std::make_unique<ReadingBatch>(ReadingBatch{{3,1,4,1,5}});
    const std::span<const int> borrowed{owner->readings};
    auto snapshot=*owner;snapshot.readings[0]+=10;
    auto next_owner=std::move(owner); // Transfer the pointer, not the pointee.
    if(owner || !next_owner) return 1;
    int threshold=3;
    const auto large=[threshold](int reading){return reading>=threshold;};
    const auto count=std::count_if(borrowed.begin(),borrowed.end(),large);
    const std::vector<short> small_type{3,1,4,1,5};
    const std::vector<unsigned char> bytes{250,10};
    if(total_of<int>(borrowed)!=14 || total_of<int>(snapshot.readings)!=24 ||
       total_of<short>(small_type)!=14 || total_of<unsigned char>(bytes)!=260 || count!=3 ||
       total_of<int>(std::span<const int>{})!=0) return 2;
    std::cout<<"owner_empty="<<(!owner)<<" next=14 snapshot=24 large="<<count<<'\n';
    std::cout<<"generic_int=14 generic_short=14\n";
}

// Stage 05: a class owns its vector and protects a small, explicit value range.
#include <iostream>
#include <span>
#include <stdexcept>
#include <vector>
class ReadingBatch {
    std::vector<int> readings_;
public:
    explicit ReadingBatch(const std::vector<int>& readings):readings_(readings) {
        if(readings_.size()>1024) throw std::invalid_argument("batch too large");
        for(const int value:readings_)
            if(value < -1000000 || value > 1000000)
                throw std::invalid_argument("reading range");
    }
    std::span<const int> view() const {return readings_;}
    long long total() const {
        long long result=0;
        for(const int value:readings_) result+=value;
        return result;
    }
    // Rule of Zero: vector releases its storage when this batch is destroyed.
    // No handwritten delete, copy operation, or destructor is necessary.
};
int main() {
    const ReadingBatch batch{{3,1,4,1,5}};
    long long saved=0;
    {const ReadingBatch temporary{{1,2}};saved=temporary.total();}
    // saved owns a number. It does not borrow the destroyed temporary's storage.
    int rejected=0;
    try {const ReadingBatch bad{{1000001}};} catch(const std::invalid_argument&) {++rejected;}
    try {const ReadingBatch bad{std::vector<int>(1025,0)};} catch(const std::invalid_argument&) {++rejected;}
    const ReadingBatch empty{std::vector<int>{}},boundary{{-1000000,1000000}};
    const ReadingBatch largest{std::vector<int>(1024,1000000)};
    if(batch.total()!=14 || batch.view().size()!=5 || saved!=3 || rejected!=2 ||
       empty.view().size()!=0 || empty.total()!=0 || boundary.total()!=0 ||
       largest.total()!=1024000000LL) return 1;
    std::cout<<"batch=14 saved_after_scope="<<saved<<" rejected="<<rejected<<'\n';
}

// Textbook stage-07 migration: check optional state before reading its value.
// Stage 07: independent expected values, always-on checks, and strict input parsing.
#include <charconv>
#include <cstddef>
#include <iostream>
#include <optional>
#include <span>
#include <string_view>
#include <vector>
struct Summary {std::size_t count;long long total;};
Summary summarize(std::span<const int> values) {
    Summary result{values.size(),0};
    for(const int value:values) result.total+=value;
    return result;
}
std::optional<int> parse_reading(std::string_view text) {
    if(text.empty()) return std::nullopt;
    int value=0;
    const auto [end,error]=std::from_chars(text.data(),text.data()+text.size(),value);
    if(error!=std::errc{} || end!=text.data()+text.size() || value < -1000000 || value > 1000000)
        return std::nullopt;
    return value;
}
int main() {
    const std::vector<std::vector<int>> cases{{3,1,4,1,5},{},{5},{-3,1},{0,0}};
    const std::vector<long long> expected{14,0,5,-2,0};
    for(std::size_t i=0;i<cases.size();++i) {
        const auto actual=summarize(cases[i]);
        if(actual.total!=expected[i] || actual.count!=cases[i].size()) return 1;
    }
    const auto three = parse_reading("3");
    const auto lower = parse_reading("-1000000");
    if(!three || *three!=3 || !lower || *lower!=-1000000 ||
       parse_reading("3x") || parse_reading("") || parse_reading("1000001")) return 2;
    const std::vector<int> left{3,1},right{4,1,5};
    if(summarize(left).total+summarize(right).total!=14) return 3;
    std::cout<<"batch_cases="<<cases.size()<<" parsing_checks=5 split_total=14\n";
}

// Stage 08: optional preview after chapter 14; concurrency is taught in chapters 21-27.
#include <algorithm>
#include <cstddef>
#include <iostream>
#include <span>
#include <stdexcept>
#include <thread>
#include <utility>
#include <vector>
std::pair<std::size_t,std::size_t> partition(std::size_t n,std::size_t p,std::size_t id) {
    if(p==0 || id>=p) throw std::invalid_argument("partition");
    const auto q=n/p,r=n%p,begin=id*q+std::min(id,r);
    return {begin,begin+q+(id<r?1:0)};
}
long long parallel_total(std::span<const int> input,std::size_t p) {
    if(p==0 || p>8 || input.size()>1024) throw std::invalid_argument("bounded workload");
    for(const int value:input)
        if(value < -1000000 || value > 1000000) throw std::invalid_argument("reading range");
    std::vector<long long> partial(p,0);
    std::vector<std::thread> workers;workers.reserve(p);
    struct JoinAll {
        std::vector<std::thread>& threads;
        ~JoinAll(){for(auto& thread:threads) if(thread.joinable()) thread.join();}
    } join_all{workers};
    for(std::size_t id=0;id<p;++id) {
        const auto [begin,end]=partition(input.size(),p,id);
        workers.emplace_back([&,id,begin,end]{
            long long local=0;
            for(auto i=begin;i<end;++i) local+=input[i];
            partial[id]=local; // Each thread writes its own existing slot once.
        });
    }
    for(auto& thread:workers) thread.join();
    long long total=0;for(const auto value:partial) total+=value;
    return total;
}
int main() {
    const std::vector<int> readings{3,1,4,1,5},single{5};
    for(std::size_t p=1;p<=8;++p) {
        if(parallel_total(readings,p)!=14 || parallel_total({},p)!=0 || parallel_total(single,p)!=5) return 1;
        std::size_t previous=0;
        for(std::size_t id=0;id<p;++id) {
            const auto [begin,end]=partition(readings.size(),p,id);
            if(begin!=previous || end<begin || end>readings.size()) return 2;
            previous=end;
        }
        if(previous!=readings.size()) return 3;
    }
    int rejected=0;
    for(const std::size_t p:{0U,9U})
        try{(void)parallel_total(readings,p);}catch(const std::invalid_argument&){++rejected;}
    if(rejected!=2) return 4;
    std::cout<<"parallel_total="<<parallel_total(readings,3)<<" worker_cases=8 rejected=2\n";
    std::cout<<"ranges=0:2,2:4,4:5\n";
}