std :: nesnesinin işlevine ve nesnenin ömür boyu işlevine işlev

Question

std::function örneğim, bir nesne örneğinin üye işlevine bağlıysa ve bu nesne örneği kapsam dışında kaldığında ve başka bir nedenle yok edilirse std::function nesnesim şimdi çağrılırsa başarısız olacak kötü bir işaretçi olarak kabul edilebilir?

Örnek:

int main(int argc,const char* argv){ 
    type* instance = new type(); 
    std::function<foo(bar)> func = std::bind(type::func,instance); 
    delete instance; 
    func(0);//is this an invalid call 
} 

ne olacağını belirten standardında bir şey var mı? Benim önsezim, nesne artık mevcut olmadığı için atar ve istisnadır.

DÜZENLEME: Standart, ne olacağını belirtiyor mu?

Bu tanımlanmamış bir davranış?

DÜZENLEME 2:

#include <iostream> 
#include <functional> 
class foo{ 
public: 
    void bar(int i){ 
     std::cout<<i<<std::endl; 
    } 
}; 

int main(int argc, const char * argv[]) { 
    foo* bar = new foo(); 
    std::function<void(int)> f = std::bind(&foo::bar, bar,std::placeholders::_1); 
    delete bar; 
    f(0);//calling the dead objects function? Shouldn't this throw an exception? 

    return 0; 
} 

i, 0 bir çıkış değerini almak Bu kod çalıştırma;

Answer 1

Ne olacağı tanımlanmamış bir davranıştır.

(instance->*(&type::func))(0); 

geçersiz işaretçi başvurusu kaldırıldığında instancedelete d olsaydı orada yapacağı gibi,: etkili arayacak func(0) çağırdığınızda böylece bind() çağrı, instance bir kopyasını içeren bazı nesne dönecektir

, tanımlanmamış bir davranıştır. Bir istisna atar (her ne kadar tanımlanmamış olsa da, kim bilir). Sesli arama bir yer tutucu kaçırdığınızı

Not: Bu olmadan

std::function<foo(bar)> func = 
    std::bind(type::func, instance, std::placeholders::_1); 
//         ^^^^^^^ here ^^^^^^^^^ 

, hatta silinmemiş örnekle func(0) diyemezsin. Daha iyi ne göstermek için örnek kod güncelleme

oluyor:

ekledi destructor ile

struct foo{ 
    int f; 
    ~foo() { f = 0; } 

    void bar(int i) { 
     std::cout << i+f << std::endl; 
    } 
}; 

, siz (f olarak) işaretçi kopyalama ve işaret edildi nesneyi kopyalama arasındaki farkı görebilirsiniz (içinde g):

foo* bar = new foo{42}; 
std::function<void(int)> f = std::bind(&foo::bar, bar, std::placeholders::_1); 
std::function<void(int)> g = std::bind(&foo::bar, *bar, std::placeholders::_1); 
f(100); // prints 142 
g(100); // prints 142 
delete bar; 
f(100); // prints 100 
g(100); // prints 142 still, because it has a copy of 
     // the object bar pointed to, rather than a copy 
     // of the pointer