我已经看到了编写一个返回boost :: shared_ptr的克隆方法的有用方法
class A
{
public:
shared_ptr<A> Clone() const
{
return(shared_ptr<A>(CloneImpl()));
}
protected:
virtual A* CloneImpl() const
{
return(new A(*this));
}
};
class B : public A
{
public:
shared_ptr<B> Clone() const
{
return(shared_ptr<B>(CloneImpl()));
}
protected:
virtual B* CloneImpl() const
{
return(new B(*this));
}
};
这允许使用与常规指针的协方差,同时仍将其包裹在智能指针的安全性中.我的问题是我的类B需要从boost :: enable_shared_from_this继承,因为在构造之后它需要用一个单独的类注册自己,将共享指针传递给它自己.我有一个Create方法,它包装构造和注册,以确保它们总是一起出现.但是,上述克隆方法实现无法处理此要求.注册不能在CloneImpl中发生,因为没有shared_ptr存在"拥有"该对象,阻止调用shared_from_this(),如果该逻辑不在虚函数中,则指向B的shared_ptr不知道B的注册需求什么时候克隆 处理这个问题的最佳方法是什么？
使用gcc 4.6和-O3,我使用简单的时间命令计时以下四个代码
#include <iostream>
int main(int argc, char* argv[])
{
double val = 1.0;
unsigned int numIterations = 1e7;
for(unsigned int ii = 0;ii < numIterations;++ii) {
val *= 0.999;
}
std::cout<<val<<std::endl;
}
案例1在0.09秒内运行
#include <iostream>
int main(int argc, char* argv[])
{
double val = 1.0;
unsigned int numIterations = 1e8;
for(unsigned int ii = 0;ii < numIterations;++ii) {
val *= 0.999;
}
std::cout<<val<<std::endl;
}
案例2在17.6秒内运行
int main(int argc, char* argv[])
{
double val = 1.0;
unsigned int numIterations = …以下示例代码在gcc下编译并按我希望的方式工作.它允许我使用函数定义作为模板参数来实例化一个对象,但是该类能够使用函数中的不同类型,就像它们作为类型模板参数单独传递一样.
template<class FuncSignature> class Obj;
template<class Type1, class Type2> class Obj<Type1 (Type2)>
{
public:
Type1 var1;
Type2 var2;
};
int main(int argc, char **argv)
{
Obj<char (int)> A;
A.var1 = 'a';
A.var2 = 3;
}
即使它似乎工作,我不知道这个代码是做什么的.为什么这段代码有效并且符合C++标准？
下面的代码用gcc v4.3.3编译,并且模板化的子类似乎覆盖了父级中的虚函数,但是这不会破坏你不能拥有虚拟模板函数的规则吗？或者是其他发生的事情,我不明白？
class BaseClass
{
public:
virtual void Func(int var)
{
std::cout<<"Base int "<<var<<std::endl;
}
virtual void Func(double var)
{
std::cout<<"Base double "<<var<<std::endl;
}
};
template <class TT>
class TemplateClass : public BaseClass
{
public:
using BaseClass::Func;
virtual void Func(TT var)
{
std::cout<<"Child TT "<<var<<std::endl;
}
};
int main(int argc, char **argv)
{
BaseClass a;
TemplateClass<int> b;
BaseClass *c = new TemplateClass<int>;
int intVar = 3;
double doubleVar = 5.5;
a.Func(intVar);
a.Func(doubleVar);
b.Func(intVar);
b.Func(doubleVar);
c->Func(intVar);
c->Func(doubleVar);
delete c;
}
然后输出: …
我与新的C++ 0x随机库中玩耍,并在此基础上的问题:
什么是获得的C++ 0x随机数生成器的状态的标准呢？
似乎如果你不知道随机生成器当前状态的种子,保存其状态的唯一方法是将生成器存储在流中.为此,我写了以下内容
#include <iostream>
#include <sstream>
#include <random>
int main(int /*argc*/, char** /*argv*/)
{
std::mt19937 engine1;
unsigned int var = engine1(); // Just to get engine1 out of its initial state
std::stringstream input;
input << engine1;
std::mt19937 engine2;
input >> engine2;
std::cout<<"Engine comparison: "<<(engine1 == engine2)<<std::endl;
std::cout<<"Engine 1 random number "<<engine1()<<std::endl;
std::cout<<"Engine 2 random number "<<engine2()<<std::endl;
}
这输出
发动机比较:1
发动机1随机数581869302
发动机2随机数4178893912
我有几个问题:
谢谢.
作为一个简化的例子,如果我有类
template <class T, class U> class ProcessEvent
{
public:
ProcessEvent(T* t) : var1(t) { var2 = new U; }
Process() { var2->Process(var1); }
private:
T* var1;
U* var2;
};
class Foo
{
/*data*/
};
class FooProcessor
{
void Process(Foo* foo) {/*functionality*/}
};
class Bar
{
/*data*/
};
class BarProcessor
{
void Process(Bar* bar) {/*functionality*/}
};
所以ProcessEvent类可以有两组不同的模板类型,
ProcessEvent<Foo, FooProcessor>
ProcessEvent<Bar, BarProcessor>
但是,第二个模板类型FooProcessor和BarProcessor直接由第一个模板类型暗示,并且是用户不关心的实现细节.我的目标是拥有与上面相同的功能,但让ProcessEvent只采用一个模板参数,Foo或Bar.除了通过ProcessEvent的专业化,这可以做到吗？