c++: Access to members of a class that contains the class that wants the access

Question

Is it possible in c++ to modify a member of a class A that "surrounds" the class B (is in the "upper" scope) besides using a reference of the "surrounding class"?

code is here: http://pastebin.com/iEEu9iZG

The goal is to modify the GFullScreen variable with the same value of the fullscreen variable. I know that I can pass a pointer of GFullScreen or a reference of the whole Game class.. Is there another way to access to it? which one is more efficient?

Answer 1

No. It would have broken encapsulation horribly. And reference would have needed to be stored somewhere anyway, implicitly or explicitly - how else could you remember this relation?

Answer 2

You cannot access members of class A using a reference of class B if class B is defined inside class A. You could only do this if Class B was inherited from class A. In that case, using a reference of type B, you would be able to access public and protected members of A.

Answer 3

If the member is static and public (or if B or the member function in B accessing the variable is a friend of A), then yes.

In every other case, no.

The reason is that B does not have an is-a relation to A, thus you need either an object (reference or pointer), or whatever you try to access must be static.

EDIT:
Just for fun, it is possible to make it look as if this was possible, by giving B a has-a relationship to A:

class A
{
    int a;

public:
    struct B;
};

class A::B : private A
{
    void foo() { A::a = 1; }
};

But of course I'm cheating here... this works because (and only because) every B has-a A, you only don't see it at once.

Answer 4

Unlike Java (nonstatic) inner classes, C++ inner classes doesn't provide any hidden reference to outer class instance (C++ rarely does something hidden, except of vtable), so you need to provide such a reference by yourself, if needed.

Answer 5

Yes. Note that the nested union is required to be at least 1 byte long, so an offset needs to be given to strcpy. Also, the behavior of this program is implementation-dependent and is more of a hack for demonstration purposes, though in practice I'd expect it to work predictably with any modern C++ compiler.

#include <cstring>
#include <iostream>

struct _a
{
        union _b {
                void mutate()
                {
                        strcpy(reinterpret_cast<char*>(this) + 1, "Goodbye, World!");
                }
        } b;
        char buf[256];

        _a() { strcpy(buf, "Hello, World!"); }
} a;

int main()
{
        std::cout << a.buf << "\n";
        a.b.mutate();
        std::cout << a.buf << std::endl;
        return 0;
};

My point is that with knowledge of C/C++ internals, you can devise some platform-dependent hacks that are often useful and necessary. This one isn't however, so I'd highly advise against actually using the code given above to accomplish common tasks.

Answer 6

So I see no one has answered this with a best practice example, I will give one here:

#include <iostream>
using namespace std;

//before includes:
class A;

//B.h
class B{
    public:
        B(A *);
        void test();
        A *parent;
};

//A.h
class A{
    public:
        A();
        ~A();

        B *b;
        void test();

        int n;
};

//B.cpp
B::B(A *a){
    parent = a;
}

void B::test(){
    cout << parent->n;
}

//A.cpp
A::A(){
    n = 404;
    b = new B(this);
}
A::~A(){
    delete b;
}
void A::test(){
    b->test();
}

//example.cpp
int main( int argc, char **argv){
    A a;
    a.test();
}

You will see that you need to pass the context yourself to the contained class to access the containing class. There is no other way, than by passing the context yourself to the class.