c ++：访问包含希望访问的类的类的成员

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

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 3

如果在类A中定义了类B，则不能使用类B的引用访问类A的成员。只有在类B继承自类A的情况下，您才能这样做。在这种情况下，使用类型B的引用，您将能够访问A的公共成员和受保护成员。

Answer 4

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 5

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.

Answer 6

与Java（非静态）内部类不同，C ++内部类不提供对外部类实例的任何隐藏引用（C ++除了vtable很少提供隐藏的东西），因此，如果需要，您需要自己提供这样的引用。