标签: deque

据我所知,deque和vector都为增长留出了一些空间.vector :: capacity()能够获取向量的内部保留空间.Deque在标准中没有这样的成员.有什么方法可以获得这些信息吗？

STL标准定义当在诸如std :: deque,std :: list等容器上发生擦除时,迭代器无效.

我的问题如下,假设std :: deque中包含的整数列表,以及一对指示std :: deque中元素范围的指示,删除所有偶数元素的正确方法是什么？

到目前为止,我有以下内容,但问题是假设结束在擦除后失效:

#include <cstddef>
#include <deque>

int main()
{
   std::deque<int> deq;
   for (int i = 0; i < 100; deq.push_back(i++));

   // range, 11th to 51st element
   std::pair<std::size_t,std::size_t> r(10,50);

   std::deque<int>::iterator it = deq.begin() + r.first;
   std::deque<int>::iterator end = deq.begin() + r.second;

   while (it != end)
   {
      if (*it % 2 == 0)
      {
         it = deq.erase(it);
      }
      else
        ++it;
   }

   return 0;
}

检查如何实现std :: remove_if,似乎有一个非常昂贵的复制/降档过程正在进行.

• 没有所有复制/转换,是否有更有效的方法来实现上述目标

• 一般来说,删除/删除元素比使用序列中的下一个第n个值交换更昂贵(其中n是到目前为止删除/删除的元素数)

注意:答案应该假设序列大小非常大,+ 1mil元素,平均1/3的元素将被删除.

我正在为Windows编写一个串口软件.为了提高性能,我试图将例程转换为使用异步I/O. 我有代码并且运行得相当好,但我是半初学者,我想进一步提高程序的性能.在程序的压力测试期间(即在高波特率下尽可能快地向/从端口突发数据),CPU负载变得非常高.

如果有人在Windows中有异步I/O和多线程的经验,如果你能看一下我的程序,我将不胜感激.我有两个主要问题:

• 异步I/O是否正确实现？我在网上发现了一些相当可靠的来源,建议您可以将用户数据传递给回调函数,方法是在最后用自己的数据实现自己的OVERLAPPED结构.这似乎工作得很好,但它确实看起来有点"hackish"给我.此外,当我从同步/轮询转换为异步/回调时,程序的性能并没有那么大提高,让我怀疑我做错了什么.

• 使用STL std :: deque作为FIFO数据缓冲区是否合理？由于当前编写了程序,我只允许在必须处理之前一次接收1个字节的数据.因为我不知道我将收到多少数据,所以可能是无穷无尽的数量.我假设这个1字节一次在必须分配数据时会产生deque线后面的缓慢行为.而且我也不相信deque也是线程安全的(我应该吗？).如果使用STL deque不合理,是否有任何建议可以使用更好的数据类型？基于静态数组的圆环缓冲区？

关于代码的任何其他反馈也是最受欢迎的.

实现了串行例程,以便我有一个名为"Comport"的父类,它处理所有与串行I/O相关的内容.从这个类我继承了另一个名为"ThreadedComport"的类,这是一个多线程版本.

ThreadedComport类(相关部分)

class ThreadedComport : public Comport
{
  private:

    HANDLE        _hthread_port;                 /* thread handle      */
    HANDLE        _hmutex_port;                  /* COM port access    */
    HANDLE        _hmutex_send;                  /* send buffer access */
    HANDLE        _hmutex_rec;                   /* rec buffer access  */

    deque<uint8>  _send_buf;
    deque<uint8>  _rec_buf;
    uint16        _data_sent;
    uint16        _data_received;

    HANDLE        _hevent_kill_thread;
    HANDLE        _hevent_open;
    HANDLE        _hevent_close;
    HANDLE        _hevent_write_done;
    HANDLE        _hevent_read_done;
    HANDLE        _hevent_ext_send;              /* notifies external thread */
    HANDLE        _hevent_ext_receive;           /* notifies external thread */

    typedef struct …

我有一个双子座:

deque<char> My_Deque;
My_Path.push_front('a');
My_Path.push_front('b');
My_Path.push_front('c');
My_Path.push_front('d');
My_Path.push_front('e');

有这样的方法输出它.

首先:

deque<char>::iterator It;
for ( It = My_Deque.begin(); It != My_Deque.end(); It++ )
    cout << *It <<  " ";

第二:

for (i=0;i<My_Deque.size();i++) {
    cout << My_Deque[i] <<  " ";
}

什么是访问双端队列的元素的最佳途径-通过迭代器或类似这样的:My_Deque[i]？deque <...>元素是一个指向每个元素的指针数组,用于快速访问它的数据,或者以连续的方式提供对它的随机元素的访问(如下图所示)？

你怎么resize一个std::deque从前面,而不是回来了？

(是的,当然我可以push_front成千上万次虚拟值,但是有更好/更有效的方法吗？)

我在调用以下代码时遇到问题:

#include<deque>
using namespace std;

deque<int> deq = {0,1,2,3,4,5,6,7,8};

for(auto it = deq.begin(); it != deq.end(); it++){
    if(*it%2 == 0)
        deq.erase(it);
}

这导致了分段错误.在查看问题后,我发现问题在于STL管理deques的迭代器的方式:如果被擦除的元素更接近deque的末尾,用于指向擦除元素的迭代器现在将指向NEXT元素,但不是前一个元素vector::iterator.据我所知,从修改的循环条件it != deq.end(),以it < deq.end()可能可能解决这个问题,但我不知道是否有遍历&在"标准形式"一个双端队列擦除某些元件,使得代码可以是其他容器类型兼容的方式同样.

我正在学习如何使用双端队列.这是我做的:

>>> d = deque([1,2,3,4,5,6], maxlen=3)

我预计d会包含[1,2,3].但相反,我得到了:

>>> d
deque([4, 5, 6], maxlen=3)

这不是违反直觉吗？

我试图使用一个简单的列表del a[0]来模仿deque.popleft().只想了解delpython的工作原理.例如:

a = [0,1,2,3,4,5]

a在记忆中处于一个连续的空间.在我调用之后del a[0],python会分配新空间并1,2,3,4,5在那里复制,或者它只会给出a一个新地址(与之相同a = a[1:]).

如果它分配新空间,它是否意味着del a[0]是O(len(a))操作？

如果del a[0]是相同的a = a[1:],Python会回收从数组中删除的内存空间吗？

我可以像这样简单地改变常规向量:

extern crate rand;
use rand::Rng;

fn shuffle(coll: &mut Vec<i32>) {
    rand::thread_rng().shuffle(coll);
}

问题是,我的代码现在需要使用std::collections::VecDeque替代,这导致此代码无法编译.

解决这个问题的最简单方法是什么？

我尝试使用inspect.getsource(deque),当它在集合中的其他模块上工作时,在deque上运行它会抛出错误"找不到类定义".为什么这只发生在deque上,我怎么能看到它的源代码？