如何返回包含不在集合中的元素的向量的副本？

Question

假设我有以下两种数据结构：

std::vector<int> all_items;
std::set<int> bad_items;

all_items 向量包含所有已知项目，bad_items 向量包含一个坏项目列表。这两种数据结构完全相互独立地填充。

编写一个返回std::vector<int> 的方法的正确方法是什么，该方法包含all_items 的所有元素，而不是bad_items？

目前，我有一个笨拙的解决方案，我认为可以更简洁地完成。我缺乏对 STL 函数适配器的理解。因此问题。我目前的解决方案是：

struct is_item_bad {
    std::set<int> const* bad_items;
    bool operator() (int const i) const {
        return bad_items.count(i) > 0;
    }
};

std::vector<int> items() const {
    is_item_bad iib = { &bad_items; };
    std::vector<int> good_items(all_items.size());
    std::remove_copy_if(all_items.begin(),  all_items.end(), 
                        good_items.begin(), is_item_bad);
    return good_items; 
}

假设all_items、bad_items、is_item_bad 和items() 都是某些包含类的一部分。有没有办法写items() getter 这样：

• 方法中不需要临时变量？
• 不需要自定义函子struct is_item_bad?

我曾希望只使用std::set 上的count 方法作为函子，但我无法用remove_copy_if 算法预测正确的表达方式。

编辑： 修复了items() 中的逻辑错误。实际代码没有问题，是转录错误。

编辑：我接受了一个不使用std::set_difference 的解决方案，因为它更通用，即使std::vector 未排序也可以工作。我选择在我的代码中使用 C++0x lambda 表达式语法。我的最终items() 方法如下所示：

std::vector<int> items() const {
    std::vector<int> good_items;
    good_items.reserve(all_items.size());
    std::remove_copy_if(all_items.begin(), all_items.end(),
                        std::back_inserter(good_items),
                        [&bad_items] (int const i) {
                            return bad_items.count(i) == 1;
                        });
}

在大约 800 万个项目的向量上，上述方法在 3.1 秒内运行。我在工作台上标记了std::set_difference 方法，它运行了大约 2.1 秒。感谢所有提供出色答案的人。

Answer 1

正如 jeffamaphone 所建议的，如果您可以对任何输入向量进行排序，则可以使用std::set_difference，这样既高效又减少了代码：

#include <algorithm>
#include <set>
#include <vector>

std::vector<int> 
get_good_items( std::vector<int> const & all_items,
                std::set<int> const & bad_items )
{
    std::vector<int> good_items;

    // Assumes all_items is sorted.
    std::set_difference( all_items.begin(),
                         all_items.end(),
                         bad_items.begin(),
                         bad_items.end(),
                         std::back_inserter( good_items ) );

    return good_items;
}

Answer 2

由于您的函数将返回一个向量，因此无论如何您都必须创建一个新向量（即复制元素）。在这种情况下，std::remove_copy_if 没问题，但你应该正确使用它：

#include <iostream>
#include <vector>
#include <set>
#include <iterator>
#include <algorithm>
#include <functional>
std::vector<int> filter(const std::vector<int>& all, const std::set<int>& bad)
{
        std::vector<int> result;
        remove_copy_if(all.begin(), all.end(), back_inserter(result),
                  [&bad](int i){return bad.count(i)==1;});
        return result;
}

int main()
{
        std::vector<int> all_items = {4,5,2,3,4,8,7,56,4,2,2,2,3};
        std::set<int> bad_items = {2,8,4};
        std::vector<int> filtered_items = filter(all_items, bad_items);
        copy(filtered_items.begin(), filtered_items.end(), std::ostream_iterator<int>(std::cout, " "));
        std::cout << std::endl;
}

要在 C++98 中执行此操作，我想您可以使用 mem_fun_ref 和 bind1st 将 set::count 转为内联函子，但这样做存在问题（导致 bind1st 被弃用在 C++0x 中）这意味着取决于您的编译器，您最终可能会使用 std::tr1::bind ：

remove_copy_if(all.begin(), all.end(), back_inserter(result),
     bind(&std::set<int>::count, bad, std::tr1::placeholders::_1)); // or std::placeholders in C++0x

在任何情况下，我认为显式函数对象会更具可读性：

struct IsMemberOf {
        const std::set<int>& bad;
        IsMemberOf(const std::set<int>& b) : bad(b) {}
        bool operator()(int i) const { return bad.count(i)==1;}
};
std::vector<int> filter(const std::vector<int>& all, const std::set<int>& bad)
{
        std::vector<int> result;
        remove_copy_if(all.begin(), all.end(), back_inserter(result), IsMemberOf(bad));
        return result;
}

Answer 3

冒着显得过时的风险：

std::set<int> badItems;
std::vector<int> items;
std::vector<int> goodItems;
for ( std::vector<int>::iterator iter = items.begin();
      iter != items.end();
      ++iter)
{
   int& item = *iter;
   if ( badItems.find(item) == badItems.end() )
   {
      goodItems.push_back(item);
   }
}

Answer 4

std::remove_copy_if 返回一个指向目标集合的迭代器。在这种情况下，它将返回good_items.end()（或类似的东西）。 good_items 在方法结束时超出范围，因此会导致一些内存错误。您应该返回good_items 或通过引用传入new vector<int>，然后clear、resize 并填充它。这将摆脱临时变量。

我相信您必须定义自定义仿函数，因为该方法取决于对象 bad_items，如果没有它获得 hackey AFAIK，您将无法指定该对象。