struct A {
    A(unique_ptr<B> b, unique_ptr<C> c): c_(move(c)), b_(move(b)) {}
    unique_ptr<C> c_;
    unique_ptr<B> b_;
}

struct B {
    B(C* c): c_(c) {}
    C* c_;
}

auto c = make_unique<C>();
auto b = make_unique<B>(c.get());
auto a = make_unique<A>(move(b), move(c));

SS>auto c = make_unique<C>();
SS>auto b = make_unique<B>(c.get());
SS>auto a = make_unique<A>(move(b), move(c));
SS>

auto c = new C;
auto b = new B(c);
auto a = new A(b,c);
b->set_parent(a);
c->set_parent(a);

#include <iostream>
#include <list>
#include <assert.h>
using namespace std;

template<size_t TChunkSize=1024*1024, typename TItem=void> class StackAllocator;
template<size_t TChunkSize, typename TItem> class StackAllocator {
    class Chunk {
        TItem data[TChunkSize];
        TItem* cur;
        const TItem* end() const { return this->data+TChunkSize; }
    public:
        size_t UsedSize() const { return this->cur - this->data; }
        size_t FreeSize() const { return this->end() - this->cur; }        
        TItem* Alloc( size_t sz ) {
            if( sz > this->FreeSize() ) {
                return 0;
            }
            TItem* res = this->cur;
            this->cur += sz;
            assert( this->cur <= this->end() );
            return res;
        }
        void setAllocatedSize( size_t new_allocated_size ) {
            assert( new_allocated_size <= TChunkSize );
            this->cur = this->data + new_allocated_size;
        }
    };
    typedef std::list<Chunk> TChunks;
    typedef typename TChunks::iterator TChunksItr;
    TChunks chunks; 
    TChunksItr cur_chunk;
    
    void get_free_chunk() {
        TChunksItr next = this->cur_chunk;
        if( this->cur_chunk == this->chunks.end() || ++next == this->chunks.end() ) {
            this->chunks.emplace_back();
            next == this->chunks.end();
            --next;
        }
        assert( this->chunks.end() != next );
        this->cur_chunk = next;
        next->setAllocatedSize( 0 );
    }
    TChunksItr find_chunk(const Chunk* chunkPtr ) {
        for( typename std::list<Chunk>::reverse_iterator cur = this->chunks.rbegin();
                cur != this->chunks.rend(); ++cur ){
            if( &*cur == chunkPtr ) {
                TChunksItr res = cur.base();
                return --res;
            }
        }
        return this->chunks.end();
    }
public :
    struct State {
        const Chunk* chunkPtr;
        size_t usedSize;
        
        // Число, полезное для отладки. Обычно в рамках одной сессии программы оно 
        // однозначно соответствует состоянию аллокатора.
        intptr_t debug_int() const { return this->usedSize + (intptr_t)this->chunkPtr; }
    };

    StackAllocator() { 
        this->cur_chunk = this->chunks.end();
        this->get_free_chunk(); 
    }
    TItem* Alloc( size_t sz ) {
        assert( sz <= TChunkSize );
        TItem* res = this->cur_chunk->Alloc( sz );
        if( res == 0 ) {
            this->get_free_chunk();
            res = this->cur_chunk->Alloc( sz );
        }
        assert( res != 0 );
        return res;
    }
    bool IsValidState( const State& st ) const {
        TChunksItr pos = const_cast<StackAllocator*>(this)->find_chunk( st.chunkPtr );
        return pos != this->chunks.end() && st.usedSize <= pos->UsedSize();
    }
    State GetState() const {
        State res = { &*this->cur_chunk, this->cur_chunk->UsedSize() };
        return res;
    }
    void Rewind( const State& st ) {
        TChunksItr pos = this->find_chunk( st.chunkPtr );
        assert( pos != this->chunks.end() && st.usedSize <= pos->UsedSize() ); 
        pos->setAllocatedSize(st.usedSize);
        this->cur_chunk = pos;
    }
    
//private:
    template<typename TCompatibleItem> class compatibleAllocator {
        typedef StackAllocator<TChunkSize, TItem> TAllocator;
        TAllocator allocator;
    public:    
        typedef TAllocator::State State;
        TCompatibleItem* Alloc( size_t sz ) 
            { return static_cast<TCompatibleItem*>( this->allocator.Alloc( sz )); }
        State GetState() const { return this->allocator.GetState(); }
        void Rewind( State st ) { this->allocator.Rewind( st ); }
    };
};

template<size_t TChunkSize, typename TItem> 
    class StackAllocator<TChunkSize, const TItem> : 
        public StackAllocator<TChunkSize, TItem>::template compatibleAllocator<const TItem> {};

template<size_t TChunkSize, typename TItem> 
    class StackAllocator<TChunkSize, volatile TItem> : 
        public StackAllocator<TChunkSize, TItem>::template compatibleAllocator<volatile TItem> {};

template<size_t TChunkSize, typename TItem> 
    class StackAllocator<TChunkSize, const volatile TItem> : 
        public StackAllocator<TChunkSize, TItem>::template compatibleAllocator<const volatile TItem> {};

template<size_t TChunkSize> 
    class StackAllocator<TChunkSize, void> : 
        public StackAllocator<TChunkSize, char>::template compatibleAllocator<void> {};

/////////////////////////////////////////////////////////////
// TEST IT
////////////////////////////////////////////////////////////

StackAllocator<500, char> a;
void test_it( int n, int max_n=5 ) {
    if( n <= 0 ) {
        return;
    }
    std::string title( std::max(max_n-n, 0), '\t' );
    std::cout << title << "n:" << n << "+State:" << (size_t)a.GetState().debug_int() << std::endl;
    StackAllocator<500>::State st = a.GetState();
    
    // Тут что-то рекурсивно аллокируем:
    for( int i = 0; i < 5; i++ ) {
        a.Alloc(64);
        test_it( n-1, max_n );
        a.Alloc(64);
    }
    // Теперь отматываем стек, как было, тем самым освобождая всё аллокированное
    a.Rewind( st );
    std::cout << title << "n:" << n << "-State:" << (size_t)a.GetState().debug_int() << std::endl;
}

int main() {
    test_it( 3 );
    // your code goes here
    return 0;
}

class Container {
    unique_ptr<C> c;
    unique_ptr<B> b;
    unique_ptr<A> a;
    Container():
        c(make_unique<C>()),
        b(make_unique<B>(c.get())),
        a(make_unique<A>(b.get(), c.get()))
    {}
}