相关疑难解决方法(0)

可能重复:
C++:删除这个？
面向对象的自杀或删除此;

我正在通过阅读非常好的C++ Primer来学习C++,并且我正在学习C++如何通过delete像C这样的关键字释放内存free.Java和Pascal没有这种用于释放内存的机制.如果程序运行很长时间并且变量被破坏,那么它可能会导致程序错误,因此不应该忽略它.

简而言之,我想知道它是合法的还是可以推荐的,例如在C++中变量可以做this.delete()和删除自己.我们大多听说过在C和C++中释放指针,这是用新的free和delete关键字完成的.Pascal也有指针,但Java没有.所以在Java中它不应该是可能的,因为你没有明确删除对象,C没有对象,因此一个struct不能free为它分配即使因为C没有对象也不是技术上是可行的内存确实帕斯卡.

因此,我认为离开C++是为了我的问题,对象是否合法删除自己的类似的东西this.delete()？

可能重复:
C++:删除这个？

我正在尝试创建一个管理游戏状态的系统.

我当前设计的问题是,当我切换状态时,在控制切换到新状态之前删除旧状态.

以下是我的代码的简化版本:

class StateManager;

class State
{
public:
    virtual void update(StateManager &manager)= 0;
    virtual ~State(){}
};


class StateManager
{
public:
    void setState(std::unique_ptr<State> && newState )
    {
        currentState = std::move(newState);
    }
    std::unique_ptr<State> currentState;

    void run()
    {
        currentState->update(*this);
    }
};

请注意,如果State对象在update方法中调用StateManager :: setState,则会有一段时间在刚刚销毁的对象上调用成员函数.

有关此行为的完整示例,请访问http://ideone.com/WHLzJL.注意在FirstState :: update返回之前如何调用FirstState的析构函数.

这是C++中未定义的行为吗？如果是这样,我应该如何改变我的设计？

鉴于以下内容:

#include <iostream>
using namespace std;

class A
{
public:
    void func() {delete this;}
    A() : x(5) {cout << "ctor A" << endl;}
    ~A() {cout << "dtor A" << endl;}
    int x;
};

int main() {
    A a;
    cout << "The X value: " << a.x << endl;
    a.func();  // calling 'delete this' ->going to the dtor #1
    cout << "The X value: " << a.x << endl;
    return 0;  
}

输出是:

ctor A
The X value: 5
dtor A …

一个对象a类的A调用对象b的类的B，通过指针：

void A::fun(){
  bPtr->delete_me();
}

在被调用函数中，我们通过一个指针（之前存储了该指针）删除了调用对象：

void B::delete_me(){
  delete aPtr;
}

这是安全的，因为A它不调用后访问任何成员bPtr->delete_me();？

当我编写一个演示字符串类时，在复制赋值函数中，我尝试在复制之前通过“删除此”来清除自身。但它失败了。

    Str &operator=(const Str &s) {
        if (this != &s) {  // self-assignment check
            //delete this; //cannot run as I imagine
            this->~Str();  
            _size = s._size;
            _str = new char[_size + 1];
            memcpy(_str, s._str, _size + 1);
        }
        return *this;
    }
    ~Str() {
        _size = 0;
        delete[] _str;
    }

linux 告诉我的

双释放或损坏（出）中止（核心转储）

我有点困惑试图理解这里发生的事情。如果一个类对象调用一个方法，然后该方法随后销毁该对象，那么该方法不应该返回，并且应该立即销毁该对象并立即调用析构函数。对吗？但相反，代码只是崩溃了。那么，是否不允许对象调用删除自身的方法？我假设从调用堆栈的工作原理来看，指向对象的指针将被销毁，因此当函数返回到调用者时，在进一步调用调用堆栈时指针不再有效？

class Foo
{
public:
    virtual void Run()
    {
        printf("Entering callback\n");
        RunSomeCallback();
        printf("We're back from callback\n");
    }
    virtual void RunSomeCallback() = 0;
    
    virtual ~Foo()
    {
        printf("We're Destroyed\n");
    }
};

Foo* f = nullptr;

void DestroyFoo();

class Bar : public Foo
{
public:
    virtual void RunSomeCallback()
    {
        printf("Inside callback\n");
        DestroyFoo();
    }
};


void DestroyFoo()
{
    printf("Deleting foo\n");
    delete f;
}
int main()
{
    f = new Bar();
    f->Run();
    return 0;
}

然后，当我使用shared_ptr运行代码时，行为似乎发生了变化，但在这种情况下，析构函数在打印“我们从回调中返回”之前被调用，代码运行，但这是否是未定义的行为？

class Foo
{
public:
    virtual void Run()
    {
        printf("Entering …

我有以下代码,我得到堆栈溢出错误任何人都可以请解释我这里有什么问题.从我的理解,这个指针指向当前对象,所以为什么我不能在析构函数中删除它;

class Object 
{
private:
    static int objCount;
public:
    int getCount()
    {
        int i =10;
        return i++;
    }
    Object()
    {
        cout<< "Obj Created = "<<++objCount<<endl;
        cout <<endl<<this->getCount()<<endl;
    }
    ~Object()
    {
        cout<<"Destructor Called\n"<<"Deleted Obj="<<objCount--<<endl;
        delete this;
    }
};

int Object::objCount = 0;

int _tmain(int argc, _TCHAR* argv[])
{


    {
        Object obj1;
    }

    {

              Object *obj2 = new Object();
    }
    getchar();
    return 0;
}