C++ 比较向量中元素的最有效和最快速的方法？

使用两个迭代器比较类向量中的元素最有效、最快的方法是什么？该向量不是可排序的，我为该类提供了一个重载“>”运算符。我使用boostforeach进行简单的向量迭代

我正在做与下面给出的类似的事情

vector<TestClass*> vec; 
vector<TestClass*>::iterator jIter;     
bool isErased=false;
vector<TestClass*>::iterator iIter = vec.begin();
if(!vec.empty()){
    while(iIter < vec.end()-1) {            
        isErased = false;
        for (jIter = iIter+1; jIter < vec.end();jIter++) {          
            if((*(*iIter))<=(*(*jIter))) {
                delete *jIter;
                jIter = vec.erase(jIter);               
                jIter--;
            }               
            else if((*(*iIter))>=(*(*jIter))) {                 
                delete *iIter;
                iIter = vec.erase(iIter);
                isErased = true;
                break;
            }               
        }
        if(!isErased) iIter++;
    }               

vec；
向量：：迭代器jIter；
bool-isErased=false；
向量：：迭代器iIter=vec.begin（）；
如果（！vec.empty（））{
而（iIter

---

谢谢。

未经测试，但类似于此

 for(auto it=vec.begin(), end=vec.end(); it!=end; ++it) {
   const auto&& val=*it;
   std::size_t count=0u;
   end=std::remove_if(
       it, end,
       [&](const TestClass& tc) -> bool {
           if(tc==val) ++count;
           return (count > 1);
       }
   );
 }
 vec.erase(end, vec.end());

---

最棘手的部分是避免遇到无效迭代器：

v.erase(std::remove_if(v.begin(), v.end(), [j](T const &i) { return i > j; });

您也可以使用循环，但在这种情况下使用反向迭代器

附言：我不知道你到底想在你的算法中实现什么

你可能会对我感兴趣

---

这段代码应该做什么？如果我不得不猜测的话，我会说OP是在尝试查看向量中的每个元素是否与任何其他元素匹配，并删除那些只存在一次的元素。最有效和最快的方法就是不要这样做。如果你使用向量做得慢，不要使用向量。至于找到最大元素数组的nt，使用std:：max_元素（vec.begin（），vec.end（））；我不明白为什么这个问题会吸引更多的选票，因为目前的形式无法准确确定OP希望实现的目标。为什么它不可排序？为什么要使用

向量
？如果你想要唯一性，那么你应该使用提供它的容器（比如
set
或
map
，或者至少是一个排序的
向量
@111111，我澄清了我对算法要求的不理解。据我所知，这在各个方面也与OP的示例所做的不同。（我不怪你，我真的无法理解它试图实现的目标）@sehe，哈哈，据我所知，他想删除重复的内容，而不排序容器，我不知道为什么他不能排序，因为他可以变异它。（注意，我只是做了一些编辑，这更有意义）。