继承 Java 集合接口（Set、Map、List 等）的 C++ 等价物是什么？还是扩展 AbstractCollection？

Question

我已经开始使用 C++ 编码，来自 Java 背景（实际上我在大学学习过 C++，但我们从未学习过 STL 等）

不管怎样，我已经到了在各种集合中排列数据的地步，我立即告诉自己“好的，这是一种 Set；这是一个 List，或者一个 ArrayList；这是一张地图等。”在 Java 中，我会简单地让我正在编写的任何类实现 Set 或 Map 或 List 接口；但我可能不会继承 ArrayList 或 HashSet 之类的东西，那里的实现有点涉及，我不想把它们搞砸。

现在，我在 C++（使用标准库）中做什么？ Sets、Maps、Lists 等似乎没有抽象基类——相当于 Java 接口；另一方面，标准容器的实现看起来很可怕。好吧，也许一旦你了解了它们，它们就不会那么可怕了，但是假设我只是想写一些像在 C++ 中扩展 AbstractSet 的非虚拟类之类的东西？我可以传递给任何需要 Set 的函数吗？我该怎么做呢？

澄清一下 - 我不一定想做 Java 中的常见做法。但是，另一方面，如果我有一个对象，从概念上讲，它是一种集合，我想继承适当的东西，免费获得默认实现，并在我的 IDE 的指导下实现我应该实现的那些方法。

Answer 1

简短的回答是：没有等价物，因为 C++ 做事不同。

没有必要争论这个，事情就是这样。如果您不喜欢这样，请使用其他语言。

长答案是：有一个等价物，但它会让你有点不开心，因为虽然 Java 的容器和算法模型主要基于继承，但 C++ 不是。 C++ 的模型主要基于泛型迭代器。

举个例子，假设你想实现一个集合。忽略 C++ 已经有 std::set、std::multiset、std::unordered_set 和 std::unordered_multiset 的事实，和这些都可以使用不同的比较器和分配器进行定制，而无序的则具有可定制的哈希函数，当然。

假设你想重新实现std::set。例如，也许您是一名计算机科学专业的学生，​​并且想要比较 AVL 树、2-3 树、红黑树和展开树。

你会怎么做？你会写：

template<class Key, class Compare = std::less<Key>, class Allocator = std::allocator<Key>> 
class set {
    using key_type = Key;
    using value_type = Key;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
    using key_compare = Compare;
    using value_compare = Compare;
    using allocator_type = Allocator;
    using reference = value_type&;
    using const_reference = const value_type&;
    using pointer = std::allocator_traits<Allocator>::pointer;
    using const_pointer = std::allocator_traits<Allocator>::const_pointer;
    using iterator = /* depends on your implementation */;
    using const_iterator = /* depends on your implementation */;
    using reverse_iterator = std::reverse_iterator<iterator>;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>

    iterator begin() const;
    iterator end() const;
    const_iterator cbegin() const;
    const_iterator cend() const;
    reverse_iterator rbegin() const;
    reverse_iterator rend() const;
    const_reverse_iterator crbegin() const;
    const_reverse_iterator crend() const;

    bool empty() const;
    size_type size() const;
    size_type max_size() const;

    void clear();

    std::pair<iterator, bool> insert(const value_type& value);
    std::pair<iterator, bool> insert(value_type&& value);
    iterator insert(const_iterator hint, const value_type& value);
    iterator insert(const_iterator hint, value_type&& value);
    template <typename InputIterator>
    void insert(InputIterator first, InputIterator last);
    void insert(std::initializer_list<value_type> ilist);

    template <class ...Args>
    std::pair<iterator, bool> emplace(Args&&... args);

    void erase(iterator pos);
    iterator erase(const_iterator pos);
    void erase(iterator first, iterator last);
    iterator erase(const_iterator first, const_iterator last);
    size_type erase(const key_type& key);

    void swap(set& other);

    size_type count(const Key& key) const;
    iterator find(const Key& key);
    const_iterator find(const Key& key) const;

    std::pair<iterator, iterator> equal_range(const Key& key);
    std::pair<const_iterator, const_iterator> equal_range(const Key& key) const;

    iterator lower_bound(const Key& key);
    const_iterator lower_bound(const Key& key) const;
    iterator upper_bound(const Key& key);
    const_iterator upper_bound(const Key& key) const;

    key_compare key_comp() const;
    value_compare value_comp() const;
}; // offtopic: don't forget the ; if you've come from Java!

template<class Key, class Compare, class Alloc>
void swap(set<Key,Compare,Alloc>& lhs, 
          set<Key,Compare,Alloc>& rhs);

template <class Key, class Compare, class Alloc>
bool operator==(const set<Key,Compare,Alloc>& lhs,
                const set<Key,Compare,Alloc>& rhs);

template <class Key, class Compare, class Alloc>
bool operator!=(const set<Key,Compare,Alloc>& lhs,
                const set<Key,Compare,Alloc>& rhs);

template <class Key, class Compare, class Alloc>
bool operator<(const set<Key,Compare,Alloc>& lhs,
               const set<Key,Compare,Alloc>& rhs);

template <class Key, class Compare, class Alloc>
bool operator<=(const set<Key,Compare,Alloc>& lhs,
                const set<Key,Compare,Alloc>& rhs);

template <class Key, class Compare, class Alloc>
bool operator>(const set<Key,Compare,Alloc>& lhs,
               const set<Key,Compare,Alloc>& rhs);

template <class Key, class Compare, class Alloc>
bool operator>=(const set<Key,Compare,Alloc>& lhs,
                const set<Key,Compare,Alloc>& rhs);

当然，您不必编写所有这些，特别是如果您只是编写一些东西来测试它们的一部分。但是如果你写了所有这些（为了清楚起见，我排除了更多），那么你将拥有一个功能齐全的集合类。那个 set 类有什么特别之处？

您可以在任何地方使用它。任何适用于std::set 的东西都适用于您的设置。它不必专门为它编程。它不需要任何东西。任何适用于任何集合类型的东西都应该适用于它。 Boost 的任何算法都适用于集合。

您编写的用于集合的任何算法都将适用于您的集合、boost 的集合以及许多其他集合。但不仅仅是在片场。如果它们写得很好，它们将适用于任何支持特定类型迭代器的容器。如果他们需要随机访问，他们将需要 RandomAccessIterators，std::vector 提供，但 std::list 没有。如果他们需要双向迭代器，那么 std::vector 和 std::list（以及其他）可以正常工作，但 std::forward_list 不会。

迭代器/算法/容器的东西真的很好用。考虑在 C++ 中将文件读入字符串的简洁性：

using namespace std;

ifstream file("file.txt");
string file_contents(istreambuf_iterator<char>(file),
                     istreambuf_iterator<char>{});

Answer 2

标准 C++ 库已经实现了列表、映射、集合等。C++ 中没有必要再次实现这些数据结构。如果您实现类似这些数据结构之一的东西，您将实现相同的概念（即，使用相同的函数名称、参数顺序、嵌套类型的名称等）。容器有多种概念（序列、关联容器等）。更重要的是，您将使用适当的迭代器概念公开结构的内容。

注意：C++ 不是 Java。不要尝试用 C++ 编写 Java。如果您想编写 Java，请编写 Java：它比尝试在 C++ 中编写要好得多。如果你想编写 C++，就编写 C++。

Answer 3

您需要尝试摆脱 Java 思维方式。你看，STL 的美妙之处在于它通过迭代器将算法与容器分开。

长话短说：将迭代器传递给您的算法。不要继承。

这里是所有容器：http://en.cppreference.com/w/cpp/container

以下是所有算法：http://en.cppreference.com/w/cpp/algorithm

您可能想要继承的原因可能有两个：

• 您想重用实现（坏主意）
• 通过使行为可用来重用现有算法（例如，从像 AbstractSet 这样的基类继承）

简要介绍第一点，如果您需要存储一个数组（比如游戏场景中的一个对象数组），就这样做，将这些对象的数组作为 Scene 对象的成员。无需子类化即可充分利用容器。换句话说，比继承更喜欢组合。这已经被做死了，并且在 Java 世界中被接受为做“正确的事情”。 See discussion here，在 GoF 书中！同样的道理也适用于 C++。

示例：

为了解决第二点，让我们考虑一个场景。您正在制作一个 2D 横向卷轴游戏，并且您有一个 Scene 对象，其中包含一个 GameObjects 数组。这些GameObjects 有位置，你想按位置对它们进行排序，然后进行二进制搜索以找到最近的对象，例如。

在 C++ 思维模式中，元素的存储和容器的操作是两个独立的事情。容器类提供了最基本的功能，用于创建/插入/删除。以上任何有趣的东西都归入算法。而它们之间的桥梁是迭代器。这个想法是，无论您使用std::vector<GameObject>（我认为相当于Java 的ArrayList），还是您自己的实现都是无关紧要的，只要对元素的访问是相同的。这是一个人为的例子：

struct GameObject {
    float x, y;

    // compare just by x position
    operator < (GameObject const& other)
    {
        return x < other.x;
    }
};

void example() {
    std::vector<GameObject> objects = {
        GameObject{8, 2},
        GameObject{4, 3},
        GameObject{6, 1}
    };
    std::sort(std::begin(objects), std::end(objects));
    auto nearestObject = std::lower_bound(std::begin(objects), std::end(objects), GameObject{5, 12});

    // nearestObject should be pointing to GameObject{4,3};
}

这里需要注意的是，我使用std::vector 来存储我的对象这一事实与我可以对其元素执行随机访问这一事实无关紧要。 vector 返回的迭代器捕获了这一点。这样我们就可以排序并执行二分查找了。

向量的本质是随机访问元素

我们可以将向量替换为任何其他随机访问结构，无需继承，代码仍然可以正常工作：

void example() {
    // using a raw array this time.
    GameObject objects[] = {
        GameObject{8, 2},
        GameObject{4, 3},
        GameObject{6, 1}
    };
    std::sort(std::begin(objects), std::end(objects));
    auto nearestObject = std::lower_bound(std::begin(objects), std::end(objects), GameObject{5, 12});

    // nearestObject should be pointing to GameObject{4,3};
}

参考，看我用过的函数：

• std::sort
• std::lower_bound

为什么这是继承的有效替代方法？

这种方法为可扩展性提供了两个正交方向：

• 无需继承即可添加新容器，只需提供迭代器访问即可。 所有现有算法都有效。
• 可以添加新算法。 所有支持这些迭代器的容器都可以使用这些新算法，过去、现在或未来。

Answer 4

C++ 标准库（注意：它不称为 STL）有许多现有的容器类型：vector、array、deque、forward_list、list、set、map、 multiset、multimap、unordered_set、unordered_map、unordered_multiset、unordered_multimap、stack、queue、priority_queue。很有可能，您只想直接使用其中之一 - 您当然从不想从它们中派生。但是，您肯定有可能在某些时候需要实现自己的特殊容器类型，并且如果它匹配某个接口会很好，对吧？

但不，容器没有派生自一些抽象基类。然而，C++ 标准为类型（有时称为概念）提供了要求。例如，如果您查看 C++11 标准（或 here）的第 23.2 节，您会发现容器的要求。例如，所有容器都必须有一个默认构造函数，该构造函数在恒定时间内创建一个空容器。然后对Sequence Containers（如std::vector）和Associative Containers（如std::map）有更具体的要求。您可以对您的类进行编码以满足这些要求，然后人们就可以按照他们的期望安全地使用您的容器。

当然，除了容器之外，还有很多其他方面的要求。例如，标准对不同类型的迭代器、随机数生成器等提出了要求。

---

ISO C++ 委员会（实际上是第 8 研究组）中的一些人正在研究使这些概念成为该语言的一个特性。该提案将允许您指定需要满足的类型的要求，才能将它们用作模板类型参数。例如，您可以像这样编写一个模板函数：

template <Sequence_container C>
void foo(C container); // This will only accept sequence containers
// or even just:
void foo(Sequence_container container);

但是，我认为这超出了您对 C++ 的理解范围。

Answer 5

在 C++ 中，集合（也称为容器）和对其进行操作的通用算法是以完全不知道继承的方式实现的。相反，连接它们的是迭代器：对于每个容器，指定它提供的迭代器类别，对于每个算法，说明它使用的迭代器类别。所以在某种程度上，迭代器将其他两个“桥接”在一起，这就是 STL 如何将容器和算法的数量保持在最低限度（N+M 而不是 N*M）。容器进一步定义为序列容器（vector、deque、list（双链表）或 forward_list（单链表）和关联容器（map、set、hashmap、hashset 等）。序列容器与性能有关（即一个是针对不同情况的更好选择）。关联容器关注事物如何存储在其中及其结果（二叉树与散列数组）。类似的想法适用于算法。这是 STL 示例的通用编程的要点通过专门且有意地不面向对象。实际上，您将不得不扭曲纯 OO 方法以实现流畅的泛型编程。这样的范式不能与 Java 或 Smalltalk 等语言一起愉快地使用