Why this C++ program is returning 16 bytes?

Question

The below program when compiled using gcc and executed on a 32-bit architecture returns 16 bytes. I am wondering why it is returning so as it is neither uses a long double member nor it is running on a 64-bit machine and there is no virtual functions defined to get extra bytes of memory and when calculating the size of double and int data member, the result comes around 12 bytes. So why this 16 bytes value?

class A {
public:
     void* data;
};
void* operator new (size_t sz, A& obj) {
     printf("Custom operator new called for %d bytes\n", sz);
     return obj.data;
}
class foo {
public:
     double a;
     int x;
     foo() { printf("foo constructor called (this=%p)\n", this); }
};
int main() {
     A obj;
     obj.data = malloc(sizeof(foo));
     printf("Allocator data: %p\n", obj.data); // Allocator data:  0x4601a8
     foo *f = new (obj) foo; // Custom operator new called for **16 bytes**
                                       // foo constructor called (this=0x4601a8)
     printf("foo allocated at %p\n", f); // foo allocated at 0x4601a8
}

Depends on your default packing - with 1, 2 or 4 byte packing, you will get 12. With 8 or 16 byte packing, you will get 16. — cup, Feb 28 '14 at 07:26

score 3 · Answer 1 · answered Feb 28 '14 at 07:26

4 bytes are added at the end of foo as padding. This is typically done for alignment purposes - a double is aligned to 8 bytes on your architecture, so if you create an array of foos, the padding bytes guarantee that the member a is properly aligned.

In a class-type there's no guarantee that the size is equal to the sum of the sizes of members. More often than not, it isn't.

There are special compiler-dependent flags that prevent padding bytes being added which you can look up. (pragma pack)

score 0 · Answer 2 · answered Feb 28 '14 at 07:28

0

There may be unnamed padding within a structure object, which is called Data_structure_alignment

in your case, double is aligned to 8 bytes, so the sizeof foo should be 8*N ,so 4bytes padded

answered Feb 28 '14 at 07:28

michaeltang

2,850
15
18

score 0 · Answer 3 · answered Feb 28 '14 at 07:28

when i run your code i found following :

class A {
public:
     void* data;
};
void* operator new (size_t sz, A& obj) {
     printf("Custom operator new called for %d bytes\n", sz);
     return obj.data;
}
class foo {
public:
     double a;
     int x;
     foo() { printf("foo constructor called (this=%p)\n", this); }
};
int main() {
     A obj;
     obj.data = malloc(sizeof(foo));
     printf("Allocator data: %p\n", obj.data); // Allocator data:  0x991d008
     printf("size of obj: %d\n", sizeof(obj)); // size of obj:  4
     printf("size of foo: %d\n",sizeof(foo)); // size of foo: 12
     foo *f = new (obj) foo; // Custom operator new called for **12 bytes**
                                       // foo constructor called (this=0x991d008)
     printf("foo allocated at %p\n", f); // foo allocated at 0x991d008
}

I have added two additional printing statement, here size of foo is 12. that is double + int.

Padding is system-specific so this is unfortunately not that helpful. The code will give different results on different computers and compilers. — Lundin, Feb 28 '14 at 07:36

score 0 · Answer 4 · edited May 23 '17 at 11:57

0

This is because of internal padding applied by the compiler. We can avoid this by using __packed compiler directive.

You can refer the following post for understanding about padding

Structure padding and packing

edited May 23 '17 at 11:57

Community

1
1

answered Feb 28 '14 at 07:34

prince

1,129
1
15
38

score 0 · Answer 5 · answered Feb 28 '14 at 07:44

0

Consider data alignment. Compiler aligns data of the object in oder to store them in memory so that CPU can get them in one load - this is possible only for aligned data. This is hardware aspect.

answered Feb 28 '14 at 07:44

Spock77

3,256
2
30
39

Why this C++ program is returning 16 bytes?

5 Answers5