何时应选用std::inplace_vector而非std::vector/std::array？求适用场景示例

std::inplace_vector的核心价值在于编译期固定容量（无堆内存分配）+ 仅初始化实际使用的元素，刚好填补了std::array（必须提前初始化所有元素）和std::vector（容量动态可变、依赖堆内存）之间的空白。以下是几个典型的适用场景：

1. 存储无默认构造函数的对象，且元素数量上限明确 #

如果自定义类型没有默认构造函数，用std::array必须提前构造所有容量内的对象，会带来不必要的开销；而std::vector需要堆内存分配。std::inplace_vector可以在固定容量内，只构造实际添加的元素。

#include <inplace_vector>

// 无默认构造函数的自定义类型
struct CustomTask {
    int task_id;
    std::function<void()> handler;
    // 仅提供带参构造
    CustomTask(int id, std::function<void()> h) : task_id(id), handler(std::move(h)) {}
};

void schedule_max_3_tasks() {
    // 容量固定为3，仅初始化实际添加的任务
    std::inplace_vector<CustomTask, 3> task_queue;
    
    task_queue.emplace_back(1, [](){ /* 任务1逻辑 */ });
    task_queue.emplace_back(2, [](){ /* 任务2逻辑 */ });
    // 仅构造了2个任务，剩余容量的内存未初始化
    
    for (auto& task : task_queue) {
        task.handler();
    }
}

2. 嵌入式/内存受限环境下的动态元素缓存 #

在嵌入式系统中，堆内存分配可能引发碎片化、分配失败等问题，而std::array的全元素初始化会浪费内存和构造开销。std::inplace_vector使用栈/静态内存，固定容量，仅初始化实际用到的元素，完美适配这类场景。

#include <inplace_vector>

struct SensorData {
    uint64_t timestamp;
    float temperature;
    // 构造时需要初始化硬件相关的校准数据，开销较大
    SensorData(uint64_t ts, float temp) : timestamp(ts), temperature(temp) {
        // 模拟校准逻辑
        temperature += get_calibration_offset();
    }
};

void collect_sensor_readings() {
    // 栈上分配，固定容量10，无堆内存操作
    std::inplace_vector<SensorData, 10> reading_cache;
    
    while (auto raw_data = read_sensor_hw()) {
        if (reading_cache.size() == reading_cache.capacity()) {
            reading_cache.erase(reading_cache.begin()); // 移除最早的记录
        }
        reading_cache.emplace_back(raw_data.timestamp, raw_data.temp);
        // 仅初始化实际采集到的读数，避免array提前构造10个对象的开销
    }
}

3. 返回可变数量但上限明确的函数结果 #

如果函数需要返回的元素数量不固定，但有明确的上限，用std::vector会带来堆分配开销，用std::array则需要返回固定大小（即使实际元素更少）。std::inplace_vector可以返回实际大小的元素，且内存分配在栈上，返回时移动开销极低。

#include <inplace_vector>

// 查找一个数的最小4个质因数（上限明确为4）
std::inplace_vector<int, 4> find_smallest_prime_factors(int num) {
    std::inplace_vector<int, 4> factors;
    if (num % 2 == 0) { factors.push_back(2); num /= 2; }
    if (num % 3 == 0) { factors.push_back(3); num /= 3; }
    if (num % 5 == 0) { factors.push_back(5); num /= 5; }
    if (num % 7 == 0) { factors.push_back(7); num /= 7; }
    // 最多返回4个元素，无堆分配
    return factors;
}

int main() {
    auto factors = find_smallest_prime_factors(105);
    // factors.size()为3，存储2、3、5
}

4. 要求内存占用明确的结构体/内存池场景 #

std::vector的小对象优化（SSO）是编译器实现定义的，内存占用不确定；而std::inplace_vector的容量是编译期明确的，适合用于需要固定内存大小的结构体或内存池场景。

#include <inplace_vector>
#include <string>

// 固定大小的日志条目结构体，适合存入内存池或固定缓冲区
struct LogEntry {
    uint32_t log_level;
    uint64_t timestamp;
    // 明确占用sizeof(std::inplace_vector<std::string, 5>)的内存，无堆分配（除非字符串本身超过SSO）
    std::inplace_vector<std::string, 5> log_args;
};

// 可以安全地预分配一批LogEntry到内存池中，内存大小完全可控

内容的提问来源于stack exchange，提问作者The Mad Gamer