Vérifier si c'est null

Votre remarque à propos des threads est inquiétant. Je suis sûr que vous avez une condition qui peut conduire à un accident. Si un thread supprime un objet et de zéros le pointeur, un autre thread pourrait faire un appel par le pointeur entre ces deux activités, la this étant non nulle, et aussi pas valide, résultant dans un accident. De même, si un thread appelle la méthode tandis qu'un autre thread est dans le milieu de la création de l'objet, vous pouvez également obtenir un crash.

Réponse courte, vous avez vraiment besoin d'utiliser un mutex ou quelque chose à synchonize accès à cette variable. Vous devez vous assurer que this est jamais null ou vous allez avoir des problèmes.

Je sais que c'est vieux, mais je sens que maintenant que nous avons affaire avec le C++11-17 quelqu'un doit mentionner les lambdas. Si vous capturez ce dans un lambda qui va être appelée de façon asynchrone à un point plus tard dans le temps, il est possible que votre objet est détruit avant que la lambda est invoquée.

je.e de le transmettre comme un rappel pour un certain temps-cher fonction qui est exécutée à partir d'un thread séparé ou seulement de manière asynchrone en général

EDIT: Juste pour être clair, la question était "est-il toujours un sens pour vérifier si c'est null" j'offre simplement un scénario où il n'a de sens que pourrait devenir plus fréquent avec l'utilisation plus large de C++ moderne.

Exemple artificiel:
Ce code est complètement runable. À voir le comportement à risque simplement en commentaire l'appel à un comportement sécuritaire et décommenter les comportements dangereux appel.

#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;
}

Je sais que c'est une vieille question, mais je pensais que je vais partager mon expérience avec l'utilisation de Lambda capture

#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;
}

Ce segment de code défauts

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

Si je supprime le std::cout déclaration de lambda_func Le code s'exécute à la fin.

Semble-t-il cette déclaration f->lambda_func([f = std::move(f)] () mutable { processus lambda capture avant que membre de la fonction est appelée.

C'est juste un pointeur passé comme premier argument à une fonction (ce qui est exactement ce qui en fait une méthode). Tant que vous ne parlez pas de méthodes virtuelles et/ou de l'héritage virtuel, alors oui, vous pouvez trouver vous-même l'exécution d'une méthode d'instance, avec une instance null. Comme les autres ont dit, vous avez presque certainement ne serez pas aller très loin avec cette exécution, avant que les problèmes surviennent, mais robuste, le codage doit probablement la vérification de cette situation, avec une assertion. Au moins, il a un sens quand vous pensez que cela pourrait être présentes pour une raison quelconque, mais de trouver exactement quelle classe /pile d'appel, c'est se produisant dans.