The problem here is all your inner classes are nothing but bags of bits. They don't do anything useful besides store data.

Take three separate implementations for a stack.
A stack has a well defined interface, you push things, and you pop things.

But how you choose to implement that functionality can vary.
Code:
// roll your own allocation and top of stack
class Stack {
    public:
        void push(int item);
        int pop(void);
    private:
        int        *m_stack;
        int         m_top;
        int         m_size;
};

// inner class tracks storage, but you still need top
class Stack {
    public:
        void push(int item);
        int pop(void);
    private:
        vector<int> m_stack;
        int         m_top;
};

// list does all the work for you
class Stack {
    public:
        void push(int item);
        int pop(void);
    private:
        list<int>   m_stack;
};
The whole point of keeping all that stuff private is that as a class implementer, you're free to swap one with another.
All the users of Stack are completely oblivious (and simply don't care) as to what happens on the inside.

If you let users mess with private data by making it public, one of two bad things happens when you change the class.
- all the users of your class suddenly find that the code doesn't compile.
- even worse, it does compile, but runs in unpredictable ways because you changed the meaning of a variable without telling anybody.