当我收到代码评论评论说虚拟功能不需要内联时,我收到了这个问题.
我认为在直接在对象上调用函数的场景中,内联虚函数可以派上用场.但是我想到的反驳论点是 - 为什么要想定义虚拟然后使用对象来调用方法呢？
最好不要使用内联虚拟功能,因为它们几乎从未扩展过吗？
我用于分析的代码片段:
class Temp
{
public:
virtual ~Temp()
{
}
virtual void myVirtualFunction() const
{
cout<<"Temp::myVirtualFunction"<<endl;
}
};
class TempDerived : public Temp
{
public:
void myVirtualFunction() const
{
cout<<"TempDerived::myVirtualFunction"<<endl;
}
};
int main(void)
{
TempDerived aDerivedObj;
//Compiler thinks it's safe to expand the virtual functions
aDerivedObj.myVirtualFunction();
//type of object Temp points to is always known;
//does compiler still expand virtual functions?
//I doubt compiler would be this much intelligent!
Temp* pTemp = &aDerivedObj;
pTemp->myVirtualFunction();
return …我正在使用std :: queue来实现JobQueue类.(基本上这个类以FIFO方式处理每个作业).在一种情况下,我想一次性清除队列(从队列中删除所有作业).我没有看到std :: queue类中有任何明确的方法.
如何有效地为JobQueue类实现clear方法？
我有一个简单的循环弹出解决方案,但我正在寻找更好的方法.
//Clears the job queue
void JobQueue ::clearJobs()
{
// I want to avoid pop in a loop
while (!m_Queue.empty())
{
m_Queue.pop();
}
}
我总是想知道为什么在删除后将指针自动设置为NULL 不是标准的一部分.如果这一点得到解决,那么由于指针无效而导致的许多崩溃都不会发生.但是,我已经说过,我可以想到为什么标准会限制这个:
性能:
额外的指令可能会降低
delete性能.可能是因为
const指针.然后标准可能已经为这个特殊情况做了一些事情我想.
有没有人知道不允许这个的确切原因？
我试图根据特定情况从地图中删除一系列元素.我如何使用STL算法？
最初我想使用remove_if但不可能因为remove_if不适用于关联容器.
是否有适用于地图的"remove_if"等效算法？
作为一个简单的选项,我想到循环遍历地图并擦除.但是循环遍历地图并删除安全选项？(因为迭代器在擦除后变为无效)
我使用以下示例:
bool predicate(const std::pair<int,std::string>& x)
{
return x.first > 2;
}
int main(void)
{
std::map<int, std::string> aMap;
aMap[2] = "two";
aMap[3] = "three";
aMap[4] = "four";
aMap[5] = "five";
aMap[6] = "six";
// does not work, an error
// std::remove_if(aMap.begin(), aMap.end(), predicate);
std::map<int, std::string>::iterator iter = aMap.begin();
std::map<int, std::string>::iterator endIter = aMap.end();
for(; iter != endIter; ++iter)
{
if(Some Condition)
{
// is it safe ?
aMap.erase(iter++);
}
}
return 0;
}
我对std :: remove算法的使用之间的区别感到有点困惑.具体来说,我无法理解使用此算法时要删除的内容.我写了一个像这样的小测试代码:
std::vector<int> a;
a.push_back(1);
a.push_back(2);
std::remove(a.begin(), a.end(), 1);
int s = a.size();
std::vector<int>::iterator iter = a.begin();
std::vector<int>::iterator endIter = a.end();
std::cout<<"Using iter...\n";
for(; iter != endIter; ++iter)
{
std::cout<<*iter<<"\n";
}
std::cout<<"Using size...\n";
for(int i = 0; i < a.size(); ++i)
{
std::cout<<a[i]<<"\n";
}
两种情况下的输出均为2,2.
但是,如果我使用erase删除这样的东西:
a.erase(std::remove(a.begin(), a.end(), 1), a.end());
我得到输出为2.
所以我的问题是:
(1).有没有使用std :: remove而不是使用擦除功能.
(2).即使在执行std :: remove之后,为什么a.size()返回2而不是1？
我在Scott Meyer的Effective STL书中读到了关于擦除删除习语的内容.但我仍然有这种困惑.
作为扩展到这个问题是const_iterators更快？,我有另一个问题const_iterators.如何删除一个常量const_iterator？虽然迭代器是指针的通用形式,但仍然const_iterator和iterators是两个不同的东西.因此,我相信,我也不能用来const_cast<>转换const_iterator为iterators.
一种方法可能是您定义一个迭代器,该迭代器将元素移动到该const_iterator点的元素.但这看起来像是一个线性时间算法.
对于实现这一目标的最佳方法有什么想法吗？
我有一些关于从函数返回对局部变量的引用的问题:
class A {
public:
A(int xx)
: x(xx)
{
printf("A::A()\n");
}
};
const A& getA1()
{
A a(5);
return a;
}
A& getA2()
{
A a(5);
return a;
}
A getA3()
{
A a(5);
return a;
}
int main()
{
const A& newA1 = getA1(); //1
A& newA2 = getA2(); //2
A& newA3 = getA3(); //3
}
我的问题是=>
执行getA1()是否正确？我觉得它是错误的,因为它返回局部变量的地址或临时变量.
main(1,2,3)中的哪些陈述会导致未定义的行为？
在const A& newA1 = getA1();做标准的保证,暂时由const引用约束不会被破坏,直到引用超出范围是什么？
我们的编码指南更喜欢const_iterator,因为它们比正常情况下快一点iterator.看起来编译器会在您使用时优化代码const_iterator.
这真的是对的吗？如果是的话,内部真正发生的事情会变得const_iterator更快吗？
编辑:我写了一个小测试来检查const_iteratorvs iterator,发现不同的结果:
对于迭代10,000个对象const_terator,花费几毫秒(大约16毫秒).但并非总是如此.有两次相等的迭代.
我有一个包含很少非相邻重复项的向量.
举个简单的例子,考虑一下:
2 1 6 1 4 6 2 1 1
我试图vector通过删除不相邻的重复项并保持元素的顺序来使这个独特.
结果将是:
2 1 6 4
我尝试的解决方案是:
手动重复消除:
Define a temporary vector TempVector.
for (each element in a vector)
{
if (the element does not exists in TempVector)
{
add to TempVector;
}
}
swap orginial vector with TempVector.
我的问题是:
是否有任何STL算法可以从向量中删除不相邻的重复项？它的复杂性是什么？
在调试时,我看到了STL vector :: empty()实现:
bool empty() const
{return (size() == 0); }
我相信,每当我们探测向量的空虚时,总是建议使用空的大小().但是看到这个实现,我想知道,这样做有什么好处？相反,在调用empty时会有一个函数调用开销,因为它在内部调用size()== 0.
我认为在列表的情况下empty()可能会有用,因为size()不保证列表中的常量时间.为了验证我的假设,我检查了列表实现,令人惊讶的是,在列表中也找到了相同的实现,
return (size() == 0);
我现在有点困惑.如果empty在内部使用size()那么我们为什么要选择empty over size()？