如何中断此std :: shared_ptr参考周期？

Question

Normally, I would break a cycle of shared_ptr s with weak_ptr . But I can't see how to do that in this example:

struct A;
struct B;
struct C;
struct D;

struct Cache {
    std::shared_ptr<A> a;
    std::shared_ptr<B> b;
    std::shared_ptr<C> c;
    std::shared_ptr<D> d;
};

struct A {
};

struct B {
    // Same 'a' as in the Cache
    std::shared_ptr<A> a;
};

struct C {
    // Holds a backreference to the cache
    std::shared_ptr<Cache> cache;
};

struct D {
    // Same 'c' as in the cache
    std::shared_ptr<C> c;
};

There are never any cycles between the A , B , etc. The only cycles are backreferences to the Cache . The Cache needs to stay alive as long as anybody (except the Cache itself) has a shared_ptr<C> , so just using weak_ptr<Cache> won't work. For example:

std::shared_ptr<Cache> make_cache() {
    auto cache = std::make_shared<Cache>();
    cache->a = std::make_shared<A>();
    cache->b = std::make_shared<B>();
    cache->b->a = cache->a;
    cache->c = std::make_shared<C>();
    cache->c->cache = cache;
    cache->d = std::make_shared<D>();
    cache->d->c = cache->c;
    return cache;
}

void use_cache() {
    auto a = make_cache()->a;
    // No need to keep the Cache around

    auto b = make_cache()->b;
    // b->a must be valid

    auto c = make_cache()->c;
    // c->cache must be valid

    auto d = make_cache()->d;
    // d->c (and therefore d->c->cache, etc.) must be valid
}

I understand that in general this would require a garbage collector, but I'm hoping in this specific case there's some trickery that can be done with shared_ptr 's aliasing constructor (8) or something.

Answer 1

"The Cache needs to stay alive as long as anybody (except the Cache itself) has a shared_ptr<C> ."

This argues that C controls the ultimate lifetime of the entire structure. Therefore, shouldn't the cache be composed into C?