struct IFace { ..... };

class TheImpl : public IFace { ..... };

class TheFixture {
public:
    IFace& iface() { return aggregate_; }
private:
    TheImpl aggregate_;
    // и ещё всякий клей, вспомогательные объекты, связи и функции
};

class TheProvider {
public:
    std::shared_ptr<IFace> provide() {
        if (need_create())
            create_cached_object();
        return cached_object_;
    }

private:
    std::shared_ptr<IFace> cached_object_;

    bool need_create() {
        return !cached_object_ || ....;  // кеша нет, кеш протух, всё такое...
    }

    // вот тут живёт бажок!
    void create_cached_object() {
        auto cached_object = std::make_shared<TheFixture>();
        cached_object_ = std::shared_ptr<IFace>{cached_object_, &cached_object->iface()};
    }
};

К>        cached_object_ = std::shared_ptr<IFace>{cached_object_, &cached_object->iface()};
К>

cached_object_ = std::shared_ptr<IFace>{cached_object, &cached_object->iface()};

m_cached_object = std::shared_ptr<IFace>{m_cached_object, &cached_object->iface()};

auto fixture = std::make_shared<TheFixture>(1,2,3);
auto cached_object = std::shared_ptr<IFace>{fixture, &fixture->iface()};
cached_object_ = cached_object;

struct TheProvider {
    explicit TheProvider() {}

    std::shared_ptr<IFace> provide() {
        if(auto obj = cached_object_.lock()) {
            return obj;
        }
        else {
            auto fixture = std::make_shared<TheFixture>(1, 2, 3);
            cached_object_= std::shared_ptr<IFace>{fixture, &fixture->iface()};
            return cached_object_.lock();
        }
    }

private:
    std::weak_ptr<IFace> cached_object_;
};

template<typename F, typename I>
std::shared_ptr<I> make_shared_8(std::shared_ptr<F>& f, I& (F::*fn_ptr)()) {
    auto& i = ((*f.get()).*fn_ptr)();
    return std::shared_ptr<I> {f, &i};
}

...

cached_object_= make_shared_8(fixture, &TheFixture::iface);

template<class T, class M>
auto shared_member_ptr_cast(shared_ptr<T> p, M&(T::*m)) { return shared_ptr<M>{p, &p->*m}; }


template<class T, class M>
auto shared_member_fun_cast(shared_ptr<T> p, M&(T::*m)()) { return shared_ptr<M>{p, &(p->*m)()}; }

template<class T, class M>
auto shared_member_fun_cast(shared_ptr<T> p, M*(T::*m)()) { return shared_ptr<M>{p, (p->*m)()}; }