Home / Questions / 90360
Accepted
PaperBirdMaster
Asked: 2020-07-26 03:28:21 +0800 CST 2020-07-26 03:28:21 +0800 CST

Why is the sizeof of a data not equal to the sizeof of its members?

  • 772

I have the following code:

struct datos
{
    char c;
    int i;
    long l;
};

#define SO(x) #x << " = " << x

int main()
{
    datos d;

    std::cout
        << SO(sizeof(d)) << '\n'
        << SO(sizeof(d.c)) << '\n'
        << SO(sizeof(d.i)) << '\n'
        << SO(sizeof(d.l)) << '\n'
        << SO(sizeof(char) + sizeof(int) + sizeof(long)) << '\n';

    return 0;
}

Which produces the following output:

sizeof(d) = 16
sizeof(d.c) = 1
sizeof(d.i) = 4
sizeof(d.l) = 8
sizeof(char) + sizeof(int) + sizeof(long) = 13

I finished my primary studies a long time ago, but the last time I checked, adding one, four and eight was thirteen; but requesting the size of datosreturns sixteen, which is not the sum of one, four, and eight.

What's going on?

c++

1 Answers

  1. Best Answer

    This is due to a decision the compiler makes in generating the type to match multiples of the processor word size .

    processor word.

    Processor word 1 roughly indicates how many bits a processor can process in a single operation. As an analogy we can imagine a polygraph, the more needles it has, the more lines it can draw at the same time:

    The processor word also tells us the size of the data that can travel across the bus each cycle; eg: A 16-bit processor will take two bus cycles to send a 32-bit integer.

    memory alignment.

    Since it intappears to be 4 bytes on your system, your processor word is likely to be 32 bits. What is the size in bits of the structure datos?

    | <----------------- datos 13 * 8 = 104 bits ------------------> |
|char|        int        |                 long                  |
| 1  | 2  | 3  | 4  | 5  | 6  | 7  | 8  | 9  | 10 | 11 | 12 | 13 |

    The size should be 13 bytes (104 bits), being the processor word 32 bits, we obtain that the structure datosoccupies 3.25 processor words; this supposes that to read an instance of the structure we will need 4 readings of which, in the last one we will ignore the last 3 bytes read.

    If after this instance of datos104 bits we store another, its memory address would be misaligned 1 byte with respect to the multiples of the processor word, it will still have to perform 4 reads but after reading it will have to align the data discarding the first byte and then moving data one byte to the left 2 .

    To avoid this extra work, the objects are created so that they occupy multiples of the processor word, so the structure datosactually looks like this in memory:

    | <------------ datos 13 * 8 bits + "relleno" 3 * 8 bits = 128 bits -----------> |
|        char        |        int        |                 long                  |
| 1  | re |lle | no  | 2  | 3  | 4  | 5  | 6  | 7  | 8  | 9  | 10 | 11 | 12 | 13 |

    In total, the structure ends up occupying 16 bytes, which are the original 13 plus the 3 padding to make its size a multiple of the processor word (4 bytes).

    How do I know that the padding is between datos::cand datos::i? Because the information inside the structure is also being aligned datos; without the alignment it datos::iwould be straddling two processor words and would require two reads (and re-alignment) to be read. Also because we can check the address of each element, with this code:

    struct datos
{
    char c;
    int i;
    long l;
};

#define DISTANCIA(x, y) #x << " - " << #y << " = " << ((long long)((void*)&x) - (long long)((void*)&y))

int main()
{
    datos d;

    std::cout
        << DISTANCIA(d.c, d) << '\n'
        << DISTANCIA(d.i, d) << '\n'
        << DISTANCIA(d.l, d) << '\n';

    return 0;
}

    We get the following output:

    d.c - d = 0
d.i - d = 4
d.l - d = 8

    That shows us that between each data of the structure datosthere is a distance of 4 bytes.

    Align to my liking.

    If for some reason you want to prevent the compiler from deciding the size of your structures (you may be serializing them) you can use the attribute __attribute__((packed))in GCC and CLang or #pragma pack(1)in MSVC.

    MSVC 
    #pragma pack(1)
struct datos
{
    char c;
    int i;
    long l;
};
    GCC/CLang 
    struct datos
{
    char c;
    int i;
    long l;
}__attribute__((packed));

    With these changes, the following code:

    #define SO(x) #x << " = " << x
#define DISTANCIA(x, y) #x << " - " << #y << " = " << ((long long)((void*)&x) - (long long)((void*)&y))

int main()
{
    datos d;

    std::cout
        << SO(sizeof(d)) << '\n'
        << SO(sizeof(d.c)) << '\n'
        << SO(sizeof(d.i)) << '\n'
        << SO(sizeof(d.l)) << '\n'
        << SO(sizeof(char) + sizeof(int) + sizeof(long)) << '\n';

    std::cout
        << DISTANCIA(d.c, d) << '\n'
        << DISTANCIA(d.i, d) << '\n'
        << DISTANCIA(d.l, d) << '\n';

    return 0;
}

    Produces the following output:

    sizeof(d) = 13
sizeof(d.c) = 1
sizeof(d.i) = 4
sizeof(d.l) = 8
sizeof(char) + sizeof(int) + sizeof(long) = 13
d.c - d = 0
d.i - d = 1
d.l - d = 5

    In which we see that the size of the structure datoshas changed to 13 and the distance between datos::cand datos::iis 1 byte (the size of datos::c).

    1 There is nothing biblical about it.

    2 This is conceptually, the processor can read the memory in another way.

    • 10