Question

我试图在矢量上做一些操作。并且只在某些情况下在矢量上要求擦除。

这是我的代码

while(myQueue.size() != 1)
{
    vector<pair<int,int>>::iterator itr = myQueue.begin();
    while(itr != myQueue.end())
    {
        if(itr->first%2 != 0)
            myQueue.erase(itr);
        else
        {
            itr->second = itr->second/2;
            itr++;
        }
    }
}

我要在第二个迭代中坠毁。而我要得到这个与信息矢量传动器不兼容的坠毁。

坠机的原因何在?

Answer 1

如果 erase () 被称作“ 迭代器”, 则无效, 然后在循环的下一个迭代时访问迭代器。 < a href=" http:// en. cppreference.com/w/ cpp/container/ vector/ erase" code>std::: vector::: 返回被擦除的迭代器之后的下一个迭代器 :

itr = myQueue.erase(itr);

Answer 2

在 [b、e) _B/code>是源头的 _B/code> /code>是源头,而是矢量范围的尽头,如果在范围中某处的代言 < > > 上进行清除操作,那么从到 e 的所有代言都将无效。因此,在调 erase 时,你需要非常小心。 s>成员会返回新的代言人,您可以用于以后的操作,你应该使用:

itr = myQueue.erase( itr ); 另一种方式是交换 > i 元素和最后一个元素,然后删除最后一个元素。这样效率更高,因为需要减少 i 以外的元素移动次数。 myQueue.swap( i, myQueue.back() ); myQueue.pop_back(); 而且,从它的外观来看,你为什么使用 victor ? 如果您需要 queue ,你也可以使用 std::queue 。

Answer 3

这是未定义的行为。特别是, 一旦你删除了一个迭代器, 它就会变成无效, 你不能再用它来做任何事情。解开循环的特异方式会像 :

for ( auto it = v.begin(); it != v.end(); ) {
   if ( it->first % 2 != 0 )
      it = v.erase(it);
   else {
      it->second /= 2;
      ++it;
   }
}

但同样,不滚动你自己的循环,而是使用算法,将更有效率,更有才华:

v.erase( std::remove_if( v.begin(),
                         v.end(),
                         []( std::pair<int,int> const & p ) {
                             return p.first % 2 != 0;
                       }),
         v.end() );
std::transform( v.begin(), v.end(), v.begin(), 
                []( std::pair<int,int> const & p ) {
                    return std::make_pair(p.first, p.second/2);
                } );

这种方法的优点是,删除时元素的复制件数量较少(在范围中留下的每个有效元素只复制一次),而且更难弄错(即滥用无效的迭代器.) 缺点在于没有 remove_if_and_transform ,所以这是一个两种通算法,如果有大量元素,这个算法可能效率较低。

Answer 4


在改变循环的同时进行迭接通常很困难。

因此,有一个特定的 C++ 语系可用于非联合序列: 擦去- 移动音系。

它将使用 remove_if  算法与 erase  方法的范围超载结合起来:

myQueue.erase(
    std::remove_if(myQueue.begin(), myQueue.end(), /* predicate */),
    myQueue.end());


以典型的授粉对象表示或使用新的C++11 羊羔语法表示上游。

// Functor
struct OddKey {
    bool operator()(std::pair<int, int> const& p) const {
        return p.first % 2 != 0;
    }
};

/* predicate */ = OddKey()

// Lambda
/* predicate */ = [](std::pair<int, int> const& p) { return p.first % 2 != 0; }


羊羔形式更简洁,但可能少一些自制文件(无名),并且只有C++11版。根据你的口味和限制,请选择最适合你的文件。



可以提升你的写法:使用Boost.Range 。

typedef std::vector< std::pair<int, int> > PairVector;

void pass(PairVector& pv) {
    auto const filter = [](std::pair<int, int> const& p) {
        return p.first % 2 != 0;
    };
    auto const transformer = [](std::pair<int, int> const& p) {
        return std::make_pair(p.first, p.second / 2);
    };

    pv.erase(
        boost::transform(pv | boost::adaptors::filtered( filter ),
                         std::back_inserter(pv),
                         transformer),
        pv.end()
    );
}

http://www.boost.org/doc/libs/1_49_0/libs/range/doc/range/doc/range/range/refer/algorithms/mutate/transform.html" rel=“nofolpt”_code> transform 和code> filtered accessor ,以及许多其他文件。

友情链接