c++ - 关于 C++/程序集数据布局、数据成员访问、方法的一般问题

Question

我试图了解 C++ 在内存中的布局方式、数据成员的访问方式以及方法调用方面的工作原理，但发现它非常困惑。当涉及到一个不涉及继承、虚函数等的非常简单的类时，我可以澄清一下我是否在正确的轨道上理解其中的一些概念。

   class Foo
    {
    public:
        Foo(); 
        int i;
        char c;
        void meth(); // sets private member j 
    private:
        int j; 
        SomeClass s;  
        friend class Bar; 
    };

Foo f;
Foo g; 

数据布局对象将按照它们声明的顺序排列，顺序排列，连同它们各自的数据成员。我在这里发现了一个类似的问题:How are objects stored in memory in C++? ，但是出现的另一个问题是如果有不同的访问 block 会发生什么，比如私有(private)和公共(public)？有什么不同吗？另外，如果其中一个数据成员是另一个类，比如 SomeClass 有自己的数据成员，它会是什么样子？

数据成员访问我读到这是通过指向对象的指针(假设为“this”指针)完成的，该指针根据成员的大小/数量+填充而被替换了一定量。同样，私有(private)成员和其他类有区别吗？这也是 Foo f 和 Foo g 的数据成员彼此分离的方式吗，即如果我执行 f.meth()，它如何选择正确的 j 进行更改？

成员方法与非成员方法当函数被调用时，它接收到一个指向调用它的对象的指针，即“this”指针。对于成员函数来说似乎是这样，但是如果一个非成员函数，比如友元类 Bar 中的某事，试图修改私有(private)成员 j 会发生什么？那么“this”肯定会是一个 Bar 对象吗？那么它如何在它试图修改的 Foo 对象中找到数据成员呢？

Answer 1

数据布局

what happens if there are different access blocks, like private in addition to public? Is there any difference?

没有区别。访问说明符对内存布局没有影响。

Also what would it look like if one of the data members is another class, like SomeClass with its own data members?

SomeClass 成员将嵌套在类对象中，其成员的顺序与它们在非成员 SomeClass 对象中出现的顺序相同。

数据成员访问

Again, is there a difference with private members and other classes?

同样，不。

Is this also how Foo f's and Foo g's data members are known to be separate from one another ie if I did f.meth(), how does it pick the right j to change?

假设这是 Foo::meth()

的主体

void Foo::meth()
{
    j++;
}

这相当于:

void Foo::meth()
{
    this->j++;
}

当分别调用 Foo 对象 f 和 g 时，等同于:

f.j++;    // this is, of course, not legal as j is private
g.j++;

成员方法与非成员方法

what happens if a non-member function, say something in the friend class Bar, tries to modify private member j? Then surely "this" would be a Bar object instead?

是的，正确。

So how would it find the data members in the Foo object it's trying to modify?

嗯，它不能通过名称直接访问对象，而它可以使用 Bar 的成员。它需要通过 Foo 对象访问它。成员 Foo 对象，或全局 Foo 对象，或作为参数传递给函数的 Foo 对象。例如

void Bar::DoSomethingWithFoo(Foo & f)
{
    // j = 10; <-- can't do this, unless Bar has a member named j
    //            but in that case, it has no effect on the j member
    //            of f

    f.j = 10;
}