指向结构或类的指针与指向第一个字段的指针

Question

I recently tried debugging a small program by printing the values of several pointers to the console. The first was the memory address of a struct, and the others were the memory addresses of its fields. A stripped-down version of the code is as follows:

#include <iostream>

struct testingPointers
{
    int i;
    float f;
    double d;
} test;

int main()
{
   std::cout << &test << '\n' << &(test.i) << '\n' << 
            &(test.f) << '\n' << &(test.d);
}

And the output is:

0x681110
0x681110
0x681114
0x681118

(obviously the exact values are different for different runs but they always have the same positions relative to each other).

I am confused because the value of first pointer--the memory location of test --is the same as that of the second one (the first field of test ). Does this mean that objects have no real unique memory address, and that a pointer to a struct or class simply points to its first field? If so, how do statements like

a.b
a->b
a.b()

make sense if a is actually just its first field, and therefore does not have any fields or methods?

Answer 1

The address of an object shall always be the address of the first non-static member within that object. Quoting from the standard (C++11-9.2-20):

A pointer to a standard-layout struct object, suitably converted using a reinterpret_cast, points to its initial member (or if that member is a bit-field, then to the unit in which it resides) and vice versa. [ Note: There might therefore be unnamed padding within a standard-layout struct object, but not at its beginning, as necessary to achieve appropriate alignment.

The requirements for standard-layout are mentioned here: StandardLayoutType .

This can certainly be applied via nesting. The standard makes no exceptions for the type of the first member except for bit-fields. Ie:

class X
{
public:
    int x;
};

class Y
{
public:
    X x;
    int y;
};

Y yobj;

By the standard, &yobj == &yobj.x == &yobj.xx .

Answer 2

A class or struct just describes a collection of fields that should be kept together in memory, and have some semantic relationship between them and some operations that operate over them. There is, in the simple case, nothing much more to the content of a class type object in memory than the members it is made up of (and some padding). When you have a testingPointers object in memory, it is really just an int , a float and a double . The concept of the class was only used to generate the correct executable code - it does not exist at run time (at least not for this purpose).

The important part from the standard regarding whether objects can share memory addresses is §1.8/6:

Unless an object is a bit-field or a base class subobject of zero size, the address of that object is the address of the first byte it occupies. Two objects that are not bit-fields may have the same address if one is a subobject of the other, or if at least one is a base class subobject of zero size and they are of different types; otherwise, they shall have distinct addresses.

We can infer from this that because member test.i is a subobject of test , they may well have the same address.

Once you look inside all of the objects of your program as deep as you can go, what you really have is a big collection of scalar values and adjacent bit-fields. These are known as memory locations in the standard. These are the things that really take up space. The rest of your objects are all in some way composed of these.

A memory location is either an object of scalar type or a maximal sequence of adjacent bit-fields all having non-zero width. [ Note: Various features of the language, such as references and virtual functions, might involve additional memory locations that are not accessible to programs but are managed by the implementation. — end note ]

Answer 3

Just to clarify your confusions:

1).value of first pointer--the memory location of test--is the same as that of the second one (the first field of test).
Address of Struct and its first field got to be the same since struct is nothing both the collection of its fields contiguously.

You can also consider the case of arrays to further simplify the understanding, wherein the address of the array will obviously be equal to the first element (field) of the array.

2).Does this mean that objects have no real unique memory address, and that a pointer to a struct or class simply points to its first field?
I think you are confusing it with that of JAVA wherein the Object is always allocated on Heap. In C++, struct/class is always allocated on Stack unless it's dynamic memory allocation (using 'new' operator) where the object is allocated in heap and a pointer variable (in Stack) will point to that object in heap. Therefore, in the former case the struct variable will always have the same address as that of its first element (field).

Hope that helps.

Answer 4

A struct in memory consists of nothing more than its fields strung together. There may be padding before the struct and/or between the fields, based on alignment needs, but there's not usually any extra "stuff" before the first field. So the first field and the struct itself have the same address.

Remember that in C, types exist only at compile time.