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

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}

型
我可以看到removed_if（）基本上移动了三个元素（> 3的元素），我认为我有泄漏的原因是因为应该被删除的元素被移动了，所以原始指针永远泄漏了。
我的问题是：有什么方法可以避免这种泄漏吗？我需要定义一些额外的移动构造函数吗？