C+ 自定义迭代器？答案

【问题标题】：C+ custom iterator?C+ 自定义迭代器？
【发布时间】：2015-11-19 01:47:22
【问题描述】：

我一直在尝试为一个简单的类实现自定义前向迭代器。这个类是固定数组的一个非常糟糕的抽象（不幸的是我无法更改它）。元素只能通过索引访问。

template <class T>
struct data
{
    static const size_t MAX_BUFFER{ 50 };
    T* buffer_[MAX_BUFFER] = {};
    int currpos_ = 0;

    void insert(T *value) {
        if (currpos_ < MAX_BUFFER-1)
            buffer_[currpos_++] = value;
    }

    T** at(int i) {
        if (i >= currpos_)
            return NULL;
        return &buffer_[i];
    }

    ~data() {
        for (int i=0; i<currpos_; ++i)
            delete buffer_[i];
    }

    int entries() const { return currpos_; }

    struct iterator : std::iterator<std::forward_iterator_tag, T*>
    {
        using reference = typename std::iterator<std::forward_iterator_tag, T*>::reference;
        using pointer = typename std::iterator<std::forward_iterator_tag, T*>::pointer;

        iterator(data<T> *d, int start) : p{ d }, index{ start } {}
        iterator operator++() { if (index < p->entries()) ++index; return *this; }
        friend bool operator==(const iterator &d1, const iterator &d2) { return d1.p == d2.p && d1.index == d2.index; }
        friend bool operator!=(const iterator &d1, const iterator &d2) { return !(d1== d2); }
        reference operator*() { return *(p->at(index)); }
        pointer operator->() { return p->at(index); }
        data<T> *p;
        int index;
    };

    iterator begin() { return iterator(this, 0); }
    iterator end() { return iterator(this, entries()); }
};

我面临的问题是，通过这个接口，我可以使用大多数 STL 标准算法，如 for_each、transform、find_if。例如，假设 d 已经用 new{2}、new{3}、new{4}、new{14}、new{-4}、new{-44}、new{42} 初始化此代码

for (auto &i : d) std::cout <<*i <<" "; std::cout <<std::endl;

auto res=std::find_if(d.begin(), d.end(), [](auto &i) { return *i == -44;});
if (res != d.end())
    std::cout <<**res <<std::endl;

std::transform(d.begin(), d.end(), d.begin(), [](auto &i) {*i *= 2; return i;});
for (auto &i : d) std::cout <<*i <<" "; std::cout <<std::endl;

会正确显示

2 3 4 14 -4 -44 42
-44
4 6 8 28 -8 -88 84

我面临的问题是算法 std::remove_if() 及其排列元素的方式。我添加了一个类似于vector::erase的成员函数：

void remove_range(iterator begin, iterator end)
{
    size_t d=std::distance(begin, end);
    currpos_ -= d;
}

当然也应该删除与已删除元素相关的内存。在这个例子中调用它时：

auto new_end = std::remove_if(d.begin(), d.end(), [](auto &r) { return *r > 3; });
d.remove_range(new_end, d.end());

valdring 一直告诉我我有 3 个内存泄漏（这是有道理的：有 3 个元素 >= 3）。我试图在 remove_range() 中添加一个删除操作，但是这个解决方案不起作用（程序崩溃）。在调试会话期间，我打印出 d 的内部状态：

(gdb) p d
$1 = {static MAX_BUFFER = <optimized out>, buffer_ = {0x603010, 0x603030, 0x603050, 0x603070, 0x603090, 0x6030b0, 0x6030d0, 0x0 <repeats 43 times>}, currpos_ = 7}
(gdb) p d
$2 = {static MAX_BUFFER = <optimized out>, buffer_ = {0x603010, 0x603030, 0x603090, 0x6030b0, 0x603090, 0x6030b0, 0x6030d0, 0x0 <repeats 43 times>}, currpos_ = 7}

我可以看到 remove_if() 基本上移动了三个元素（那些 > 3 的元素），我认为我有泄漏的原因是因为元素 - 应该被删除 - 被移动了，所以原始指针永远泄露了。

我的问题是：有什么办法可以避免这种泄漏吗？我需要定义一些额外的移动构造函数吗？

【问题讨论】：

您能否提供一个最小的可编译示例，以尽可能少的代码行来演示该问题？否则很难为您提供帮助。
我建议不要碰这门课。如果您必须拥有它，请编写与 std::vector 之间的转换函数，并且仅在绝对必要时才将此类用作这些函数之一的参数。这可以为您节省不少麻烦。
你能用unique_ptr代替原始指针（unique_ptr<T> buffer_[MAX_BUFFER];）吗？
这可能是最好的解决方案。不幸的是，那里的代码是遗留代码，无法更改:(

标签： c++ stl iterator

【解决方案1】：

我想我终于找到了一个至少对我来说是有意义的答案。这取自 http://en.cppreference.com/w/cpp/algorithm/remove 并显示了 std::remove_if 的可能实现。

template< class ForwardIt, class T >
ForwardIt remove(ForwardIt first, ForwardIt last, const T& value)
{
    first = std::find(first, last, value);
    if (first != last)
        for(ForwardIt i = first; ++i != last; )
            if (!(*i == value))
                *first++ = std::move(*i);
    return first;
}

我的代码有泄漏的原因是因为

*first++ = std::move(*i).

我发现问题的唯一解决方案是

使用在调用 std::move() 之前删除元素的 std::remove_if() 版本。在我的示例中，我只需要更改
```
auto new_end = std::remove_if(d.begin(), d.end(), [](auto &r) { return (*r > 3); });
```

进入（使用相同的 remove_range 实现）

auto new_end = std::remove_if(d.begin(), d.end(), 
    [](auto &r) { 
        bool res = (*r > 3); 
        if (res) delete r; 
        return res; });

使用 std::partition() 并为需要删除的范围内的每个元素手动调用 delete（std::partition 使用 std::swap）

我用 std::vector 重现了完全相同的问题：

std::vector<int*> v{new int{1}, new int{3}, new int{-10}, new int{12}};
v.erase(std::remove_if(v.begin(), v.end(), [](auto &p) { return *p > 3;}));
for (auto &i : v)
    delete i;

【讨论】：

【解决方案2】：

remove_if 收集范围开头不应删除的所有元素。为此，它可以使用交换或移动。正如您的调试输出所示，它似乎使用了移动，这似乎与复制相同（这对于指针等简单数据结构是有意义的）。您的调试器输出显示：指针 0x603090 在您第二次打印时出现两次。因此，当您在 remove_if 之后调用 remove_range（并将 remove_range 修改为实际调用 delete）时，您对已复制到前面的指针值调用 delete，并且稍后您可能会再次调用 delete , 当你释放范围的前面部分时。

另一方面，一些被删除的指针值确实丢失了，因此您无法对它们调用 delete，从而导致 valgrind 中的内存泄漏。

最简单的解决方法可能是使用partition 而不是remove_if。

编辑： remove_if 稳定，partition 不稳定，所以这可能是个问题。还有stable_partition，但是需要双向迭代器，前向迭代器是不够的。也许你可以改变你的迭代器，使它们是双向的？

【讨论】：

这与我找到的解决方案完全相同。非常感谢！

【解决方案3】：

您看到的泄漏是由remove_range 实现引起的，而不是迭代器。

我添加了一个类似于vector::erase的成员函数... 这当然也应该删除与已删除元素相关的内存。

但事实并非如此。您在容器析构函数中的元素上调用delete，但在擦除方法中的项目没有delete。

【讨论】：