假设我有一些武断的类,A:
class A {
//... stuff
};
我想调用一个外部API,它接受一个指向某些类型的共享指针(,我不能更改这个接口):
//...much later
void foo(std::shared_ptr<A> _a){
//operate on _a as a shared_ptr
}
但是,在我正在处理的(遗留)代码中,我正在处理的类A实例是在堆栈上分配的(,我无法绕过):
A a;
//...some stuff on a
//Now time to call foo
最重要的是,A类的实例相当大,每个实例的大小为1GB。
我知
我有这个问题,有一个函数foo(),如下所示,
vector<ClassA> vec;
void foo()
{
ClassA a; //inside foo, a ClassA object will be created
a._ptr = new char[10];
vec.push_back(a); //and this newly created ClassA object should be put into vec for later use
}
vec将调用ClassA的copy-ctor来复制新创建的对象a,这就是问题所在。如果我
所以我有一个存储类,它有大量的基本功能,按原样非常有用。它有移动构造函数来允许按值返回。
class A
{
public:
virtual ~A(){}
A(const A& a);
A(A&& a);
A& operator=(const A& rhs);
A& operator=(A&& rhs);
int foo();//example member function
//example function returning by value, elision and
我了解如何移动对象,例如:
int a(5), b(6);
int c(std::move(a)); // move constructor
c = std::move(b); // move assignment
我理解自定义移动构造函数的常见实现(它获取动态指针的所有权,并将从指针移动到nullptr)。
但是,我还没有找到任何关于移动动态分配指针本身的信息。我需要确认以下代码是合法的:
int *p(new int(42));
int val(std::move(*p));
delete p; // I think this is no longer necessary. Is i
在做一个处理图论的项目时,我使用了这样的对象:
class Node{
vector<Node> nodeList;
};
Node n = new Node();
Node a = new Node();
n.nodeList.push_back(a);
在创建了大约20个节点,每个节点平均有3个连接到其他节点之后,我的程序基本上会挂起。
为了解决这个问题,我将我的对象声明改为
class Node{
vector<Node*> nodeList;
};
Node* n = new Node();
Node* a = new Node();
n.nodeList.pu
读完 to 后,我对boost::ptr_container和std::vector<shared_ptr>之间的区别感到好奇。我的印象是,在发布时会调用它包含的所有指针的析构函数,而不考虑其他对它的居民的引用。这与std::vector<shared_ptr>的目的相反,在释放之后,它只会在引用计数为0的情况下释放指针本身。
如果是这样的话(我假设不是),为什么Boost文档示例中的看起来它们的目的是相似的,为什么timday的答案会提出一个boost::ptr_container,而它与std::vector<shared_ptr>的目的非常不同。
我知道C++移动语义应该可以节省处理器的能力和内存,因为
Move::Move(Shallow&& source) noexcept // Move constructor
{
data = source.data; // Assume data is an array of size = size and all initiated to a user specific value
size = source.size;
source.size =0;
source.data ={nullptr};
}
假设所有数组索引都
我有一个对象RenderBuffer,它创建一个OpenGL缓冲区作为其构造函数的一部分,并将其作为析构函数的一部分销毁。这是个非常昂贵的手术。这个对象没有默认的构造函数,所以它通常被放在初始化列表中,或者被推入向量的后面,如果其中有很多:
Window::Window(Renderer & render)
: m_renderBuffer(render) // sometimes looks like this
{
m_multipleBuffer.push_back(RenderBuffer(render)) // othertimes can look like
std::make_shared在堆上生成一个控制块/对象对,只需要一个分配,并且控制块和对象与帮助局部性保持在很近的距离。
我希望这样做,但我希望将其创建为另一个类的聚合组件。我环顾了四周,但我没有看到这样的野兽。我是不是遗漏了什么?
例如。
struct Bar {};
struct Foo
{
// This would allocate the control block and object Bar on
// the heap, which is pointed at by Foo.
std::shared_ptr<Bar> x;
// Example
我有一个带有指向接口对象(让我们称之为pInterface)的(非智能)指针的类,并且我正在构建一个嵌套类,它也需要访问该接口。我将通过将指向接口的指针传递到嵌套类的构造函数中来解决此问题:
CNestedClass someClass( pInterface, ... );
然而,我不确定在嵌套类中存储这个指针的最佳方式。我可以使用:
1) A scoped (or other smart) pointer (to the original object)
2) A pointer to a pointer
你们有什么建议?为什么?
编辑:我应该澄清一下--嵌套类需要调用接口对象上的方法,
我有以下问题。我创建了一个类,并将指向该类的指针存储在另一个类中。创建之后,一切都是正常的。然而,一步之后,这个类似乎消失了。
我在这里写了一个非常简单的测试场景:
#include <iostream>
using namespace std;
class test
{
public:
test();
bool ok;
};
test::test()
{
ok = false;
}
class func
{
public:
func();
void check();
t