C++20中带外部容器捕获的Lambda作为Set比较器的编译问题

你的问题核心在于带捕获的Lambda闭包没有默认构造函数，而std::set的默认构造要求比较器类型可默认构造；同时模板参数需要类型而非变量。以下是三种可行的实现方案：

方案一：自定义比较器类（推荐） #

通过自定义类持有外部容器的指针，既满足std::set的默认构造要求，又能安全访问外部容器。

代码示例 #

#include <vector>
#include <set>
#include <unordered_map>
#include <string>
#include <algorithm>
#include <stdexcept>

class WordOrderComparator {
private:
    const std::vector<std::string>* words_ptr = nullptr;
    // 可选：预存索引映射提升性能
    std::unordered_map<std::string, size_t> word_index;

public:
    // 默认构造函数，满足std::set默认构造需求
    WordOrderComparator() = default;

    // 带容器指针的构造函数，同时预建索引映射
    explicit WordOrderComparator(const std::vector<std::string>* ptr) : words_ptr(ptr) {
        if (!ptr) throw std::invalid_argument("容器指针不能为空");
        for (size_t i = 0; i < ptr->size(); ++i) {
            word_index[(*ptr)[i]] = i;
        }
    }

    // 比较逻辑：按容器中的出现顺序排序
    bool operator()(const std::string& a, const std::string& b) const {
        if (!words_ptr) {
            return a < b; // 默认 fallback 逻辑，或抛出异常
        }
        auto it_a = word_index.find(a);
        auto it_b = word_index.find(b);
        if (it_a == word_index.end() || it_b == word_index.end()) {
            return a < b; // 不在容器中的元素按字典序排序
        }
        return it_a->second < it_b->second;
    }
};

int main() {
    std::vector<std::string> wordsContainer = {"apple", "banana", "cherry", "date"};

    // 定义unordered_map，value为带自定义比较器的set
    std::unordered_map<int, std::set<std::string, WordOrderComparator>> my_map;

    // 插入时传入初始化好的比较器
    my_map.emplace(1, std::set<std::string, WordOrderComparator>(WordOrderComparator(&wordsContainer)));

    // 向set中添加元素
    my_map.at(1).insert("banana");
    my_map.at(1).insert("apple");
    my_map.at(1).insert("date");

    // 输出顺序：apple banana date
    for (const auto& s : my_map.at(1)) {
        std::cout << s << " ";
    }
    return 0;
}

关键说明 #

• 比较器类提供默认构造函数，满足std::set默认构造的要求；
• 用指针而非引用持有外部容器，避免引用无法默认初始化的问题；
• 预建索引映射将std::find的O(n)性能优化为O(1)。

方案二：用std::function包装Lambda #

将带捕获的Lambda包装为std::function，利用其可默认构造的特性满足std::set的要求。

代码示例 #

#include <vector>
#include <set>
#include <unordered_map>
#include <string>
#include <functional>
#include <algorithm>

int main() {
    std::vector<std::string> wordsContainer = {"apple", "banana", "cherry", "date"};

    // 预建索引映射提升性能
    std::unordered_map<std::string, size_t> word_index;
    for (size_t i = 0; i < wordsContainer.size(); ++i) {
        word_index[wordsContainer[i]] = i;
    }

    // 用std::function包装带捕获的Lambda
    using Comparator = std::function<bool(const std::string&, const std::string&)>;
    auto cmp = [&word_index](const std::string& a, const std::string& b) {
        auto it_a = word_index.find(a);
        auto it_b = word_index.find(b);
        if (it_a == word_index.end() || it_b == word_index.end()) {
            return a < b;
        }
        return it_a->second < it_b->second;
    };

    // 定义unordered_map
    std::unordered_map<int, std::set<std::string, Comparator>> my_map;

    // 插入时传入包装后的比较器
    my_map.emplace(1, std::set<std::string, Comparator>(cmp));

    // 操作set
    my_map.at(1).insert("banana");
    my_map.at(1).insert("apple");
    my_map.at(1).insert("date");

    for (const auto& s : my_map.at(1)) {
        std::cout << s << " ";
    }
    return 0;
}

关键说明 #

• std::function是类型擦除的包装器，支持默认构造（默认状态为空，调用会抛出std::bad_function_call）；
• 避免使用my_map[key]（会默认构造空set），改用emplace或at操作。

方案三：用unique_ptr包装set #

直接使用带捕获的Lambda类型作为比较器，将std::set放入unique_ptr中，绕开set默认构造的要求。

代码示例 #

#include <vector>
#include <set>
#include <unordered_map>
#include <string>
#include <memory>
#include <algorithm>

int main() {
    std::vector<std::string> wordsContainer = {"apple", "banana", "cherry", "date"};

    std::unordered_map<std::string, size_t> word_index;
    for (size_t i = 0; i < wordsContainer.size(); ++i) {
        word_index[wordsContainer[i]] = i;
    }

    // 带捕获的Lambda
    auto cmp = [&word_index](const std::string& a, const std::string& b) {
        auto it_a = word_index.find(a);
        auto it_b = word_index.find(b);
        if (it_a == word_index.end() || it_b == word_index.end()) {
            return a < b;
        }
        return it_a->second < it_b->second;
    };

    // unordered_map的value为unique_ptr<set>
    std::unordered_map<int, std::unique_ptr<std::set<std::string, decltype(cmp)>>> my_map;

    // 构造set并插入到map中
    my_map[1] = std::make_unique<std::set<std::string, decltype(cmp)>>(cmp);

    // 操作set
    my_map[1]->insert("banana");
    my_map[1]->insert("apple");
    my_map[1]->insert("date");

    for (const auto& s : *my_map[1]) {
        std::cout << s << " ";
    }
    return 0;
}

关键说明 #

• 带捕获的Lambda闭包类型无默认构造函数，因此不能直接用std::set作为value类型；
• 用unique_ptr持有set，构造时传入Lambda实例，绕开默认构造的要求；
• 需确保外部容器（wordsContainer/word_index）的生命周期长于所有set对象，避免悬空引用。

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