Question

我对std::remove_if函数有一点疑问。我的程序中某处有内存泄漏，我怀疑erase函数会以某种方式被破坏。

实际上，我的代码中有这个

std::vector<Object*> v; // Just the constructor to show you
v.erase(std::remove_if(begin(v), end(v), [Foo f](Object *o){
    return o->containsFoo(f);
}), end(v));

但经过一些研究，这比以前更好吗？

v.erase(std::remove_if(begin(v), end(v), [Foo f](Object *o){
   if(o->containsFoo(f)) {
     delete o;
     return true; 
   }
   return false;
}), end(v));

或者我应该使用其他东西吗？

Answer 1

你真的应该使用智能指针而不是裸Object* -

std::vector<std::unique_ptr<int>>

或

std::vector<std::shared_ptr<int>>

取决于哪个。如果你使用裸C风格的指针，那么很容易错过关键的delete（或delete两次）。

尽管如此，很容易看到一种方法泄漏而另一种方法没有泄漏：

#include <algorithm>
#include <vector>

int main(int argc, char **)
{
    std::vector<int*> v{ new int(1), new int(-1) };

    if (argc < 2) {
        // First version
        v.erase(std::remove_if(begin(v), end(v),
                               [](int *o){
                                   return *o < 0;
                               }),
                end(v));
    } else {
        // Second version
        v.erase(std::remove_if(begin(v), end(v),
                               [](int *o){
                                   if (*o < 0) {
                                       delete o;
                                       return true;
                                   }
                                   return false;
                               }),
                end(v));
    }

    // normal cleanup
    for (int *p: v)
        delete p;

}

我在没有参数（调用第一个版本）然后使用参数（调用第二个版本）的情况下运行它。看看会发生什么：

g++ -std=c++11 -g -Wall -Wextra 34191606.cpp -o 34191606

valgrind --leak-check=full ./34191606
==16894== HEAP SUMMARY:
==16894==     in use at exit: 72,708 bytes in 2 blocks
==16894==   total heap usage: 4 allocs, 2 frees, 72,728 bytes allocated
==16894== 
==16894== 4 bytes in 1 blocks are definitely lost in loss record 1 of 2
==16894==    at 0x4C2B0E0: operator new(unsigned long) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==16894==    by 0x400881: main (34191606.cpp:6)
==16894== 
==16894== LEAK SUMMARY:
==16894==    definitely lost: 4 bytes in 1 blocks
==16894==    indirectly lost: 0 bytes in 0 blocks
==16894==      possibly lost: 0 bytes in 0 blocks
==16894==    still reachable: 72,704 bytes in 1 blocks
==16894==         suppressed: 0 bytes in 0 blocks
==16894== Reachable blocks (those to which a pointer was found) are not shown.
==16894== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)

valgrind --leak-check=full ./34191606 -
==16895== HEAP SUMMARY:
==16895==     in use at exit: 72,704 bytes in 1 blocks
==16895==   total heap usage: 4 allocs, 3 frees, 72,728 bytes allocated
==16895== 
==16895== LEAK SUMMARY:
==16895==    definitely lost: 0 bytes in 0 blocks
==16895==    indirectly lost: 0 bytes in 0 blocks
==16895==      possibly lost: 0 bytes in 0 blocks
==16895==    still reachable: 72,704 bytes in 1 blocks
==16895==         suppressed: 0 bytes in 0 blocks
==16895== Reachable blocks (those to which a pointer was found) are not shown.
==16895== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

请注意，在第一个版本中，您永远不会删除从向量中删除其指针的对象，并且该对象报告为泄露。在第二个版本中，没有泄露的内存。

Answer 2

lambda 更好，但如果我是你（并且由于某些原因你不准备使用std::unique_ptr），我会这样做：

const auto predicate = [Foo f](Object *o){return !o->containsFoo(f);};
const auto new_end = std::partition(begin(v), end(v), predicate);
std::for_each(new_end, end(v), [](Object *o){delete o;});
v.erase(new_end,end(v));

换句话说：

使用 ~~remove_if~~ partition将不需要的指针随机播放到最后
使用for_each删除所有不需要的对象
使用erase删除（现在无效的）不需要的指针。

关键是，当事物被移动时删除指针是毛茸茸的。

在充满指针的std :: vector上使用std :: remove_if

2 个答案: