Comment gérer shared_ptr qui pointe vers les données internes d'un objet déjà référencé?

Question

Supposons que j'ai ces classes:

struct Engine { 
    int engine_data; 
}; 

struct Car { 
    shared_ptr<Engine> engine; 
    int car_data; 
}; 

Pour des raisons de performance, je veux les rendre bien emballés dans la mémoire (mais je ne veux pas perdre la flexibilité de la conception). Donc, je peux créer une structure « tassée », et une usine qui sera de retour en toute transparence une nouvelle instance B:

struct PackedCarAndEngine { 
    Engine engine; 
    Car car; 
}; 

shared_ptr<Car> new_Car() { 
    shared_ptr<PackedCarAndEngine> packed = make_shared<PackedCarAndEngine>(); 

    // uses aliasing shared_ptr constructor 
    packed->car.engine = shared_ptr<Engine>(packed, &packed->engine); 

    // again 
    shared_ptr<Car> car = shared_ptr<Car>(packed, &packed->car); 

    return car; 
} 

Le problème est que cette instance « voiture » ne sera jamais détruit, parce qu'il a un compte de référence de deux. Quand il meurt, il aura un compte de référence d'un, pour toujours. Savez-vous un meilleur moyen de continuer à utiliser le shared_ptr interne (de sorte que je peux attribuer une référence "déballé" si je veux), et encore faire cette structure emballée?

MISE À JOUR

je pouvais utiliser un no-op Deleter, mais il serait très dangereux si je décide de garder le engine mais pas le car:

// ... 
    packed->car.engine = shared_ptr<Engine>(&packed->engine, do_nothing_deleter); 
    // ... 

shared_ptr<Car> my_car = new_Car(); 
shared_ptr<Engine> my_engine = my_car->engine; 
my_car.reset(); // Danger: engine was destroyed here!!! 
cout << my_engine->engine_data; // Crash! 

Answer 1

void nop(Engine*) { /* do nothing */ } 

packed->car.engine = shared_ptr<Engine>(&packed->engine, nop); 

Explication : Ce code crée un shared_ptr qui pense qu'il possède le moteur mais en fait il a un compteur de référence séparé ET il ne fait rien lorsque le suppresseur est appelé.

Answer 2

Pensez à utiliser weak_ptr au lieu de l'intérieur shared_ptrstruct Car, il ne contribue pas à faire référence à nombre, mais peut être converti en un shared_ptr en cas de besoin.