8

这可能是不可能的，但我想知道是否有可能让一个暂时的东西永远不会超过它原来的表达方式。我有一个指向父对象的对象链，以及一个将创建子对象的成员函数，一个简化的例子是here

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的复制构造函数和赋值运算符，但是有什么办法可以防止这种错误的发生吗？如果可能的话，我想避免动态分配。

4

2 回答 2

3

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

你考虑过使用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;
}
于 2011-09-27T20:23:58.880 回答
0

你必须做这样的事情：

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

这样，在您真正完成它之前（在调用“use”之后），父“a”不会超出范围。

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

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

于 2011-09-27T20:29:40.483 回答