检查这是否为空

Question

检查 this 是否为空有意义吗？

假设我有一个带有方法的类；在该方法中，我检查this == NULL，如果是，则返回错误代码。

如果 this 为 null，则表示该对象已被删除。该方法甚至能够返回任何东西吗？

更新：我忘了提到该方法可以从多个线程调用，它可能会导致对象被删除，而另一个线程在该方法中。

Answer 1

检查 this==null 是否有意义？我在进行代码审查时发现了这一点。

在标准 C++ 中，它不会，因为对空指针的任何调用已经是未定义的行为，因此任何依赖于此类检查的代码都是非标准的（甚至无法保证检查会被执行）。

请注意，这也适用于非虚拟函数。

但是，某些实现允许this==0，因此专门为这些实现编写的库有时会将其用作 hack。这种组合的一个很好的例子是 VC++ 和 MFC - 我不记得确切的代码，但我清楚地记得在某处看到 if (this == NULL) 检查 MFC 源代码。

它也可能作为调试帮助，因为在过去的某个时候，由于调用者中的错误，此代码被this==0 命中，因此插入了一个检查以捕获未来的实例。不过，对于此类事情，断言会更有意义。

如果 this == null 则表示该对象已被删除。

不，不是那个意思。这意味着在空指针或从空指针获得的引用上调用了一个方法（尽管获得这样的引用已经是 U.B.）。这与delete 无关，并且不需要任何此类对象曾经存在过。

Answer 2

您关于线程的注释令人担忧。我很确定您有可能导致崩溃的竞争条件。如果一个线程删除一个对象并将指针归零，另一个线程可以在这两个操作之间通过该指针进行调用，导致this 为非空且无效，从而导致崩溃。同样，如果一个线程调用一个方法，而另一个线程正在创建对象，你也可能会遇到崩溃。

简短的回答，您确实需要使用互斥锁或其他东西来同步对该变量的访问。您需要确保this 从不为空，否则您将遇到问题。

Answer 3

我知道这是旧的，但我觉得现在我们正在处理 C++11-17，有人应该提到 lambdas。 如果您将 this 捕获到稍后将异步调用的 lambda 中，则您的“this”对象可能会在该 lambda 被调用之前被销毁。

即将它作为回调传递给一些耗时的函数，该函数从单独的线程运行或通常只是异步运行

编辑：为了清楚起见，问题是“检查这是否为空有意义吗”我只是提供了一个场景，它确实有意义，随着现代 C++ 的广泛使用可能会变得更加普遍。

人为的例子： 这段代码是完全可运行的。要查看不安全行为，只需注释掉对安全行为的调用并取消注释不安全行为调用。

#include <memory>
#include <functional>
#include <iostream>
#include <future>

class SomeAPI
{
public:
    SomeAPI() = default;

    void DoWork(std::function<void(int)> cb)
    {
        DoAsync(cb);
    }

private:
    void DoAsync(std::function<void(int)> cb)
    {
        std::cout << "SomeAPI about to do async work\n";
        m_future = std::async(std::launch::async, [](auto cb)
        {
            std::cout << "Async thread sleeping 10 seconds (Doing work).\n";
            std::this_thread::sleep_for(std::chrono::seconds{ 10 });
            // Do a bunch of work and set a status indicating success or failure.
            // Assume 0 is success.
            int status = 0;
            std::cout << "Executing callback.\n";
            cb(status);
            std::cout << "Callback Executed.\n";
        }, cb);
    };
    std::future<void> m_future;
};

class SomeOtherClass
{
public:
    void SetSuccess(int success) { m_success = success; }
private:
    bool m_success = false;
};
class SomeClass : public std::enable_shared_from_this<SomeClass>
{
public:
    SomeClass(SomeAPI* api)
        : m_api(api)
    {
    }

    void DoWorkUnsafe()
    {
        std::cout << "DoWorkUnsafe about to pass callback to async executer.\n";
        // Call DoWork on the API.
        // DoWork takes some time.
        // When DoWork is finished, it calls the callback that we sent in.
        m_api->DoWork([this](int status)
        {
            // Undefined behavior
            m_value = 17;
            // Crash
            m_data->SetSuccess(true);
            ReportSuccess();
        });
    }

    void DoWorkSafe()
    {
        // Create a weak point from a shared pointer to this.
        std::weak_ptr<SomeClass> this_ = shared_from_this();
        std::cout << "DoWorkSafe about to pass callback to async executer.\n";
        // Capture the weak pointer.
        m_api->DoWork([this_](int status)
        {
            // Test the weak pointer.
            if (auto sp = this_.lock())
            {
                std::cout << "Async work finished.\n";
                // If its good, then we are still alive and safe to execute on this.
                sp->m_value = 17;
                sp->m_data->SetSuccess(true);
                sp->ReportSuccess();
            }
        });
    }
private:
    void ReportSuccess()
    {
        // Tell everyone who cares that a thing has succeeded.
    };

    SomeAPI* m_api;
    std::shared_ptr<SomeOtherClass> m_data = std::shared_ptr<SomeOtherClass>();
    int m_value;
};

int main()
{
    std::shared_ptr<SomeAPI> api = std::make_shared<SomeAPI>();
    std::shared_ptr<SomeClass> someClass = std::make_shared<SomeClass>(api.get());

    someClass->DoWorkSafe();

    // Comment out the above line and uncomment the below line
    // to see the unsafe behavior.
    //someClass->DoWorkUnsafe();

    std::cout << "Deleting someClass\n";
    someClass.reset();

    std::cout << "Main thread sleeping for 20 seconds.\n";
    std::this_thread::sleep_for(std::chrono::seconds{ 20 });

    return 0;
}

Answer 4

FWIW，我在断言中使用了(this != NULL) 的调试检查，之前有助于捕获有缺陷的代码。并不是说如果没有崩溃代码就一定会走得太远，而是在没有内存保护的小型嵌入式系统上，断言确实有帮助。

在具有内存保护的系统上，如果使用 NULL this 指针调用操作系统通常会遇到访问冲突，因此断言 this != NULL 的价值较小。但是，请参阅 Pavel 的评论，了解为什么即使在受保护的系统上它也不一定毫无价值。

Answer 5

您的方法很可能（可能因编译器而异）能够运行并且能够返回一个值。只要它不访问任何实例变量。如果它尝试这样做，它将崩溃。

正如其他人指出的那样，您不能使用此测试来查看对象是否已被删除。即使可以，它也不会起作用，因为该对象可能会在测试之后但在测试之后执行下一行之前被另一个线程删除。请改用线程同步。

如果this 为空，则您的程序中存在错误，很可能在您的程序设计中。

Answer 6

我还要补充一点，通常最好避免使用 null 或 NULL。我认为这里的标准再次发生变化，但现在 0 确实是您要检查的内容，以绝对确保您得到您想要的。

Answer 7

这只是作为第一个参数传递给函数的指针（这正是使它成为方法的原因）。只要您不是在谈论虚拟方法和/或虚拟继承，那么是的，您会发现自己正在执行一个带有空实例的实例方法。正如其他人所说，在出现问题之前，您几乎肯定不会在该执行中走得太远，但健壮的编码可能应该使用断言检查这种情况。至少，当您怀疑它可能由于某种原因发生但需要准确跟踪它发生在哪个类/调用堆栈中时，这是有道理的。

Answer 8

我知道这是一个老问题，但我想我会分享我使用 Lambda 捕获的经验

#include <iostream>
#include <memory>

using std::unique_ptr;
using std::make_unique;
using std::cout;
using std::endl;

class foo {
public:
    foo(int no) : no_(no) {

    }

    template <typename Lambda>
    void lambda_func(Lambda&& l) {
        cout << "No is " << no_ << endl;
        l();
    }

private:
    int no_;
};

int main() {
    auto f = std::make_unique<foo>(10);

    f->lambda_func([f = std::move(f)] () mutable {
        cout << "lambda ==> " << endl;
        cout << "lambda <== " << endl;
    });

    return 0;
}

此代码段错误

$ g++ -std=c++14  uniqueptr.cpp  
$ ./a.out 
Segmentation fault (core dumped)

如果我从lambda_func 中删除std::cout 语句，代码将运行到完成。

看起来，这条语句f->lambda_func([f = std::move(f)] () mutable { 在调用成员函数之前处理 lambda 捕获。