有没有办法访问STL容器适配器的底层容器？

Question

是否有一种标准方式来访问stack、queue、priority_queue ?

我在stack和queue的VS2008实现中发现了一种名为：_Get_container()的方法，但没有人<代码>优先级队列！ 我认为无论如何这都不标准。

另外，我知道这是一个愚蠢的问题！ 在哪里可以找到标准库的官方文档？

---

只是为了澄清，我并不想搞乱底层容器。 我想做的就是这样：

template <class Container>
std::ostream& printOneValueContainer(std::ostream& outputstream, Container& container)
{
    Container::const_iterator beg = container.begin();

    outputstream << "[";

    while(beg != container.end())
    {
        outputstream << " " << *beg++;
    }

    outputstream << " ]";

    return outputstream;
}

// stack, queue
template
    < class Type
    , template<class Type, class Container = std::deque<Type> > class Adapter
    >
std::ostream& operator<<(std::ostream& outputstream, const Adapter<Type>& adapter)
{
    return printOneValueContainer(outputstream, adapter._Get_container());
}
.
.
.
std::stack<int> iStack;
.
.
std::cout << iStack << std::endl;

我希望你看到 _Get_container() 不是标准的，并且 VS2008 中没有 priority_queue 。代码> 实现。

Answer 1

我在网络上的某个地方发现了以下解决方案，并且我正在我的项目中使用它：

template <class T, class S, class C>
    S& Container(priority_queue<T, S, C>& q) {
        struct HackedQueue : private priority_queue<T, S, C> {
            static S& Container(priority_queue<T, S, C>& q) {
                return q.*&HackedQueue::c;
            }
        };
    return HackedQueue::Container(q);
}

int main()
{
    priority_queue<SomeClass> pq;
    vector<SomeClass> &tasks = Container(pq);
    return 0;
}

玩得开心:)。

Answer 2

基于接受的答案，一种更通用的方法：

template <class ADAPTER>
typename ADAPTER::container_type & get_container (ADAPTER &a)
{
    struct hack : ADAPTER {
        static typename ADAPTER::container_type & get (ADAPTER &a) {
            return a.*&hack::c;
        }
    };
    return hack::get(a);
}

正如我从这个答案，.*&实际上是两个运算符，其中&hack::c产生的指针（其类型为 ADAPTER::container_type ADAPTER::*）是用于检索底层容器本身的目标或 .* 运算符。 hack 可以访问受保护的成员，但获得指针后，保护就会丢失。 所以 a.*(&hack::c) 是允许的。

Answer 3

我在评论中提到过，但经过一番思考，这似乎是一个不错的解决方案。 queue/stack/priority_queue（即所有适配器类）都有一个 protected 成员c 是底层容器（请参阅 ISO/IEC 14882:2003 第 23.2.2.4 节），因此如果您从其中任何一个继承，则可以直接访问它。

我知道典型的智慧是由于非虚拟 dtor 而不要从 STL 容器继承，但这种情况是一个例外。 目标不是使功能过载，而是对适配器的接口进行较小的扩展。 下面是添加访问底层容器的能力的示例。

#include <queue>
#include <iostream>

template <class Container>
class Adapter : public Container {
public:
    typedef typename Container::container_type container_type;
    container_type &get_container() { return this->c; }
};

int main() {
    typedef std::queue<int> C;
    typedef Adapter<C> Container;

    Container adapter;

    for(int i = 0; i < 10; ++i) {
        adapter.push(i);
    }

    Container::container_type &c = adapter.get_container();
    for(Container::container_type::iterator it = c.begin(); it != c.end(); ++it) {
        std::cout << *it << std::endl;
    }
}

不幸的是，您必须诉诸类型双关来“升级”现有的 std::queue 。 * 到 Adapter; > *。 从技术上讲，这可能会很好地工作......但我建议不要这样做：

    typedef std::stack<int> C;
    typedef Adapter<C> Container;
    C stack;
    // put stuff in stack
    Container *adapter = reinterpret_cast<Container *>(&stack);
    Container::container_type &c = adapter->get_container();
    // from here, same as above        

所以我建议使用 typedef 来轻松在两者之间进行交换。 （另请注意，在我的示例中，由于 typedef 的自由使用，您只需更改 1 行即可将其从 queue 更改为 stack >s）。

Answer 4

不，没有标准的方法可以做到这一点。 至于访问该标准，它在网络上不可用，您必须购买副本！ 但有各种草稿副本
可在此处获取。

Answer 5

我相信，这个 SGI 页面是最“官方”的在线文档。

您无法直接访问底层容器的原因是适配器更改了使用模式，并且使底层容器的方法可用将违反该新的使用模式。 例如：

2 此限制是队列存在的唯一原因。 任何既是前插入序列又是后插入序列的容器都可以作为队列； 例如，deque 有成员函数 front、back、push_front、push_back、pop_front 和 pop_back 使用容器适配器队列而不是容器双端队列的唯一原因是为了明确您仅执行队列操作，而不执行其他操作运营。
http://www.sgi.com/tech/stl/queue.html

如果您想绕过此设计功能，您可以执行以下操作：

template <typename T>
class clearable_queue : public std::queue<T>
{
public:
    void clear() { c.clear(); }
};

Answer 6

作为一般规则，任何以下划线开头的标识符都是供应商特定的扩展或实现细节。 所以_Get_container()只是微软的一个补充，因为它简化了他们的实现。 它不打算被使用。

至于在哪里可以找到文档，它分为几个部分。

权威来源当然是语言标准。 正如尼尔·巴特沃斯所说，网上有免费的草稿副本（仍然非常有用。与最终版本的差异非常小）。 或者，您可以购买副本。 它应该可以从您所在国家代表 ISO 的任何组织获得（也可能从无数其他来源获得）。 您要查找的文档是 ISO/IEC 14882:2003 编程语言 C++。 （14882是标准编号。2003年是最后一次修订的年份。如果你遇到过1998年的版本，也可以使用它。两者之间的差异确实小得离谱，基本上只是一些澄清。可能最好远离 C++0x 的草案，因为那里的更改要广泛得多）

除此之外，标准库的每个实现都需要记录大量细节（实现定义的行为、标准中未指定，而是由库实现者决定）。 此外，他们中的大多数还提供了整个库的详细文档。

Microsoft 在 MSDN 上提供了详细文档。 该文档尊重标准，并清楚地标记所有非标准扩展，以便您知道哪个是哪个。

SGI 也有在线文档（尽管它较旧，并且在某些情况下并不完全准确） ）。

IBM 在其网站上提供了类似的文档，我相信 GCC 也有。

Answer 7

我当然希望没有办法访问优先级队列的底层容器。 如果可以的话，您可能会弄乱优先级队列的内部堆结构。 无论如何，这些适配器的要点是它们仅为您提供堆栈或队列的最小接口，并抽象出所有其他内容。 因此，如果您需要使用任何其他功能，您应该直接使用原始容器。

至于STL的文档，你可以在这里查看SGI的STL文档。 SGI 的 STL 与 C++ 标准中的 STL 之间存在一些差异，但它们大多在该网站上注明。 此外，cppreference.com 是 C++ 库的 wiki 文档，该文档正在变得更加完整。

Answer 8

您可以编写一个子类来检索成员变量 c。
请参阅 libstdc++ 的评论。

protected:
/**
 *  'c' is the underlying container.  Maintainers wondering why
 *  this isn't uglified as per style guidelines should note that
 *  this name is specified in the standard, [23.2.3.1].  (Why?
 *  Presumably for the same reason that it's protected instead
 *  of private: to allow derivation.  But none of the other
 *  containers allow for derivation.  Odd.)
 */
_Sequence c;

Answer 9

这应该适用于最新的 ISO 编译器：

template <typename T, typename Seq = std::vector<T>,
            typename Cmp = std::less<typename Seq::value_type>>
  class PriorityQueueContainer : public std::priority_queue<T, Seq, Cmp> {
   public:
    using base_t = std::priority_queue<T, Seq, Cmp>;
    PriorityQueueContainer() = default;
    template <typename Cont>
    PriorityQueueContainer(Cont&& cont) : base_t(Cmp{}, std::move(cont)) {}
    template <typename Cmp, typename Cont>
    PriorityQueueContainer(const Cmp& cmp, Cont&& cont) : base_t(cmp, std::move(cont)) {}
    template <typename Cont>
    PriorityQueueContainer(const Cont& cont) : base_t(Cmp{}, cont) {}

    static Seq&& retrieve_container(PriorityQueueContainer&& pq) {
      return std::move(pq.c);
    }
  };

用法：

 PriorityQueueContainer<int> pq();
 std::vector<int> retrieve = PriorityQueueContainer<int>::retrieve_container(std::move(pq));

Answer 10

在哪里可以找到标准库的官方文档？

C++ 标准有精装本，ISBN 0470846747。
标准草案以 PDF 形式广泛存在，但您必须小心地将它们与官方版本（C++98、03、11 或 14）相匹配。 当前的草案超出了 C++14 标准。