防止暂时延长其寿命？

Question

这可能是不可能的，但我想知道是否有可能通过它的原始表达来保持暂时的永久。我有一个指向父对象对象链，这将创建一个子对象的成员函数，一个简单的例子是在这里

class person{ 
    string name; 
    person * mommy; 
public: 
    person(const string & nam, person * m = 0) : name(nam), mommy(m) {} 
    person baby(const string & nam){ 
     return person(nam, this); 
    } 
    void talk() const{ 
     if (mommy) mommy->talk(); 
     cout << name << endl; 
    } 
}; 

int main(){ 
    person("Ann").baby("Susan").baby("Wendy").talk();  // fine 

    const person & babygirl = person("Julie").baby("Laura"); // not fine 

    babygirl.talk(); // segfault 
    return 0; 
} 

我想用person是将其传递给函数的方式，和这样的事情：

void use(const person & p) { 
    p.talk(); 
} 
use(person("Anna").baby("Lisa")); 

很好。

只要没有一个临时存活通过原始表达式，但是如果我将其中一个临时临时对象绑定到一个常量引用，它的父项就不能存活，并且我得到一个段错误。我可以隐藏person的拷贝构造函数和赋值操作符，但有什么办法可以防止这种错误发生？如果可能，我想避免动态分配。

Answer 1

看起来你正在创建一个数据结构，在这里孩子们有指向父母的指针。在这种情况下，使用临时工会保证让你感到悲伤。为了安全起见，您需要动态分配并可能使用某种引用计数。

您是否考虑过使用boost::shared_ptr？它是引用计数智能指针类的实现。使用shared_ptr以及可能的某些工厂方法，您可能能够获得所需的效果并减少动态内存分配的麻烦。我试了一下，它似乎工作。一旦代码退出范围，对象将被全部销毁，因为没有引用留给shared_ptrs。

编辑： 响应于zounds'评论，我已修改的示例，以使根对象控制的数据结构的寿命。

#include <iostream> 
#include <string> 
#include <vector> 
#include <boost\shared_ptr.hpp> 
#include <boost\weak_ptr.hpp> 

using boost::shared_ptr; 
using boost::weak_ptr; 

using std::string; 
using std::cout; 
using std::endl; 
using std::vector; 

class person; 
typedef shared_ptr<person> Person; 
typedef weak_ptr<person> PersonWk; 

class person {  
    PersonWk pThis; 
    friend Person makePerson(const string & nam, Person m = Person()); 

    string name; 
    PersonWk mommy; // children should not affect parent lifetime, so store weak ptr 
    vector<Person> children; // parents affect children lifetime so store child shared ptrs 

    // make constructor private so that you can only make a person using factory method 
    person(const string & nam, Person m) : name(nam), mommy(m) 
    { 
     // for demo purposes 
     printf("creating %s\n", nam.c_str()); 
     ++personCount; 
    } 

    // undefined copy constructor and assignment operators 
    person(const person&); 
    person& operator=(const person&); 

public: 
    // for demo purposes 
    static int personCount; 

    ~person() 
    { 
     // for demo purposes 
     printf("destroying %s\n", name.c_str()); 
     --personCount; 
    } 

    Person baby(const string & nam){   
     Person child = makePerson(nam, Person(pThis)); 
     children.push_back(child); 
     return child; 
    } 

    void talk() const{ 
     if (Person mom = mommy.lock()) 
      mom->talk(); 
     cout << name << endl; 
    } 
}; 

int person::personCount = 0; 

// factory method to make a person 
Person makePerson(const string & name, Person m) { 
    Person p = Person(new person(name, m)); 
    p->pThis = p; // stash weak_ptr so I can use it to make a shared_ptr from "this" in the baby method 
    return p; 
} 

void use(const Person p) { 
    printf("In method use...\n"); 
    p->talk(); 
} 

int _tmain(int argc, _TCHAR* argv[]) 
{ 
    printf("personCount=%d\n", person::personCount); 
    { 
     Person ann = makePerson("Ann"); 

     // ann has baby and grandbaby, pass grandbaby to use method 
     use(ann->baby("Susan")->baby("Wendy")); 

     ann.reset(); // remove reference from root object. Destruction ensues... 
    } 
    printf("personCount=%d\n", person::personCount); 
    return 0; 
} 

Answer 2

你必须做这样的事情：

void use(const person & p) { 
    p.talk(); 
} 
person a("Anna"); 
use(a.baby("Lisa")); 

这样，父“一个”不出去的范围，直到你真正用它做（后呼叫“使用”）。

原始代码的问题在于，父母“Anna”只需保持足够长的时间来调用“宝贝”，并且在进行函数调用之前父母可以被丢弃。通过使父变量具有作用域，您可以控制何时被破坏。

这看起来对我来说很危险吗？是。因此，我建议看看m-sharp对动态分配的回答。但是如果你想要一种不需要参考计数的方法等，那么你可以这样做......