我有一个用户定义的结构struct theName,我想制作这些结构(deque<theName> theVar)的双端队列.但是,当我尝试编译时,我收到此错误:
In file included from main.cpp:2:
Logger.h:31: error: ISO C++ forbids declaration of ‘deque’ with no type
Logger.h:31: error: expected ‘;’ before ‘<’ token
为什么我不能这样做？
#ifndef INC_LOGGER_H
#define INC_LOGGER_H
#include <deque>
#include "Motor.h"
struct MotorPoint {
double speed;
double timeOffset;
};
class Logger{
private:
Motor &motor;
Position &position;
double startTime;
(31) deque<MotorPoint> motorPlotData;
double getTimeDiff();
public:
Logger(Motor &m, Position &p);
//etc...
};
#endif
我正在与一个图书馆合作,我必须与工会合作.具体来说,我正在使用SDL和SDL_Event联合.我需要复制SDL_Events,我找不到关于使用联合重载赋值运算符的好信息.
如果我可以重载赋值运算符,我应该手动筛选联合成员并复制相关成员,或者我可以简单地来一些成员(这对我来说似乎很危险),或者只是使用memcpy()(这看似简单快速,但有点危险)？
如果我不能超载运营商那么我最好的选择是什么呢？我想我可以制作新副本并传递一堆指针,但在这种情况下我宁愿不这样做.
欢迎任何想法!
编辑:按要求错误消息,顺便说一下,我想我已经学到了一些东西......
physworld.cpp:325: error: no match for ‘operator=’ in ‘CurrentEvent = ((physworld*)this)->physworld::SDL_UserInputEvents.std::queue<_Tp, _Sequence>::pop [with _Tp = SDL_Event, _Sequence = std::deque<SDL_Event, std::allocator<SDL_Event> >]()’ /usr/include/SDL/SDL_events.h:220: note: candidates are: SDL_Event& SDL_Event::operator=(const SDL_Event&)
编辑2:这太愚蠢......我认为Deqeues pop()成员返回了删除的项目.我认为代码非常简单,不能直接成为我的代码,但事实证明这是错误的.
我的代码看起来像:
for(SDL_Event CurrentEvent; !DequeueOfSDLEvents.empty(); CurrentEvent = DequeueOfSDLEvents.pop() )
{
//Do stuff
}
所以,如果没有别的,我将学习更仔细地看看我最近没有用过的容器的成员函数.感谢您解释默认情况下的分配工作,否则需要更长的时间才能找到它.
请原谅我以这样一般的方式询问,因为我确信他们的表现取决于他们如何使用它们,但在我的情况下collections.deque,比collections.defaultdict我想要验证值的存在时要慢.
我使用Peter Norvig的拼写校正来验证用户对一小组单词的输入.由于我没有使用带有单词频率的字典,所以我使用了一个简单list而不是defaultdict一开始,但是deque一旦我注意到单个单词查找花了大约25秒就用它替换它.
令人惊讶的是,这并不比使用a更快,list所以我defaultdict几乎立即返回使用返回的结果.
有人可以向我解释这种性能差异吗？
提前致谢
PS:如果你们中的一个想要重现我正在谈论的内容,请在Norvig的脚本中更改以下行.
-NWORDS = train(words(file('big.txt').read()))
+NWORDS = collections.deque(words(file('big.txt').read()))
-return max(candidates, key=NWORDS.get)
+return candidates
我有一个代码块,我在一个pthread(让我们调用这个线程a),我希望产生一个新的pthread(让我们调用这个线程b).线程b需要传递一个双端队列,我有以下代码:
void* process_thread_b(void* arg)
{
deque<string> *ptr = (deque<string>*)arg;
cout << "Size -" << ptr->size() << endl;
deque<string>::iterator it;
for(it = ptr->begin(); it != ptr->end(); it++)
{
cout <<(*it) << endl;
}
}
上面的代码是线程b's代码.它传递一个双端队列并正确打印出大小.我尝试打印出任何元素的那一刻,我得到:
terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc
Abort (core dumped)
当我产生pthread时,我使用下面的代码......
deque<string> myDeque;
// Add strings to deque here...
pthread_t dispatchCommands;
pthread_create(&dispatchCommands, NULL, &process_thread_b, (void*)&myDeque);
底部代码发生在线程中a.为什么当我尝试打印出deque的一个元素时,我收到一个错误,但我可以得到它的大小？
我正在编写一个编译器并使用deque来存储类的方法标签,这里是示例代码:
#include <deque>
#include <iostream>
#include <string>
using std::cout;
using std::deque;
using std::endl;
using std::string;
int main()
{
deque<const char *> names;
string prefix = "___";
const char *classname = "Point";
const char *methodname[] = {"Init", "PrintBoth", "PrintSelf", "equals"};
for (int i = 0; i < 4; i++)
{
string label = prefix + classname + "." + methodname[i];
names.push_back(label.c_str());
}
for (int i = 0; i < 4; i++)
cout << names[i] << endl;
return 0;
}
但是,结果并不是我所期望的:
___Point …这个方法:
void LRU::displayQueue() const
{
for(iter = m_buffer.begin(); iter != m_buffer.end(); ++iter)
std::cout << (*iter) << " ";
std:: cout << std::endl;
}
导致以下错误:
lru.cpp:58: error: passing 'const std::_Deque_iterator<int, const int&, const int*>' as 'this' argument of 'std::_Deque_iterator<int, const int&, const int*>& std::_Deque_iterator<int, const int&, const int*>::operator=(const std::_Deque_iterator<int, const int&, const int*>&)' discards qualifiers
m_buffer并iter在我的头文件中声明,其中缓冲区被声明为deque类型int并且iter是常量迭代器:
// ...
std::deque<int> m_buffer;
std::deque<int>::const_iterator iter;
// ...
取出const的displayQueue方法将消除编译器错误,但由于在这个功能应该不修改任何数据deque,我想保持我的代码"常量纠正",以更加明确.当我的迭代器是一个时,为什么会导致错误 const_iterator …
这是一个简单的程序
#include <iostream>
#include <deque>
#include <string.h>
std :: deque <char> d;
int main ()
{
const char * X = "abcdefg";
d .insert (d .end (), X, X + strlen (X));
d .erase (d .begin (), d .begin () + 4);
d .insert (d .end (), X, X + strlen (X));
std :: cout .write (& d [0], d .size ());
}
我希望输出为"efgabcdefg",实际输出为十六进制
65 66 67 00 00 00 00 C9 0B 02
这是"efg ???????"
出了什么问题？
我有这个小片段在GCC上表现得非常好(如预期的那样).
#include <deque>
#include <iostream>
#include <algorithm>
std::deque<int> values = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int main()
{
typedef std::deque<int>::iterator buf_iterator;
buf_iterator itr = values.begin() + 1;
const int K = 5;
buf_iterator i = std::max(itr - K, values.begin());
int pos = i - values.begin();
std::cout << *i << std::endl;
return 0;
}
但是,在MSVC 2013和2015上运行会产生调试断言:"deque迭代器不可解除引用".的值pos在这种情况下-4,而零的预期.
我知道使用以下方法将矢量"转换"为c样式数组是合法的:
std:vector<char> v;
char *c = &v[0];
对于std :: deque来说也是如此吗？
说我有一个std::deque<int> d含有100个值,从0到99.鉴于以下内容:
与向量不同,deques不能保证将其所有元素存储在连续的存储位置中:通过将指针偏移到另一个元素来访问双端队列中的元素会导致未定义的行为.
它似乎在下面的行无效:
int invalidResult = *(d.begin() + 81); // might give me 81, but NOT GUARANTEED, right?
我的问题是:迭代器会处理这个问题吗？
std::deque<int>::iterator it = d.begin();
int isThisValid = *(it + 81); // 81 every time? or does it result in undefined behavior?
有一次,我曾经认为迭代器会处理底层存储中的任何不连续性,但现在我不太确定.显然,如果你使用it++81次,*it会给你81一个结果.
有人可以说肯定吗？
对于它的价值,我不是在使用C++ 11.