在 std::set 或 std::unordered_set 上保留插入顺序

Question

在将此标记为重复之前，我一直是here、here 和here, a duplicate of the first。

我知道boost::multi_index，并使用我缺少它的环境，并且std::unordered_set 不一定以确定性插入顺序存储元素。

我发现使用两个容器的概念，说一个额外的std::vector 不礼貌。

我喜欢是一个涉及比较器的解决方案，我可以在std::set 的模板参数中使用它（澄清一下，这可能是一个简单的函子结构，包含bool operator()() 重载、常规函数或 lambda）。有可能吗？

附录

1. 必须通过 std:: 容器的开始迭代器/结束迭代器构造函数进行初始化，例如在这个 sn-p 中。

   std::string str; cin >> str;
   std::set<char>(str.begin(), str.end());
   

2. 另外，另一个有趣的用例是创建一个哑哈希包装函子，允许将插入顺序推入std::unordered_set 的模板参数。

Answer 1

您不能直接将 lambda 表达式作为集合的模板参数，因为 lambda 表达式是一个值，而集合的模板参数是一个类型。对问题的明显更正，即使用 lambda 和 decltype 的构造是否可以工作，导致了一个有趣的问题，即 lambda 表达式表示 unique 类型（“闭包类型”），所以你永远不能创建相同闭包类型的两个单独的 lambda 表达式。*

但是，在更抽象的意义上，您可以使用模板参数推导在本地上下文中实现您想要的，例如：

template <typename F>
int f(int* first, int* last, F comp)
{
    std::set<int, F> s(comp);
    while (first != last) s.insert(*first++);
    ...
}

现在您可以使用 lambda 表达式作为参数调用 f，从而有效地“使用 lambda 作为集合的比较器”。或者，对于一个更简单的示例，您可以只为 lambda 指定一个命名变量（将所有模板推导放入单个 auto：

auto comp = [](...) { ... };
std::set<int, decltype(comp)> s(comp);

_{*) 有一个提议允许在未评估的上下文中使用 lambdas 来解决这一点，但其前景尚不确定。它有一些有趣的副作用，比如让闭包类型影响名称修改。}

Answer 2

保留插入顺序的 adt 是 std::vector。 您可以像这样轻松地包装它以获得类似 std::set 的行为：

#include <iostream>
#include <vector>
#include <utility>
#include <algorithm>

using namespace std;

template < typename T >
class VectorSet : public vector<T> {
public:
    using iterator = typename vector<T>::iterator;
    using value_type = typename vector<T>::value_type;

    pair<iterator, bool> insert (const value_type& val) {
        auto it = ::find(this->begin(), this->end(), val);
        if (it == this->end())
            it = ::vector<T>::insert(this->end(), val);

        return pair<iterator, bool>(it, true);
    }
};

int main()
{
    VectorSet<int> my;
    my.insert(1);
    my.insert(4);
    my.insert(3);
    my.insert(4);

    for (auto & v : my) {
        cout << v << endl;
    }

    return 0;
}

Answer 3

你不能，除非你使用额外的索引。两种方法：

1。使用显式索引

Live On Coliru

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

using namespace std;

#include <iostream>

string read_word() {
    string str;
    cin >> str;
    return str;
}

int main() {
    using Ref = std::reference_wrapper<char const>;

    auto const str = read_word();
    std::cout << "Word: "   << str << "\n";

    auto v = [&]() -> vector<Ref> {
        set<Ref> u(str.begin(), str.end());
        return {u.begin(), u.end()};
    }();

    std::cout << "Unique: " << string(v.begin(), v.end()) << "\n";

    auto pos = [str](char ch) { return str.find(ch); };
    std::sort(v.begin(), v.end(), [pos](auto& a, auto& b) { return pos(a) < pos(b); });

    std::cout << "Insertion: " << string(v.begin(), v.end()) << "\n";
}

打印例如

Word: pineapple
Unique: aeilnp
Insertion: pineal

2。使用 Boost 多索引

同样的交易

Live On Coliru

#include <boost/multi_index_container.hpp>
#include <boost/multi_index/sequenced_index.hpp>
#include <boost/multi_index/ordered_index.hpp>

namespace bmi = boost::multi_index; 

using Index = bmi::multi_index_container<char, 
      bmi::indexed_by<
          bmi::sequenced<>,
          bmi::ordered_unique<bmi::tag<struct unique>, bmi::identity<char> >
      > > ;

#include <iostream>

std::string read_word() {
    std::string str;
    std::cin >> str;
    return str;
}

int main() {

    auto const str = read_word();
    std::cout << "Word: "   << str << "\n";

    Index idx(str.begin(), str.end());

    std::cout << "Insertion: " << std::string(idx.begin(), idx.end()) << "\n";

    auto& u = idx.get<unique>();
    std::cout << "Unique: " << std::string(u.begin(), u.end()) << "\n";
}

打印

Word: pineapple
Insertion: pineal
Unique: aeilnp

Answer 4

我认为一个奇怪的解决方案（虽然不涉及任何集合）可能是使用元素类型的std::map 和std::time_point 作为键类型。如果根本没有任何东西，这将确保插入顺序。