blocks|key|2740072|text|我不认为有任何直接的方法可用。因此，可以通过向向量逐个添加元素来实现这一点。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2740073|std::vector<int>+v;
while+(!q.empty())
{
++++v.push_back(q.front());
++++q.pop();
}|code-block|syntax|javascript|2740074|请注意，之后队列将为空。|2740075|正如@David在注释中所建议的那样，最好避免复制队列元素(特别是当包含的对象很大时)。使用emplace_back()和std::move()实现相同的目标：|offset|length|style|CODE|2740076|v.emplace_back(std::move(q.front()));|2740077|entityMap^0|0|0|0|1A|E|1P|B|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|V|8|@$K|W|L|X|M|N]|$K|Y|L|Z|M|N]]|9|@]|A|$]]|$1|O|3|P|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

I don't think there's any direct way available.
Hence this can be achieved by adding elements one by one to the vector.

<pre><code>std::vector&lt;int&gt; v;
while (!q.empty())
{
 v.push_back(q.front());
 q.pop();
}
</code></pre>

Note that the queue will be empty after this.

As suggested by @David in the comment, it'd be good to avoid copying the queue elements (helpful especially when the contained objects are big). Use <code>emplace_back()</code> with <code>std::move()</code> to achieve the same:

<pre><code>v.emplace_back(std::move(q.front()));
</code></pre>

blocks|key|1988513|text|std::vector有一个构造函数采用一对迭代器。，所以如果您能够在队列中迭代，那么您将被设置。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1988514|借用这个问题的答案，您确实可以通过子类std::queue来实现这一点。|1988515|template<typename+T,+typename+Container=std::deque<T>+>
class+iterable_queue+:+public+std::queue<T,Container>
{
public:
++++typedef+typename+Container::const_iterator+const_iterator;

++++const_iterator+begin()+const+{+return+this->c.begin();+}+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++const_iterator+end()+const+{+return+this->c.end();+}
};|code-block|syntax|javascript|1988516|(注意，我们只允许const迭代；出于这个问题的目的，我们不需要迭代器允许修改元素。)|1988517|这样，就可以很容易地构建一个vector|1988518|#include+<queue>
#include+<vector>

using+namespace+std;

template<typename+T,+typename+Container=std::deque<T>+>
class+iterable_queue+:+public+std::queue<T,Container>
{
public:
++++typedef+typename+Container::const_iterator+const_iterator;

++++const_iterator+begin()+const+{+return+this->c.begin();+}+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++const_iterator+end()+const+{+return+this->c.end();+}
};

int+main()+{
++++iterable_queue<int>+int_queue;
++++for(int+i=0;+i<10;+%2B%2Bi)
++++++++int_queue.push(i);

++++vector<int>+v(int_queue.begin(),+int_queue.end());
++++return+0;
}|1988519|entityMap|0|LINK|mutability|MUTABLE|url|http://en.cppreference.com/w/cpp/container/vector/vector|1|https://stackoverflow.com/questions/1259099/stdqueue-iteration^0|0|B|E|C|0|0|J|A|2|4|1|0|0|9|5|0|E|6|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@$9|15|A|16|1|17]]|E|$]]|$1|F|3|G|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@$9|1B|A|1C|1|1D]]|E|$]]|$1|H|3|I|5|J|7|1E|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1F|8|@$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1I|8|@$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|J|7|1L|8|@]|D|@]|E|$K|L]]|$1|S|3|-4|5|6|7|1M|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]|10|$5|V|W|X|E|$Y|11]]]]

<code>std::vector</code> has a <a href="http://en.cppreference.com/w/cpp/container/vector/vector" rel="nofollow noreferrer">constructor taking a pair of iterators</a>, so if you would be able to iterate over the queue, you would be set.

Borrowing from an answer to <a href="https://stackoverflow.com/questions/1259099/stdqueue-iteration">this question</a>, you can indeed do this by subclassing <code>std::queue</code>:

<pre><code>template&lt;typename T, typename Container=std::deque&lt;T&gt; &gt;
class iterable_queue : public std::queue&lt;T,Container&gt;
{
public:
 typedef typename Container::const_iterator const_iterator;

 const_iterator begin() const { return this-&gt;c.begin(); } 
 const_iterator end() const { return this-&gt;c.end(); }
};
</code></pre>

(Note we're allowing only <code>const</code> iteration; for the purpose in the question, we don't need iterators allowing modifying elements.)

With this, it's easy to construct a <code>vector</code>:

<pre><code>#include &lt;queue&gt;
#include &lt;vector&gt;

using namespace std;

template&lt;typename T, typename Container=std::deque&lt;T&gt; &gt;
class iterable_queue : public std::queue&lt;T,Container&gt;
{
public:
 typedef typename Container::const_iterator const_iterator;

 const_iterator begin() const { return this-&gt;c.begin(); } 
 const_iterator end() const { return this-&gt;c.end(); }
};

int main() {
 iterable_queue&lt;int&gt; int_queue;
 for(int i=0; i&lt;10; ++i)
 int_queue.push(i);

 vector&lt;int&gt; v(int_queue.begin(), int_queue.end());
 return 0;
}
</code></pre>

blocks|key|1988549|text|建模queue_like行为和类似向量行为的正确容器是一个std::deque。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1988550|这样做的好处是：|1988551|固定时间的插入和删除的两端。|ordered-list-item|1988552|迭代元素而不破坏deque的能力|1988553|std::deque支持begin()和end()方法，这意味着您可以直接构造一个向量(具有兼容的值类型)。|1988554|#include+<vector>
#include+<deque>

class+AcceptsVectors
{
public:
++AcceptsVectors(std::vector<double>+arg);
};

int+main()
{
++++std::deque<double>+myqueue;

++++auto+av+=+AcceptsVectors({myqueue.begin(),+myqueue.end()});
}|code-block|syntax|javascript|1988555|不可能将queue转换为vector。|1988556|entityMap^0|T|A|0|0|0|0|0|A|C|7|K|5|0|0|4|5|C|6|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|10|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|11|8|@]|D|@]|E|$]]|$1|K|3|L|5|J|7|12|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]|$9|18|A|19|B|C]]|D|@]|E|$]]|$1|O|3|P|5|Q|7|1A|8|@]|D|@]|E|$R|S]]|$1|T|3|U|5|6|7|1B|8|@$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|V|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]]|W|$]]

The correct container to model both queue_like behaviour and vector-like behaviour is a <code>std::deque</code>.

This has the advantages of:

<ol>
<li>constant-time insertion and deletion at either end of the deque</li>
<li>ability to iterate elements without destroying the deque</li>
</ol>

<code>std::deque</code> supports the <code>begin()</code> and <code>end()</code> methods which means you can construct a vector (with compatible value-type) directly.

<pre><code>#include &lt;vector&gt;
#include &lt;deque&gt;

class AcceptsVectors
{
public:
 AcceptsVectors(std::vector&lt;double&gt; arg);
};

int main()
{
 std::deque&lt;double&gt; myqueue;

 auto av = AcceptsVectors({myqueue.begin(), myqueue.end()});
}
</code></pre>

A non-mutating conversion of a <code>queue</code> to a <code>vector</code> is not possible.

blocks|key|1395759|text|这只是一种避免将从std::queue复制到std::vector的方法。不管你用不用，我都由你决定。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|1395760|房地|1395761|std::queue是一个容器适配器。默认情况下，内部container是std::deque，但是也可以将其设置为std::vector。幸运的是，保存此容器的成员变量被标记为protected。因此，您可以通过子类queue来破解它。|1395762|解决方案(!)|1395763|template<typename+T>
struct+my_queue+:+std::queue<T,+std::vector<T>>
{
++using+std::queue<T,+std::vector<T>>::queue;
++//+in+G%2B%2B,+the+variable+name+is+`c`,+but+it+may+or+may+not+differ
++std::vector<T>&+to_vector+()+{+return+this->c;+}
};|code-block|syntax|javascript|1395764|就这样！！|1395765|用法|1395766|my_queue<int>+q;
q.push(1);
q.push(2);
std::vector<int>&+v+=+q.to_vector();|1395767|演示。|1395768|entityMap|0|LINK|mutability|MUTABLE|url|http://ideone.com/uUHSN9^0|3|5|9|A|M|B|0|0|0|A|R|9|11|A|1M|B|2H|9|31|5|0|0|0|0|0|0|0|2|0|0^^$0|@$1|2|3|4|5|6|7|17|8|@$9|18|A|19|B|C]|$9|1A|A|1B|B|D]|$9|1C|A|1D|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|1E|8|@]|E|@]|F|$]]|$1|I|3|J|5|6|7|1F|8|@$9|1G|A|1H|B|D]|$9|1I|A|1J|B|D]|$9|1K|A|1L|B|D]|$9|1M|A|1N|B|D]|$9|1O|A|1P|B|D]|$9|1Q|A|1R|B|D]]|E|@]|F|$]]|$1|K|3|L|5|6|7|1S|8|@]|E|@]|F|$]]|$1|M|3|N|5|O|7|1T|8|@]|E|@]|F|$P|Q]]|$1|R|3|S|5|6|7|1U|8|@]|E|@]|F|$]]|$1|T|3|U|5|6|7|1V|8|@]|E|@]|F|$]]|$1|V|3|W|5|O|7|1W|8|@]|E|@]|F|$P|Q]]|$1|X|3|Y|5|6|7|1X|8|@]|E|@$9|1Y|A|1Z|1|20]]|F|$]]|$1|Z|3|-4|5|6|7|21|8|@]|E|@]|F|$]]]|10|$11|$5|12|13|14|F|$15|16]]]]

This is just an approach to avoid copying from <code>std::queue</code> to <code>std::vector</code>. I leave it up to you, if to use it or not.

<h2>Premises</h2>

<code>std::queue</code> is a container adaptor. The internal <code>container</code> by default is <code>std::deque</code>, however you can set it to <code>std::vector</code> as well. The member variable which holds this container is marked as <code>protected</code> luckily. Hence you can hack it by subclassing the <code>queue</code>.

<h2>Solution (!)</h2>

<pre><code>template&lt;typename T&gt;
struct my_queue : std::queue&lt;T, std::vector&lt;T&gt;&gt;
{
 using std::queue&lt;T, std::vector&lt;T&gt;&gt;::queue;
 // in G++, the variable name is `c`, but it may or may not differ
 std::vector&lt;T&gt;&amp; to_vector () { return this-&gt;c; }
};
</code></pre>

That's it!!

<h2>Usage</h2>

<pre><code>my_queue&lt;int&gt; q;
q.push(1);
q.push(2);
std::vector&lt;int&gt;&amp; v = q.to_vector();
</code></pre>

<a href="http://ideone.com/uUHSN9" rel="nofollow">Demo</a>.

I need to make use of a queue of doubles because of the good properties it has as an ordered container. I want to pass this queue to a class constructor that accepts vectors. If I do that directly I get the following error:

<blockquote>
 candidate constructor not viable: no known conversion from
 'std::queue' to 'std::vector &amp;' for 2nd argument
</blockquote>

How to cast a queue to a vector?

How to convert std::queue to std::vector

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

我需要使用一个双重队列，因为它作为一个有序容器具有良好的属性。我想把这个队列传递给接受向量的类构造函数。如果我直接这样做，就会得到以下错误：候选构造函数不可行:对于第二个参数，没有已知的从'std::queue‘到'std::vector &’的转换如何将队列转换为向量？

问如何将std::queue转换为std::vector
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何将std::queue转换为std::vectorEN