相关疑难解决方法(0)

是否有可能阻止对象的堆栈分配,并且只允许在堆上使用"new"进行隔离？

在我最初的基本测试中,这样做是完全安全的.然而,它已经让我吃惊试图操纵this该功能后delete小号this可能是一个运行时错误.这是真的,通常是安全的delete this吗？或者只有某些安全的情况？

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

我想知道下面的代码是否安全运行:

#include <iostream>
using namespace std;

class A
{
public:
    A() {
        cout << "Constructor" << endl;
    }
    ~A() {
        cout << "Destructor" << endl;
    }

    void deleteMe() {
        delete this;
        cout << "I was deleted" << endl;
    }
};

int main()
{
    A *a = new A();
    a->deleteMe();
    cout << "Exit ...";
    return 0;
}

输出是:

Constructor
Destructor
I was deleted
Exit ...

并且程序正常退出,但这里有一些内存访问暴力吗？

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

在C++中,可以删除函数定义中的自身对象.这有什么副作用？

class MyClass {

public:
    void ~myClass() {}
    void myFunction() { 
        // logic here
        delete this;
    }
}

谢谢!

这是明确定义的行为吗？

#include <functional>

void foo() {
    auto f = new std::function<void()>;
    *f = [f]() { delete f; };
    (*f)();
    f = nullptr;
}

int main() {
    foo();
}

使用最新的g ++,如果我在模板中执行此操作,它会在valgrind下运行时导致无效读取,否则它可以正常工作.为什么？这是g ++中的错误吗？

#include <functional>

template<std::size_t>
void foo() {
    auto f = new std::function<void()>;
    *f = [f]() { delete f; };
    (*f)();
    f = nullptr;
}

int main() {
    foo<0>();
}

以下代码

#include <iostream>
#include <map>

struct foo
{
  void kill(std::map<int, foo>& m, int i)
  {
    m.erase(i);
  }
};

int main()
{
  std::map<int, foo> m;

  m.emplace(1, foo() );

  std::cout << m.size() << std::endl;

  m[1].kill(m, 1);

  std::cout << m.size() << std::endl;
}

在没有警告的情况下编译(g ++),执行时没有错误,并且通过输出判断kill方法foo从地图中删除对象.但是,我觉得这可能实际上是未定义的行为.似乎kill在行之后的行m.erase(i) this不再指向有效对象.

C++标准对此有何看法？

呼唤void reset( pointer ptr = pointer() ) noexcept; 会调用以下操作

\n

给定 current_ptr（由 *this 管理的指针），按以下顺序执行以下操作：

\n

\n
1. 保存当前指针的副本 old_ptr = current_ptr
\n
2. 使用参数 current_ptr = ptr 覆盖当前指针
\n
3. 如果旧指针非空，则删除先前管理的对象 if(old_ptr) get_deleter()(old_ptr)。
\n

\n

参考参数

这个特殊命令的原因是什么？为什么不先执行 3)，然后再执行 2)？在这个问题中std::unique_ptr::reset 检查托管指针无效？第一个答案引用了标准

\n

[\xe2\x80\xa6] [ 注意：这些操作的顺序很重要，因为调用 get_deleter() 可能会破坏 *this。\xe2\x80\x94结束注]

\n

这是唯一的原因吗？怎么能get_deleter()毁掉unique_ptr（*this )呢？

我已经知道某些形式的"自杀"是安全的(被认为是合法的),但是,delete this在虚拟成员函数中执行是否特别安全？

注意,"安全",我的意思是编译器生成的"代码"是否能够处理构造.

注意,我对这样做的利弊并不感兴趣,只是我能考虑是否安全.

附带问题:语言标准是明确地还是隐含地要求实现支持任何形式的delete this习语？

我不认为这是重复的是删除这个允许吗？.我的问题是关于在虚拟成员函数中是否安全.

以下是我要追求的内容概述

class FooBase {
protected:
    virtual void on_idle() { /* no-op by default */ }
};

class Foo : public FooBase {
    void on_idle() override final
    {
        delete this;
    }
};

请注意,虽然Foo需要堆分配,但其他子类可能不会.

我有一个类似下面的Thread类

class Thread {
public:
  Thread();
  ~Thread();
  void start();
  void stop();
}

所以我需要从stop()方法调用析构函数,这是一个很好的方法吗？

我想知道是否可以通过析构函数方法删除对象？

我班级的构造函数和析构函数:

class cal
{
    public:
        cal()
        {
            days = 0;
            day = 1;
            month = 1;
            year = 1300;
            leap = true;
        };
        ~cal()
        {
            delete this;
        }
}*calendar = new cal;

如何通过类删除此指针？

PS

我忘了写下面的代码

cal *calandar = new cal[];

我想在堆中使用它而不是堆栈

我想经常使用这个类(对象)(很多那个对象)想象我应该写多少时间删除它,这使我难以理解,排除故障和跟踪代码我希望它们被自动销毁(在堆中)

当我执行"删除[]日历"时,我在我的班级中使用了以下代码,它减少了我的rams占用(使用的ram数量)它是否通过退出程序正常工作(销毁所有对象)？因为我使用GNU/Linus并且它使用或不使用那些行来破坏所有对象,我担心在windows中泄漏

void DisposeObject() { delete this; }