一、底层架构与核心特性

std::vector 是 C++ 标准库中最为广泛使用的序列式容器。其内存布局与连续地址的普通数组保持高度一致，工程实践中常被称为"动态单端数组"。与固定长度的静态数组不同，vector 具备根据运行时数据规模自动调节存储空间的弹性。

当容器触发改扩操作时，系统并不会在原内存地址后方直接追加区块，而是向堆区申请一块容量更大的独立内存池，随后执行元素迁移并将原始地址回收到内存管理器。此外，该容器封装了随机访问迭代器，支持高效的指针偏移、距离计算以及 O(1) 时间复杂度的任意位置寻址。

二、初始化策略

提供多种实例化途径以适配不同业务场景，支持默认构建、区间映射、批量填充及深度拷贝。

#include <iostream>
#include <vector>

void renderContainer(const std::vector<int>& buf) {
    for (const auto& item : buf) {
        std::cout << item << ' ';
    }
    std::cout << '\n';
}

void exploreConstructors() {
    // 1. 默认构造结合逐步追加
    std::vector<int> initialPool;
    for (int cnt = 0; cnt < 10; ++cnt) {
        initialPool.push_back(cnt);
    }
    renderContainer(initialPool);

    // 2. 区间法映射：提取另一容器的完整范围
    std::vector<int> mirrorContainer(initialPool.begin(), initialPool.end());
    renderContainer(mirrorContainer);

    // 3. 批量同质化填充
    std::vector<int> uniformSet(10, 100);
    renderContainer(uniformSet);

    // 4. 引用语义拷贝构造
    std::vector<int> cloneContainer(uniformSet);
    renderContainer(cloneContainer);
}

三、赋值与覆盖机制

支持通过重载运算符进行对象状态平移，或通过专用方法执行指定规则的覆盖写入。所有操作均触发深拷贝，确保内存独立性。

#include <iostream>
#include <vector>

void overwriteDemo() {
    std::vector<int> sourceData;
    for (int idx = 0; idx < 5; ++idx) sourceData.emplace_back(idx * 20);

    // 重载等号实现完全替换
    std::vector<int> destination;
    destination = sourceData;
    for (auto v : destination) std::cout << v << ' ';
    std::cout << '\n';

    // assign方法：区间覆盖
    std::vector<int> viaRange;
    viaRange.assign(sourceData.cbegin(), sourceData.cend());
    for (auto v : viaRange) std::cout << v << ' ';
    std::cout << '\n';

    // assign方法：定量重置
    std::vector<int> viaCount;
    viaCount.assign(6, 88);
    for (auto v : viaCount) std::cout << v << ' ';
    std::cout << '\n';
}

四、容量与逻辑大小管控

需严格区分容量（capacity）与大小（size）。前者代表已分配的物理内存上限，后者表示当前驻留的有效元素数量。使用 resize() 可双向调整逻辑维度。

#include <iostream>
#include <vector>

void manageDimensions() {
    std::vector<int> metrics;
    for (int k = 0; k < 8; ++k) metrics.emplace_back(k + 1);

    if (!metrics.empty()) {
        std::cout << "有效元素数: " << metrics.size() << '\n';
        std::cout << "底层分配阈值: " << metrics.capacity() << '\n';
    }

    // 拉长维度，超出的空缺位由值初始化的零补位
    metrics.resize(12);
    for (auto val : metrics) std::cout << val << ' ';
    std::cout << '\n';

    // 拉长维度并指定自定义填充值
    metrics.resize(16, 99);
    for (auto val : metrics) std::cout << val << ' ';
    std::cout << '\n';

    // 缩短维度，超出部分直接截断销毁
    metrics.resize(3);
    for (auto val : metrics) std::cout << val << ' ';
    std::cout << '\n';
}

五、节点增删操作

涵盖首尾快捷操作与中间区域的精确控制。需注意：任意位置的插入或删除都可能引发后续元素的内存搬运，且可能使原有迭代器失效。

#include <iostream>
#include <vector>

void manipulateNodes() {
    std::vector<int> ringBuffer;
    ringBuffer.reserve(15);

    // 尾部压入
    ringBuffer.emplace_back(15);
    ringBuffer.emplace_back(25);
    ringBuffer.emplace_back(35);
    ringBuffer.emplace_back(45);
    ringBuffer.emplace_back(55);
    for (auto n : ringBuffer) std::cout << n << ' ';
    std::cout << '\n';

    // 弹出末尾项
    ringBuffer.pop_back();
    for (auto n : ringBuffer) std::cout << n << ' ';
    std::cout << '\n';

    // 指定迭代器前嵌入单值
    ringBuffer.insert(ringBuffer.begin(), 100);
    for (auto n : ringBuffer) std::cout << n << ' ';
    std::cout << '\n';

    // 指定位置批量注入同构值
    ringBuffer.insert(ringBuffer.begin() + 1, 3, 200);
    for (auto n : ringBuffer) std::cout << n << ' ';
    std::cout << '\n';

    // 擦除起始节点
    ringBuffer.erase(ringBuffer.begin());
    for (auto n : ringBuffer) std::cout << n << ' ';
    std::cout << '\n';

    // 全局清空（保留已分配容量）
    ringBuffer.clear();
    std::cout << "清理完毕\n";
}

六、元素访问路径

除迭代器遍历外，容器提供基于下标的直接寻址接口。运算符 [] 性能极高但不执行边界校验，而 at() 会抛出异常保障安全。

#include <iostream>
#include <vector>

void accessInterface() {
    std::vector<int> payload;
    for (int q = 0; q < 5; ++q) payload.push_back(q * 2);

    // 快车道索引（无越界保护）
    for (size_t i = 0; i < payload.size(); ++i) {
        std::cout << payload[i] << ' ';
    }
    std::cout << '\n';

    // 安全车道索引（越界触发 std::out_of_range）
    for (size_t i = 0; i < payload.size(); ++i) {
        std::cout << payload.at(i) << ' ';
    }
    std::cout << '\n';

    std::cout << "首项: " << payload.front() << '\n';
    std::cout << "末项: " << payload.back() << '\n';
}

七、容器置换与内存优化

swap() 本质是交换底层指向堆区的指针元数据，时间复杂度为 O(1)。该特性常被用于"强制缩容"场景，解决因历史扩容导致的内存碎片闲置问题。

#include <iostream>
#include <vector>

void exchangeAndCompact() {
    std::vector<int> groupA;
    for (int j = 0; j < 10; ++j) groupA.push_back(j);

    std::vector<int> groupB;
    for (int j = 10; j > 0; --j) groupB.push_back(j);

    std::swap(groupA, groupB);
    for (auto x : groupA) std::cout << x << ' ';
    std::cout << '\n';
    for (auto x : groupB) std::cout << x << ' ';
    std::cout << '\n';

    // 缩容实战：利用临时对象析构剥离冗余分配区
    std::vector<int> bulkyStorage;
    bulkyStorage.reserve(50000);
    for (int m = 0; m < 50000; ++m) bulkyStorage.emplace_back(m);

    std::cout << "扩张阶段容量: " << bulkyStorage.capacity() << '\n';
    bulkyStorage.resize(100);
    std::cout << "收缩后容量(未变更): " << bulkyStorage.capacity() << '\n';

    // 构造仅容纳当前有效数据的匿名向量，并与本体交换，迫使旧大内存块释放
    std::vector<int>(bulkyStorage).swap(bulkyStorage);
    std::cout << "强制回收后容量: " << bulkyStorage.capacity() << '\n';
}

八、预分配存储策略

通过提前声明预期容量，可有效规避频繁触发 new/delete 带来的性能损耗与迭代器失效风险。

#include <iostream>
#include <vector>

void optimizeAllocation() {
    std::vector<int> preAllocated;

    // 预先划定内存边界
    preAllocated.reserve(20000);

    int rebalanceEvents = 0;
    void* priorBase = nullptr;

    for (int t = 0; t < 20000; ++t) {
        preAllocated.emplace_back(t);
        void* currentBase = const_cast<void*>(static_cast<const void*>(&preAllocated[0]));
        if (currentBase != priorBase) {
            ++rebalanceEvents;
            priorBase = currentBase;
        }
    }

    std::cout << "底层重分配频次: " << rebalanceEvents << '\n';
}