Zapobieganie czasowemu przedłueniu jego okresu trwałości?

Question

Może to być niemożliwe, ale zastanawiałem się, czy możliwe było zachowanie tymczasowego odlegle od jego pierwotnego wyrażenia. Mam sieć obiektów, które wskazują na obiektach nadrzędnych, a funkcja członek, który stworzy obiekt podrzędny, uproszczonym przykładem jest tutaj

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

Sposób chcę użyć person jest przekazanie go do funkcji, i coś takiego:

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

Jest w porządku.

To zadziała dobrze, o ile żaden z tymczasników nie przeżyje poza pierwotnym wyrażeniem, ale jeśli zwiążę jeden z ostatnich tymczasowych do odniesienia do const, jego rodzice nie przetrwają, a ja dostaję segfault. Mogę ukryć konstruktora kopii i operatora przypisania, ale czy jest jakiś sposób, aby zapobiec temu rodzajowi błędu? Jeśli to możliwe, chciałbym uniknąć alokacji dynamicznej.

Answer 1

Wygląda na to, że tworzysz strukturę danych, w której dzieci mają wskaźniki do rodziców. Korzystanie z tymczasowych gwarantuje w tym przypadku żal. Aby było to bezpieczne, będziesz musiał dynamicznie przydzielać i ewentualnie używać pewnego rodzaju liczenia odwołań.

Czy rozważałeś użycie boost::shared_ptr? Jest to implementacja referencyjnej zliczonej klasy inteligentnego wskaźnika. Korzystanie z shared_ptr i być może niektórych metod fabrycznych, może być w stanie uzyskać pożądany efekt i zmniejszyć ból dynamicznej alokacji pamięci. Wypróbowałem to i wygląda na to, że działa. Gdy kod wychodzi z zakresu, wszystkie obiekty są niszczone, ponieważ nie ma żadnych odniesień do shared_ptrs.

Edit: W odpowiedzi na komentarz Zounds', mam zmodyfikowany przykład tak, że obiekt główny kontroluje żywotność struktury te dane.

#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

Musisz zrobić coś takiego:

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

ten sposób rodzic „a” nie wykracza poza zakres dopóki nie jesteś naprawdę z nim zrobić (po zadzwoń do "użytkowania").

Problem z oryginalnym kodem polega na tym, że rodzic "Anna" musi zostać na tyle długo, aby zadzwonić "dziecko", a rodzic może zostać odrzucony przed wykonaniem wywołania funkcji. Poprzez ustawienie zmiennej nadrzędnej na zakres można kontrolować jej zniszczenie.

Czy to wygląda dla mnie niebezpiecznie? Tak. Dlatego sugeruję spojrzenie na odpowiedź m-sharp na alokację dynamiczną. Ale jeśli chcesz zastosować metodę, która nie wymaga liczenia odwołań itp., Możesz to zrobić w ten sposób ...