如何向Lambda表达式传递向量列表？编译报错排查

代码示例 #

#include <iostream>
#include <vector>

struct data_t {
    int data;
    int some_other_data;
};

auto main() -> int {
    std::vector<data_t> v1 = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}};
    std::vector<data_t> v2 = {{6, 6}, {7, 7}, {8, 8}, {9, 9}, {10, 10}};

    const auto update_vectors = [&](auto& v, const auto& c, const auto pop) {
        for (auto& i : v) {
            if (pop) i.pop_back();
            i.push_back(c);
        }
    };

    auto d = data_t{11, 11};
    update_vectors({v1, v2}, d, true);

    return 0;
}

编译错误信息 #

error: no match for call to '(const main()::<lambda(const auto:1&, const auto:2&, auto:3)>) (<brace-enclosed initializer list>, data_t&, bool)'
   23 |     update_vectors({v1, v2}, d, true);
      |     ~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~

错误原因 #

Lambda的第一个参数是auto& v，但你传递的{v1, v2}是花括号初始化列表，C++无法自动推导这个列表的具体类型来匹配左值引用参数。花括号列表本身不是完整的对象类型，不能直接绑定到非const左值引用；同时std::initializer_list的元素是const属性，无法满足后续修改向量（pop_back/push_back）的需求。

解决方案 #

方案1：显式构造包含向量引用的容器 #

构造持有向量引用的容器，避免拷贝向量：

#include <iostream>
#include <vector>
#include <functional> // 引入std::reference_wrapper

struct data_t {
    int data;
    int some_other_data;
};

auto main() -> int {
    std::vector<data_t> v1 = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}};
    std::vector<data_t> v2 = {{6, 6}, {7, 7}, {8, 8}, {9, 9}, {10, 10}};

    const auto update_vectors = [&](auto& v, const auto& c, const auto pop) {
        for (auto& vec : v) {
            if (pop) vec.pop_back();
            vec.push_back(c);
        }
    };

    auto d = data_t{11, 11};
    update_vectors(std::vector<std::reference_wrapper<std::vector<data_t>>>{v1, v2}, d, true);

    return 0;
}

方案2：改用可变参数Lambda（推荐） #

修改Lambda为接受可变数量的向量参数，直接批量处理，无需额外构造容器：

#include <iostream>
#include <vector>

struct data_t {
    int data;
    int some_other_data;
};

auto main() -> int {
    std::vector<data_t> v1 = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}};
    std::vector<data_t> v2 = {{6, 6}, {7, 7}, {8, 8}, {9, 9}, {10, 10}};

    // 可变参数Lambda，支持任意数量的向量引用
    const auto update_vectors = [&](const auto& c, bool pop, auto&... vs) {
        // 单个向量的更新逻辑
        auto update_single = [&](auto& vec) {
            if (pop) vec.pop_back();
            vec.push_back(c);
        };
        // 折叠表达式遍历所有传入的向量
        (update_single(vs), ...);
    };

    auto d = data_t{11, 11};
    update_vectors(d, true, v1, v2);

    return 0;
}

说明 #

方案2是C++17及以后的现代写法，支持传递任意数量的向量，代码简洁高效，无额外容器开销，是优先推荐的解决方式。

内容的提问来源于stack exchange，提问作者Andrew