class A {
    public:
        class Observer {
             protected:
                 int GetPrivate(A & a) {return a.ValueA;};
        };
    private:
        int ValueA;
};

class B: public A::Observer {
    public:
        void Foo (A & a) {
             cout<<GetPrivate(A);
        }
};

Class B cannot access the privates of class A directly, but it inherits a subclass of A that can access the privates of A given as a parameter. Since I have just tried this “pattern” recently, I am not sure what is the direct benefit of this.

I believe a benefit can be in the sense of making a programmer’s life easier. Programming languages play several parts. They provide us powerful functionality, but they also suppose to give us ease of use. You can program anything on assembly, but it would be really difficult to write a big game in assembly.
If you do not expose privates via a getter, you give the programmer one less method to think about when he need to use the class’s instance for something.

Can you think how you would use this “pattern”? Do you think there is no use for it?
Tell me what you think.

This is very similar to software, you don’t need to think on certain problems upfront, but rather decide when the need arise. If making changes is not too difficult, you can make changes as you go, add, remove and edit.
There is no need to find the perfect solution right from the start.
The buzz word to describe this way of thinking would be lazy fattening.
That is, you don’t mind having objects with a lot of features and functionality(fat), but you only add those feature if you encounter a problem that requires you to do so.