C++ 我想使用set删除重复的元素，并在插入时保持顺序

我想使用set删除重复的元素，同时保持它们的顺序。所以我尝试更改compare参数，让它们按照插入顺序排序

#include <set>
#include <iostream>
using namespace std;


template <class T>
struct compare
{
    bool operator() (T x, T y) 
    {
        return true;
    }
};

void main()
{
    set<int,compare<int>> one;

    one.insert(5);
    one.insert(3);
    one.insert(9);
    one.insert(1);
    one.insert(5);
    one.insert(5);
}

#包括
#包括
使用名称空间std；
模板
结构比较
{
布尔运算符（）（T x，T y）
{
返回true；
}
};
void main（）
{
设置一个；
一.插入（5）；
一.插入（3）；
一.插入（9）；
一.插入（1）；
一.插入（5）；
一.插入（5）；
}

---

IDE中的表达式是：invaild运算符依赖于比较器来维持严格的弱顺序，并确保每个值都是唯一的。不能按插入顺序对

std:：set

进行排序

#include <set>
#include <iostream>
using namespace std;


template <class T>
struct compare
{
    bool operator() (T x, T y) 
    {
        return true;
    }
};

void main()
{
    set<int,compare<int>> one;

    one.insert(5);
    one.insert(3);
    one.insert(9);
    one.insert(1);
    one.insert(5);
    one.insert(5);
}

一种可能的解决方案是使用两个容器，一个

std:：set

包含唯一元素，一个

std:：vector

索引保持插入顺序。向量可能在集合中包含迭代器

使用自己的迭代器将这两个容器封装在自己的类中可能比较方便。下面是一个简单的实现：

class MySetIterator {
  std::vector<std::set<int>::iterator>::iterator pos;
public:
  MySetIterator(std::vector<std::set<int>::iterator>::iterator pos) : pos(pos) {}
  int operator*() { return **pos; }
  MySetIterator& operator++() { ++pos; return *this; }
  bool operator!=(const MySetIterator& rhs) { return pos != rhs.pos; }    
};

class MySet {
 std::set<int> vals;
 std::vector<std::set<int>::iterator> order;
public:
  void insert(int val) { 
    auto ret = vals.insert(val);
    if (ret.second)
      order.push_back(ret.first);
  }
  MySetIterator begin() { return {order.begin()}; }
  MySetIterator end() { return {order.end()}; }    
};

int main() {
  MySet my_set;

  my_set.insert(5);
  my_set.insert(3);
  my_set.insert(9);
  my_set.insert(1);
  my_set.insert(5);
  my_set.insert(5);
  for (int val : my_set)
      std::cout << val << " ";
}

类MySetIterator{
std:：vector:：iterator pos；
公众：
MySetIterator（std:：vector:：iterator pos）：pos（pos）{}
int运算符*（）{return**pos；}
MySetIterator&operator++（）{++pos；返回*this；}
布尔运算符！=（const myseterator&rhs）{return pos！=rhs.pos；}
};
类MySet{
std：：设置VAL；
std：：向量顺序；
公众：
无效插入（int val）{
自动返回=val.insert（val）；
如果（返回秒）
订单。推回（返回优先）；
}
MySetIterator begin（）{return{order.begin（）}；}
MySetIterator end（）{return{order.end（）}；}
};
int main（）{
我的集我的集；
my_set.insert（5）；
my_set.insert（3）；
my_set.insert（9）；
my_set.insert（1）；
my_set.insert（5）；
my_set.insert（5）；
for（int val:my_set）
std:：cout其他可能的解决方案是使用boost:：multi_索引

#include <iostream>

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

namespace boost_mi = boost::multi_index;

typedef boost::multi_index_container<
    int,
    boost_mi::indexed_by<
        boost_mi::random_access<>, // preserves insertion order
        boost_mi::ordered_unique<boost_mi::identity<int> > // removes duplicates
    >
> MySet;

int main()
{
    MySet my_set;

    my_set.push_back(5);
    my_set.push_back(3);
    my_set.push_back(9);
    my_set.push_back(1);
    my_set.push_back(5);
    my_set.push_back(5);

    for (auto val : my_set) {
        std::cout << val << std::endl;
    }

    return 0;
}

#包括
#包括
#包括
#包括
名称空间boost\u mi=boost:：multi\u索引；
typedef boost:：多索引容器<
int，
boost_mi：：索引_by<
boost\u mi:：random\u access，//保留插入顺序
boost\u mi:：ordered\u unique//删除重复项
>
>迈塞特；
int main（）
{
我的集我的集；
我的套装。向后推（5）；
我的设置。向后推（3）；
我的套装。向后推（9）；
我的设置。向后推（1）；
我的套装。向后推（5）；
我的套装。向后推（5）；
用于（自动值：我的设置）{
std:：cout A
std:：set
已订购其项目，且不包含重复项。您无需“帮助”设置了这些问题中的任何一个。因此我猜
set
不是您应该使用的容器。您使用std:：set有什么原因吗？您想做什么？我知道里面没有重复项。我只希望所有元素都按照插入的顺序放置。例如，“5,3,6,7,1”已经一个接一个地插入到一个集合中，我希望它们在插入该集合后仍然保持相同的顺序，“5,3,6,7,1”。
std:：set
需要一个简单的弱顺序。插入顺序不能满足这一点。您的比较器肯定不能。