据Wiki称:
调用者将返回地址推送到堆栈上,被调用的子例程在它完成时弹出调用堆栈上的返回地址,并将控制转移到该地址。
来自Wiki的Pic:
我不太明白。假设我有一个C程序如下:
#include <stdio.h>
int foo(int x)
{
return x+1;
}
void spam()
{
int a = 1; //local variable
int b = foo(a); //subroutine called
int c = b; //local variable
}
int main()
{
我希望在多态情况下将派生类unique_ptr的所有权转移到它的抽象基类unique_ptr。怎么走?
class Fruit {
public:
virtual void print() = 0;
};
class Apple: public Fruit {
public:
string name;
virtual void print() { cout << " Apple name is " << name << endl; }
Apple(string name): name(name) {}
}
下面的unique_ptr是否按预期正确使用?代码以一些内存泄漏(可能是假阳性)结束。还是真正的泄密?)。我想把所有权转移到RunSimulation,在那里结束unique_ptr的生命,在循环中创建更新的,但是,这最终会导致访问冲突。
理想情况下,我希望main()中的一个unique_ptr对象在main()中过期,另一个在RunSimulation()外部发送以释放。
class Result { public: int n; };
void RunSimulation(std::unique_ptr<Result> result) {result->n = 0;}
我尝试过以下几种方法:
std::function<void ()> getAction(std::unique_ptr<MyClass> &&psomething){
//The caller given ownership of psomething
return [psomething](){
psomething->do_some_thing();
//psomething is expected to be released after this point
};
}
但是它不能编
我有一个具有std::unique_ptr类型字段的A类
class A
{
public:
std::unique_ptr pointer;
// class body
};
在代码中的某个地方,我使用了一些指向同一对象的std::shared_ptr。现在我想要实现的是将所有权转移到我的类中的这个std::unique_ptr,这样如果所有的shared_ptr都被销毁了,那么只要这个unique_ptr还活着,我的对象就会一直存活。
我的问题是-可以将所有权从std::shared_ptr转移到std::unique_ptr吗?如果可以,我如何做到这一点?
TL;DR
如果该元素是模板类的实例,而模板类也是从虚拟基类派生的,那么如何复制向量的最后一个元素呢?
我想要创建一个向量,它将充当一个撤销堆栈。堆栈应该包含基于浮点和字符串的对象(可能还有其他类型)。它可能包含所有的浮动,所有的字符串或两者的组合。当首次添加浮点或字符串时,我希望将其副本添加到堆栈中。
到目前为止,这就是我所拥有的:
class Base
{
...
virtual bool func1() = 0;
}
带有模板参数的派生类。
template<typename T>
class derived : public base {...}
这两个人
class f
是否可以从std::unique_ptr<T>创建堆栈变量(具有移动构造函数的T类型 我试过这样的东西 std::unique_ptr<T> p = ext_get_my_pointer(); // external call returns a smart pointer
T val{std::move(*p.release())}; // I actually need a stack variable 但它看起来很丑陋,而且显然造成了内存泄漏。不过,我不知道为什么。
如果函数Foo()将std::unique_ptr的所有权转移到函数Bar()并假设Bar()抛出异常,则std::unique_ptr中包含的对象将被销毁。
在这种情况下,如何处理Foo()可能希望保留所有权的情况。
class A
{
public:
std::unique_ptr<SomeData> getSomeData(...);
};
class B
{
public:
pushToQ(std::unique_ptr<SomeData>);
doSomething()
...
popFromQ();
...
在C++编程语言中,有以下示例(3.2.4节)。
unique_ptr<Shape> read_shape(istream& is);
void user()
{
vector<unique_ptr<Shape>> v;
while (cin)
v.push_back(read_shape(cin));
draw_all(v);
// call draw() for each element
rotate_all(v,45);
// call rotate(45) for each e
转发std::unique_ptr的正确方式通常是什么?
下面的代码使用std::move,我认为这是经过深思熟虑的做法,但它崩溃了。
class C {
int x;
}
unique_ptr<C> transform1(unique_ptr<C> p) {
return transform2(move(p), p->x); // <--- Oops! could access p after move construction takes place, compiler-dependant
}
unique_ptr<C> t
我已经在堆栈溢出上阅读了类似于这个问题的各种评论,但没有找到我的问题的确切解决方案。我有一个基类和派生类,也是一个包含并保持这个对象所有权的类。
class Base { };
class Derived: public Base { };
class MyClass
{
std::vector<std::unique_ptr<Base>> myVector;
public:
MyClass() {}
void addElement (std::unique_ptr<Base> &base)
{
myVector.push
当在创建了多个对象的构造函数中抛出bad_alloc异常时,必须做些什么来清理内存。例如。
class Object
{
private:
A * a;
B * b;
public:
Object()
{
a= new A();
b= new B(); //So if a bad_alloc is called here, how is a deleted???
}
}
我的直觉是每次调用new都放在一个单独的try catch块中,然后删除所有之前调用过new的对象,但这太冗长了(第一个try块不调用析构函数,
最初,我创建了一个采用抽象类型的GameState*的堆栈。那就是..。
std::stack<GameState*> gameStates
然而,有人告诉我,如果我想保留所有权,我应该使用C++11的智能指针unique_ptr。那就是..。
std::stack<std::unique_ptr<GameState>> gameStates
现在,每当我将我的GameState推到堆栈上时,我的编译器就会抱怨。显然我做错了什么..。
上面说..。
no instance of overloaded function matches the argument
我在成员函数定义中的一些代码上遇到了问题。
从.h文件:
//This is a private type
struct node {
node *next;
node *prev;
T *o;
};
从.cpp文件中产生错误的代码:
template <typename T>
void Dlist<T>::function(T *o)
{
node newV = new node;
....
}
我认为这是声明结构的正确语法,并且我得到了一个""node in not declaring in this scope“”错误。
然后我
在Linux和GCC 8.1上使用Netbeans 8.2,unique_ptr::operator->()给出了错误的Unable to resolve template based identifier {var}警告,更重要的是不会自动完成成员名称。
代码编译和运行都很好,令人惊讶的是,如果使用的是shared_ptr 而不是,那么自动完成仍然不带警告。我不知道这怎么可能。下面是一个有问题的例子,以供参考
#include <iostream>
#include <memory>
struct C { int a;};
int main () {
s