[c] 구조 패딩 및 포장

( 위의 대답은 아주 명확하게 이유를 설명하지만, 완전히 패딩의 크기가 해결되지 것 같다, 그래서, 내가 배운 내용에 따라 답변을 추가합니다 구조 포장의 잃어버린 예술 , 그것은에없는 한계까지 진화했다 C, 그러나 또한 적용에 Go, Rust. )

메모리 정렬 (구조용)

규칙 :

• 각 개별 구성원 앞에는 크기로 나눌 수있는 주소에서 시작하도록 패딩이 있습니다.
  예를 들어 64 비트 시스템에서는 int주소를 4로 나누고 long8 short을 2 로 나눠서 시작해야합니다 .
• char그리고 char[]그들이 전에 패딩을 필요가 없습니다, 어떤 메모리 주소 수, 특별하다.
• struct각각의 개별 부재에 대한 정렬 필요 이외의 경우 , 전체 구조체 자체의 크기는 끝에서 패딩함으로써 가장 큰 개별 부재의 크기로 나눌 수있는 크기로 정렬 될 것이다.
  예를 들어 구조체의 가장 큰 멤버 long를 8로 나눈 int다음 4, short2 로 나눌 수 있습니다.

회원 순서 :

• 멤버의 순서는 구조체의 실제 크기에 영향을 줄 수 있으므로 명심하십시오. 예 를 들어 아래 stu_c및 stu_d예제에서 동일한 멤버를 가지지 만 순서가 다르므로 두 구조체의 크기가 다릅니다.

메모리의 주소 (struct 용)

규칙 :

• 64 비트 시스템 구조
  주소는 (n * 16)바이트 에서 시작 합니다. ( 아래 예제에서 볼 수있는 구조체의 모든 16 진수 주소는으로 끝납니다 0. )
  이유 : 가능한 가장 큰 개별 구조체 멤버는 16 바이트 ( long double)입니다.
• (업데이트) 구조체에charas 멤버만 포함하면해당 주소는 모든 주소에서 시작할 수 있습니다.

빈 공간 :

• 두 구조체 사이의 빈 공간은 비 구조 변수에 의해 사용될 수 있습니다.
  예를 들어 test_struct_address()아래에서 변수 x는 인접한 구조체 g와 사이에 있습니다 h. 선언
  여부 x에 관계없이 h의 주소는 변경되지 않으며 x빈 공간을 재사용했습니다 g.
  의 경우도 마찬가지입니다 y.

예

( 64 비트 시스템 용 )

memory_align.c :

/**
 * Memory align & padding - for struct.
 * compile: gcc memory_align.c
 * execute: ./a.out
 */
#include <stdio.h>

// size is 8, 4 + 1, then round to multiple of 4 (int's size),
struct stu_a {
    int i;
    char c;
};

// size is 16, 8 + 1, then round to multiple of 8 (long's size),
struct stu_b {
    long l;
    char c;
};

// size is 24, l need padding by 4 before it, then round to multiple of 8 (long's size),
struct stu_c {
    int i;
    long l;
    char c;
};

// size is 16, 8 + 4 + 1, then round to multiple of 8 (long's size),
struct stu_d {
    long l;
    int i;
    char c;
};

// size is 16, 8 + 4 + 1, then round to multiple of 8 (double's size),
struct stu_e {
    double d;
    int i;
    char c;
};

// size is 24, d need align to 8, then round to multiple of 8 (double's size),
struct stu_f {
    int i;
    double d;
    char c;
};

// size is 4,
struct stu_g {
    int i;
};

// size is 8,
struct stu_h {
    long l;
};

// test - padding within a single struct,
int test_struct_padding() {
    printf("%s: %ld\n", "stu_a", sizeof(struct stu_a));
    printf("%s: %ld\n", "stu_b", sizeof(struct stu_b));
    printf("%s: %ld\n", "stu_c", sizeof(struct stu_c));
    printf("%s: %ld\n", "stu_d", sizeof(struct stu_d));
    printf("%s: %ld\n", "stu_e", sizeof(struct stu_e));
    printf("%s: %ld\n", "stu_f", sizeof(struct stu_f));

    printf("%s: %ld\n", "stu_g", sizeof(struct stu_g));
    printf("%s: %ld\n", "stu_h", sizeof(struct stu_h));

    return 0;
}

// test - address of struct,
int test_struct_address() {
    printf("%s: %ld\n", "stu_g", sizeof(struct stu_g));
    printf("%s: %ld\n", "stu_h", sizeof(struct stu_h));
    printf("%s: %ld\n", "stu_f", sizeof(struct stu_f));

    struct stu_g g;
    struct stu_h h;
    struct stu_f f1;
    struct stu_f f2;
    int x = 1;
    long y = 1;

    printf("address of %s: %p\n", "g", &g);
    printf("address of %s: %p\n", "h", &h);
    printf("address of %s: %p\n", "f1", &f1);
    printf("address of %s: %p\n", "f2", &f2);
    printf("address of %s: %p\n", "x", &x);
    printf("address of %s: %p\n", "y", &y);

    // g is only 4 bytes itself, but distance to next struct is 16 bytes(on 64 bit system) or 8 bytes(on 32 bit system),
    printf("space between %s and %s: %ld\n", "g", "h", (long)(&h) - (long)(&g));

    // h is only 8 bytes itself, but distance to next struct is 16 bytes(on 64 bit system) or 8 bytes(on 32 bit system),
    printf("space between %s and %s: %ld\n", "h", "f1", (long)(&f1) - (long)(&h));

    // f1 is only 24 bytes itself, but distance to next struct is 32 bytes(on 64 bit system) or 24 bytes(on 32 bit system),
    printf("space between %s and %s: %ld\n", "f1", "f2", (long)(&f2) - (long)(&f1));

    // x is not a struct, and it reuse those empty space between struts, which exists due to padding, e.g between g & h,
    printf("space between %s and %s: %ld\n", "x", "f2", (long)(&x) - (long)(&f2));
    printf("space between %s and %s: %ld\n", "g", "x", (long)(&x) - (long)(&g));

    // y is not a struct, and it reuse those empty space between struts, which exists due to padding, e.g between h & f1,
    printf("space between %s and %s: %ld\n", "x", "y", (long)(&y) - (long)(&x));
    printf("space between %s and %s: %ld\n", "h", "y", (long)(&y) - (long)(&h));

    return 0;
}

int main(int argc, char * argv[]) {
    test_struct_padding();
    // test_struct_address();

    return 0;
}

실행 결과- test_struct_padding():

stu_a: 8
stu_b: 16
stu_c: 24
stu_d: 16
stu_e: 16
stu_f: 24
stu_g: 4
stu_h: 8

실행 결과- test_struct_address():

stu_g: 4
stu_h: 8
stu_f: 24
address of g: 0x7fffd63a95d0  // struct variable - address dividable by 16,
address of h: 0x7fffd63a95e0  // struct variable - address dividable by 16,
address of f1: 0x7fffd63a95f0 // struct variable - address dividable by 16,
address of f2: 0x7fffd63a9610 // struct variable - address dividable by 16,
address of x: 0x7fffd63a95dc  // non-struct variable - resides within the empty space between struct variable g & h.
address of y: 0x7fffd63a95e8  // non-struct variable - resides within the empty space between struct variable h & f1.
space between g and h: 16
space between h and f1: 16
space between f1 and f2: 32
space between x and f2: -52
space between g and x: 12
space between x and y: 12
space between h and y: 8

따라서 각 변수의 주소 시작은 g : d0 x : dc h : e0 y : e8입니다.

답변

#pragma pack(n)