C / C ++中的对象/结构对齐

Question

#include <iostream>

using namespace std;

struct test
{
    int i;
    double h;
    int j;
};

int main()
{
    test te;
    te.i = 5;
    te.h = 6.5;
    te.j = 10;

    cout << "size of an int: " << sizeof(int) << endl; // Should be 4
    cout << "size of a double: " << sizeof(double) << endl; //Should be 8
    cout << "size of test: " << sizeof(test) << endl; // Should be 24 (word size of 8 for double)

    //These two should be the same
    cout << "start address of the object: " << &te << endl; 
    cout << "address of i member: " << &te.i << endl;

    //These two should be the same
    cout << "start address of the double field: " << &te.h << endl;
    cout << "calculate the offset of the double field: " << (&te + sizeof(double)) << endl; //NOT THE SAME

    return 0;    
}

Output:

size of an int: 4
size of a double: 8
size of test: 24
start address of the object: 0x7fffb9fd44e0
address of i member: 0x7fffb9fd44e0
start address of the double field: 0x7fffb9fd44e8
calculate the offset of the double field: 0x7fffb9fd45a0

Why do the last two lines produce different values? Something I am doing wrong with pointer arithmetic?

Answer 1

(&te + sizeof(double))

This is the same as:

&((&te)[sizeof(double)])

You should do:

(char*)(&te) + sizeof(int)

Answer 2

Firstly, your code is wrong, you'd want to add the size of the fields before h (ie an int ), there's no reason to assume double . Second, you need to normalise everything to char * first (pointer arithmetic is done in units of the thing being pointed to).

More generally, you can't rely on code like this to work. The compiler is free to insert padding between fields to align things to word boundaries and so on. If you really want to know the offset of a particular field, there's an offsetof macro that you can use. It's defined in <stddef.h> in C, <cstddef> in C++.

Most compilers offer an option to remove all padding (eg GCC's __attribute__ ((packed)) ).

---

_{I believe it's only well-defined to use offsetof on POD types.}

Answer 3

You are correct -- the problem is with pointer arithmetic.

When you add to a pointer, you increment the pointer by a multiple of that pointer's type

Therefore, &te + 1 will be 24 bytes after &te .

Your code &te + sizeof(double) will add 24 * sizeof(double) or 192 bytes.

Answer 4

struct test
{
    int i;
    int j;
    double h;
};

Since your largest data type is 8 bytes, the struct adds padding around your ints, either put the largest data type first, or think about the padding on your end! Hope this helps!

Answer 5

&te + sizeof(double) is equivalent to &te + 8 , which is equivalent to &((&te)[8]) . That is — since &te has type test * , &te + 8 adds eight times the size of a test .

Answer 6

Compilers are free to space out struct s however they want past the first member, and usually use padding to align to word boundaries for speed.

See these:
C struct sizes inconsistence
Struct varies in memory size?
et. al.

Answer 7

You can see what's going on more clearly using the offsetof() macro:

#include <iostream>
#include <cstddef>

using namespace std;

struct test
{
    int i;
    double h;
    int j;
};

int main()
{
    test te;
    te.i = 5;
    te.h = 6.5;
    te.j = 10;

    cout << "size of an int:   " << sizeof(int)    << endl; // Should be 4
    cout << "size of a double: " << sizeof(double) << endl; // Should be 8
    cout << "size of test:     " << sizeof(test)   << endl; // Should be 24 (word size of 8 for double)

    cout << "i: size = " << sizeof te.i << ", offset = " << offsetof(test, i) << endl;
    cout << "h: size = " << sizeof te.h << ", offset = " << offsetof(test, h) << endl;
    cout << "j: size = " << sizeof te.j << ", offset = " << offsetof(test, j) << endl;

    return 0;
}

On my system (x86), I get the following output:

size of an int:   4
size of a double: 8
size of test:     16
i: size = 4, offset = 0
h: size = 8, offset = 4
j: size = 4, offset = 12

On another system (SPARC), I get:

size of an int:   4
size of a double: 8
size of test:     24
i: size = 4, offset = 0
h: size = 8, offset = 8
j: size = 4, offset = 16

The compiler will insert padding bytes between struct members to ensure that each member is aligned properly. As you can see, alignment requirements vary from system to system; on one system (x86), double is 8 bytes but only requires 4-byte alignment, and on another system (SPARC), double is 8 bytes and requires 8-byte alignment.

Padding can also be added at the end of a struct to ensure that everything is aligned properly when you have an array of the struct type. On SPARC, for example, the compile adds 4 bytes pf padding at the end of the struct.

The language guarantees that the first declared member will be at an offset of 0, and that members are laid out in the order in which they're declared. (At least that's true for simple structs; C++ metadata might complicate things.)