我有一个类A,它是类B和C的父类.还有一个类X,它是Y和Z的父类.
class A {};
class B : public A {};
class C : public A {};
class X
{
void foo(A) { std:: cout << "A"; }
};
class Y : public X
{
void foo(B) {std::cout << "B"; }
};
class Z : public X
{
void foo(c) {std<<cout <<"C"; }
};
int main()
{
B b;
C c;
Y y;
Z z;
y.foo(b);//prints B // b is a B, and Y::foo takes a B, hence print B
y.foo(c);//prints …我的代码
void build(std::vector<RKD <DivisionSpace> >& roots, ...) {
try {
// using a local lock_guard to lock mtx guarantees unlocking on destruction / exception:
std::lock_guard<std::mutex> lck (mtx);
roots.push_back(RKD<DivisionSpace>(...));
}
catch (const std::bad_alloc&) {
std::cout << "[exception caught when constructing tree]\n";
return;
}
}
现在,实际工作应该连续进行,而不是并行进行.
构造函数RKD可以与其他构造函数并行运行RKD.然而,推回物体std::Vector是一个关键部分,对吗？
我要构建的对象的数量是已知的.在实践中它将在[2,16]范围内.理论上它可以是任何正数.
此外,我对它们将被插入容器的顺序并不感兴趣.
所以我可以这样做:
RKD tree = RKD(...);
mutex_lock(...);
roots.push_back(tree);
然而,这意味着复制,不是吗？
我应该怎么做才能使我的代码并行？
由于这个答案,我决定使用锁(而不仅仅是互斥锁).
从c ++ 11开始,我可以在不创建和删除原始指针的情况下编写代码.但这是正确的方法 - 我应该总是使用智能指针(共享,独特或弱)或者是否有我应该自己删除对象的情况？
对于此代码,C++中有与智能指针相同的编码？
在External.cpp中:
class ExampleClass {...};
ExampleClass* function()
{
ExampleClass *ptr = new ExampleClass();
ptr->doSomething();
return ptr;
}
在Another.cpp中我想做这样的事情,怎么做？:
ExampleClass *ptr2 = function();
请查看以下代码
#include <iostream>
using namespace std;
class Memory
{
private:
int *memory;
public:
Memory()
{
memory = new int[3];
for(int i=0;i<3;i++)
{
memory[i] = i;
cout << memory[i] << endl;
}
}
~Memory()
{
delete[] memory;
}
};
int main()
{
cout << "Running" << endl;
Memory m;
// do I have to invoke ~Memory() ?
int *secondMemory = new int[5];
//How to clear the memory of 'secondMemory' ?
system("pause");
return 0;
}
在这里,我已经清除memory了类的析构函数中动态分配的数组的内存.但我的问题是
这些问题在代码的适当位置作为注释询问.请帮忙!
编辑 …