对填充了指针的std::向量使用std:remove_if

Use std::remove_if on a std::vector filled with pointers

本文关键字：std remove if 指针 填充 向量      更新时间：2023-10-16

我对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));

或者我应该用别的东西吗？

您确实应该使用智能指针，而不是裸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)

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

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));

换句话说：

  1. 使用
    2. remove_ifpartition将不需要的指针拖到末尾
  2. 使用for_each删除所有不需要的对象
  3. 使用erase来清除（现在无效的）不需要的指针

关键是，在事物移动时删除指针是很麻烦的。

相关文章：