此页面由 Cloud Translation API 翻译。

依序播放的容器

fbl:: 提供了两个主要的容器系列，即“顺序容器” 和关联容器

有序容器是一种容器，其中的元素的枚举顺序为根据用户向特定来源添加元素或从中移除元素的方式容器。fbl:: 定义了两种类型的有序容器。

SinglyLinkedList 是一个仅支持正向的有序容器迭代。
DoublyLinkedList 是一个有序容器，支持双向迭代。

有序容器和关联容器之间的主要区别决定着向容器添加元素和从容器中移除元素的方式。本指南的这一部分将向您介绍如何在以及从有序容器中移除

请参阅设置 build 依赖项要使用各种容器类型，必须添加该文件

向有序容器添加元素

SinglyLinkedList 提供了两种向容器添加元素的方法。它们是：

push_front(Ptr)
insert_after(Iter, Ptr)

DoublyLinkedList 也支持这些方法，但还添加了以下内容方法。

push_back(Ptr)
insert(Iter, Ptr)
splice(Iter, List)

与往常一样，如果该容器类型使用的节点状态已经是容器的成员。使用托管指针类型时，用户可以为容器提供自己的通过值提供指针实例来引用对象，或者可以使用 std::move 将其引用转移至容器。

将元素推送到按顺序排列的容器中

推送方法的行为符合预期，会添加新元素并将其设为新元素序列中的前部或后部元素（即，第一个或枚举顺序中的最后一个元素）。例如：

struct Tag1 {};
struct Tag2 {};
class Obj : public fbl::RefCounted<Obj>,
            public fbl::ContainableBaseClasses<
              fbl::TaggedDoublyLinkedListable<fbl::RefPtr<Obj>, Tag1>,
              fbl::TaggedDoublyLinkedListable<fbl::RefPtr<Obj>, Tag2>
            > {
 public:
  explicit Obj(int val) : val_(val) {}
  int val() const { return val_; }
 private:
  const int val_;
};

TaggedDoublyLinkedList<fbl::RefPtr<Obj>, Tag1> stack_like;
TaggedDoublyLinkedList<fbl::RefPtr<Obj>, Tag2> queue_like;

for (int i = 0; i < 5; ++i) {
  fbl::RefPtr<Obj> obj_ref = fbl::AdoptRef(new Obj(i));
  stack_like.push_front(obj_ref);            // Copy our reference
  queue_like.push_back(std::move(obj_ref));  // Transfer our reference
}

// Prints "4 3 2 1 0 "
for (const auto& obj : stack_like) { printf("%d ", obj.val()); }
printf("\n");

// Prints "0 1 2 3 4 "
for (const auto& obj : queue_like) { printf("%d ", obj.val()); }
printf("\n");

将元素插入按顺序排列的容器中

insert 和 insert_after 均在排名紧随其前 (insert) 或紧随其后 (insert_after) 迭代器。begin() 或 end() 都可以作为 insert 的迭代器，其功能等同于仅指定 push_front 或 push_back。使用insert_after 不引用元素的迭代器，因此 insert_after 只会当容器为非空时接受容器的 begin()，并且永远不会接受 end()。继续上一个示例：

queue_like.insert(queue_like.begin(), fbl::MakeRefCounted<Obj>(100));
queue_like.insert(queue_like.end(), fbl::MakeRefCounted<Obj>(500));
for (auto iter = queue_like.begin(), iter != queue_like.end(); ++iter) {
  if (iter->val() == 2) {
    queue_like.insert(iter, fbl::MakeRefCounted<Obj>(200));
    queue_like.insert_after(iter, fbl::MakeRefCounted<Obj>(300));
    break;
  }
}

// Prints "100 0 1 200 2 300 3 4 500 "
for (const auto& obj : queue_like) { printf("%d ", obj.val()); }
printf("\n");

使用 `splice` 合并有序容器

最后，splice 将获取所提供列表的内容，并将其拼接成另一个列表中迭代器前面的位置。完成后，源列表将为空，因为已将它的所有元素目标列表。源列表和目标列表必须是不同的列表但必须是相同类型的列表（例如，两者必须使用相同的节点存储）。begin() 和 end() 都是目标位置中的有效目标。前者会将源元素附加到目标元素，而后者会附加相应代码上一个示例即将完成：

TaggedDoublyLinkedList<fbl::RefPtr<Obj>, Tag2> tmp;

tmp.push_front(fbl::MakeRefCounted<Obj>(-1));
tmp.push_front(fbl::MakeRefCounted<Obj>(-2));
queue_like.splice(queue_like.begin(), tmp);

tmp.push_back(fbl::MakeRefCounted<Obj>(1000));
tmp.push_back(fbl::MakeRefCounted<Obj>(2000));
queue_like.splice(queue_like.end(), tmp);

tmp.push_back(fbl::MakeRefCounted<Obj>(50));
tmp.push_back(fbl::MakeRefCounted<Obj>(60));
for (auto iter = queue_like.begin(), iter != queue_like.end(); ++iter) {
  if (iter->val() == 300) {
    queue_like.splice(iter, tmp);
    break;
  }
}

// Prints "-2 -1 100 0 1 200 2 50 60 300 3 4 500 1000 2000 "
for (const auto& obj : queue_like) { printf("%d ", obj.val()); }
printf("\n");

从有序容器中移除元素

SinglyLinkedList 提供了三种从容器中移除元素的方法。它们是：

pop_front()
erase_next(Iter)
clear()