( 위의 대답은 아주 명확하게 이유를 설명하지만, 완전히 패딩의 크기가 해결되지 것 같다, 그래서, 내가 배운 내용에 따라 답변을 추가합니다 구조 포장의 잃어버린 예술 , 그것은에없는 한계까지 진화했다 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입니다.
