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"));

很好。

只要暂时没有一个临时表现在原始表达式之后，这将会正常工作，但是如果我将其中一个最终的临时工具绑定到const引用，它的父母就无法生存，我会得到一个段错误。我可以隐藏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"));

这样，父母“a”不会超出范围，直到你真正完成它（在“使用”调用之后）。

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

这对我来说是否危险？是。因此，我建议看一下m-sharp关于动态分配的答案。但是如果你想要一个不需要引用计数等的方法，那么你可以这样做......

防止临时延长其寿命？

2 个答案: