创建和管理 STL 列表的子列表

Question

我有一个问题的解决方案，该解决方案涉及从 STL 项目列表创建项目的子列表（即子范围）。例如，我有一个整数列表，需要创建子列表，其中子列表是一个类，它代表原始列表中的一系列项目。所有范围都是不相交的，我需要对子列表执行操作（插入/删除），这些更改需要反映在原始列表中。

我想出了下面的实现，它使用 C++11。但是，我在删除子列表时遇到了麻烦。问题是子列表的 _end 迭代器指向下一个连续子列表的 _beg 指针。所以我的问题是：

1. 表示这种模式的常用方法是什么？即，管理列表的子列表，其中子列表中的修改反映在原始列表中。
2. 我怎样才能更正下面的代码并且仍然使用 ranged-for 成语？

在这个例子中，子列表没有做很多事情，但这只是一个例子。在原始问题中，这两个类将用于几个不同的任务。

感谢任何帮助。

#include <iostream>
#include <list>
#include <algorithm>
using namespace std;

typedef list<int>           i_list;
typedef list<int>::iterator it_list;

class Sublist {
private:
    string  _name;
    i_list* _items;
    it_list _beg;
    it_list _end;

public:
    Sublist(string name, i_list* items, it_list beg, it_list end) 
        :   _name(name), 
            _items(items),
            _beg(beg), 
            _end(end)
    { 
    }

    it_list begin() { 
        return this->_beg; 
    }

    it_list end() { 
        return this->_end; 
    }

    void erase(it_list it) {
        if (it == _beg) {
            _beg = _items->erase(it);
        }
        else if (it == _end) {
            _end = _items->erase(it);
            _end--;
        }
        else { 
            _items->erase(it);
        }
    }

    void print() {
        cout << _name << ":" << endl;

        // this for access an invalid iterator
        for (auto x : *this) {
            cout << "\t" << x << endl;
        }
    }
};

class List {
private:
    i_list* items;

public:
    List(int size) { 
        items = new i_list();

        for (int i=1; i<=size; i++)
            items->push_back(i*10);
    }

    Sublist* sl(string name, int beg, int end) {
        return new Sublist( name, items, 
                                find(items->begin(), items->end(), beg),
                                find(items->begin(), items->end(), end));
    }
};


int main() {
    List f(20);

    Sublist* sl1 = f.sl("SL1", 10, 60);
    Sublist* sl2 = f.sl("SL2", 60, 110);
    Sublist* sl3 = f.sl("SL3", 110, 160);
    Sublist* sl4 = f.sl("SL4", 160, 210);

    sl1->print();
    sl2->print();
    sl3->print();
    sl4->print();

    sl2->erase( sl2->begin() );
    sl2->erase( sl2->begin() );
    sl2->erase( sl2->begin() );
    sl2->erase( sl2->begin() );
    sl2->erase( sl2->begin() );

    // When uncommented the program will get stuck looping
    //sl1->print();
    sl2->print();
    sl3->print();
    sl4->print();

    return 0;
}

Answer 1

您的问题是您将end 视为范围的一部分。参见例如erase 将接受 end。 在 C++ 中，end 是第一个不属于范围的元素。因此，对于相邻的子列表，end 与下一个 begin 基本相等。

因此，ranged-for 成语不会访问*end。

Answer 2

首先，您的程序没有编译并且有一些逻辑错误，所以我不确定我是在解决您的实际问题，还是只是一个错字。

但是，您声称

所有范围都不相交

在语义上不正确，因为您通过两个不同的子列表访问某些元素（即由 begin 和 end _begin 和 _end 迭代器指向的元素）。对于 STL 容器，C::end() 不需要 supposed 来指向实际元素，并且擦除或取消引用迭代器是未定义的行为。

在你的情况下我会做的是

1) 引入一个单独的标志来指示子列表为空

 private:
    string  _name;
    i_list* _items;
    bool _isEmpty;
    it_list _beg;
    it_list _end;

2) 将 _end 指向最后一个“有效”元素并通过以下方式实现end()

Sublist(string name, i_list* items, it_list beg, it_list end) 
    :   _name(name), 
        _items(items),
        _isEmpty(beg==end),
        _beg(beg),             
        _end(beg==end ? beg : end-1)
{ 
}

it_list end() {
    if (this->_isEmpty) {
        return this->_begin;   
    } else {    
         return this->_end+1; 
    }
}

3) 检查erase()，用户是否试图擦除范围内的最后一个元素

void erase(it_list it) {      
    if (it == _beg) {
        if (_beg==_end) {
            _isEmpty=true;                
        }
        _beg = _items->erase(it);
    }
    else if (it == _end) { //This would be UB in the original version anyway
        _end = _items->erase(it);
        _end--;
    }
    else { 
        _items->erase(it);
    }
}

4) 相应地调整您的 insert 方法（如果有的话）

从已经为空的范围中擦除元素 - 我相信 - 通常是 UB 无论如何，所以我没有检查，但你当然可以在擦除开始时添加这个检查并抛出错误。

==============

编辑：

我的解决方案还有一个问题：
调用sl2->erase( sl2->begin() ) 时 sl1->end() 的副本仍然无效，但我相信，解决此问题的唯一方法是引入服装迭代器或以某种方式修改原始数据结构 - 例如将一些额外的保护节点拼接到原始列表中

作为对 MSalters 评论的回应，我想详细说明一下我认为的问题：
取决于一个人关注的是实现还是行为 - 并忽略了所有空子列表 - 您可以将其视为单个设计错误或行为中的一个确定和一个潜在错误。让我们从最后一个开始：

由于没有单独的文档，可以说Sublist::erase() 的代码暗示sl1->erase( sl1->end() ) 应该可以工作，但是由于它破坏了sl2，因此存在缺陷。但是，也有人可能会争辩说 - 期待 STL 容器语义 - 这个调用无论如何都是 UB，因此，该类的行为“正确”，因为破坏 sl2 只是 UB 的一种可能化身。
main() 中的示例代码实际上遇到的更大问题是调用 sl2->erase( sl2->begin() ) 破坏了 sl1，我相信没有人会说这是可以接受的行为。

现在，行为中的这两个错误都是单一设计问题的结果，即相邻子列表的 _begin 和 _end 迭代器指向父列表中的相同节点 彼此。从sl1.end() 和sl2.begin() 返回的迭代器指向同一个内存位置这一事实本身并不一定是问题，但是当调用sl2->erase( sl2->begin() ) 时，这不仅会破坏_end 指向的元素，但也会切断通向该节点的链接。结果，基于范围的 for 循环永远不会到达sl1.end()，并且由于该链表似乎是作为循环列表实现的，因此会导致无限循环。