c/c++ 结构体大小计算

sizeof 和 strlen区别

sizeof 是编译时的操作符，它用来计算数据类型或者对象所占用的大小(以字节为单位),它在编译时计算，不再运行时消耗资源。

strlen 是c语言库函数，用于计算字符串的长度，返回的是字符串中字符的数量（不包括结束符 ‘\0’）

int a = 10;
printf("sizeof(a) = %zu\n", sizeof(a));  // 输出 int 类型的大小（通常是 4 字节）

char str[] = "Hello";
printf("sizeof(str) = %zu\n", sizeof(str));  // 输出数组 str 的总大小，通常是 6 字节（包含末尾的 null 字符）

char* p1 = (char*)("Hello");
int* p2 = nullptr;
// 输出的是指针的大小，p1 = p2 = 8(64-bit 程序编译)
printf("sizeof(p1) = %d ,sizeof(p2) = %d \n", sizeof(p1),sizeof(p2));  

测一测:

    char str[20]  = "0123456789";
    int a = strlen(str);
    int b = sizeof(str);

a = 10 ,b = 20

    const char *str  = "0123456789";
    int a = strlen(str);
    int b = sizeof(str);
    int c = sizeof(*str);

• a：strlen(str) 返回的是字符串 “0123456789” 的长度，不包括结尾的 ‘\0’，因此是 10。
• b：sizeof(str) 计算的是指针 str 的大小，而不是它指向的字符串大小，通常在 64 位系统上是 8 字节。
• c：sizeof(*str) 计算的是 str 指向的对象（即 char 类型）的大小，char 类型的大小是 1 字节。

    char buff[] = "Hello";
    int a = strlen(buff);
    int b = sizeof(buff);

a：strlen(buff) 计算的是 "Hello" 字符串的长度，不包括结尾的 '\0'，因此是 5。
b：sizeof(buff) 计算的是字符数组 buff 的总大小，包括结尾的 null 字符 '\0'，因此是 6 字节。

结构体大小计算

uint8_t = 1-bit
uint16_t = 2-bit
uint32_t = 4-bit
uint64_t = 8-bit

struct test
{
  uint8_t  a;  //1
  uint8_t  b;  //1
  uint8_t  c;  //1
};

每个变量都是占一个字节，对齐也是1字节，所以结构体大小是 3字节

struct test
{
  uint8_t   a;  //1
  uint16_t  b;  //2
  uint8_t   c;  //1
};

• a 占 1 字节。
• b 占 2 字节，并且需要 1 字节填充来满足对齐要求。
• c 占 1 字节。
• 最终为了满足结构体的整体对齐要求，结构体的大小会根据最大对齐要求进行填充，这里的最大对齐要求是 2 字节（因为 uint16_t 需要 2 字节对齐）。因此，整个结构体会对齐到 2 字节边界。
  最终结果，结构体大小为 6-bit

typedef struct
{
        uint8_t a;
        uint16_t b;
        uint32_t c;
        uint64_t d;        
}ST1;

计算结构体如下:
a = 1,b = 2, 此时 a 对齐 b ，所以 a = 2
b = 2,c = 4, 此时他们不需要对齐

在 64 位系统上，通常系统会要求结构体的对齐大小是其成员中对齐要求最大的那个，这里是 8 字节（uint64_t 的对齐要求）。因此，整个结构体的大小也会按照 8 字节对齐。

详细布局：

• a（uint8_t）占 1 字节。
• b（uint16_t）占 2 字节，并且需要 2 字节对齐。为了保证对齐，编译器会在 a 后面填充 1 个字节，所以 b 将从第 2 字节开始，且总共占用 2 字节。
• c（uint32_t）占 4 字节，并且需要 4 字节对齐。为了保证对齐，编译器会在 b 后面填充 2 个字节，使得 c 从第 4 字节开始，且总共占用 4 字节。
• d（uint64_t）占 8 字节，并且需要 8 字节对齐。为了保证对齐，编译器会在 c 后面填充 4 个字节，使得 d 从第 8 字节开始，且总共占用 8 字节。
  最终，结构体的总大小会按照 8 字节对齐，因此结构体的大小是 16 字节。

printf(“sizeof(ST1) = %zu\n”, sizeof(ST1)); // 输出 16

typedef struct
{
        uint16_t b;
        uint32_t c;
        uint64_t d;        
        uint8_t  a;
}ST2;

最终结果: 24-bit