2. 程式人生 > >結構體對齊詳解

結構體對齊詳解

阿新 • • 發佈：2019-02-20

閱讀說明

1、在文中要注意#pragma pack（）函式的使用

2、本文中博主用於演示的是linux32位系統

3、如果有不同意見可以在下面評論區一起討論（windows下的我不是很清楚，聽說例二windows下的那個分析有問題,1B+8B=13B，閱讀分析時請注意）

4、我覺得這篇文章解釋的非常清楚，看完之後醍醐灌頂

5、標註為“注”的是我的註釋

我認為結構體對齊要考慮三點：

1、確認結構體對齊值（模數），通過比較【#pragma pack指定的數值】、【未指定#pragma pack時，系統預設的對齊模數（32位系統為4位元組，64位為8位元組）】和【結構體內部最大的基本資料型別成員】長度中數值較小

者。結構體的長度應該是該模數的整數倍。

2、確定成員自身對齊模數（首先需要明確的是各個資料成員的對齊模數，對齊模數和資料成員本身的長度以及pragma pack編譯引數有關，其值是二者中最小數）

3、結構體對齊

我對結構體大小的計算方法和本文作者講解的方法有所不一樣，但是文章作者的圖畫的很清晰。

我是這樣理解例一的：我在linux64位下操作

struct my_struct 
{ 
    char a; 
    long double b; 
};

首先確定對齊模數，long double在64位下對齊模數是16，長度為16，大於64位的8，這裡沒有呼叫#pragma pack（），因此綜合考慮後，結構體對齊模數為16.
char佔一個位元組，因為成員自身要對齊，後面填充15個位元組，16是long double模數的最小整數倍，long double長度為16，所以1+15+16=32，最後考慮結構體自身對齊，因為32是16的倍數，因此該結構體大小為32.

改進程式碼：

struct A
{
    char a;
    long double d;  
    char x;

}A;

int main()
{

    printf("%d\n",sizeof(A))；
    return 0;
}

結果：

[fanmaolin@Centeros pen]$ ./a.out 
48

下面是轉載文章：

1 – 結構體資料成員對齊的意義

許多實際的計算機系統對基本型別資料在記憶體中存放的位置有限制，它們會要求這些資料的起始地址的值是某個數k的倍數，這就是所謂的記憶體對齊，而這個k則被稱為該資料型別的對齊模數(alignment modulus)。這種強制的要求一來簡化了處理器與記憶體之間傳輸系統的設計，二來可以提升讀取資料的速度。
比如這麼一種處理器，它每次讀寫記憶體的時候都從某個8倍數的地址開始，一次讀出或寫入8個位元組的資料，假如軟體能保證double型別的資料都從8倍數地址開始，那麼讀或寫一個double型別資料就只需要一次記憶體操作。否則，我們就可能需要兩次記憶體操作才能完成這個動作，因為資料或許恰好橫跨在兩個符合對齊要求的8位元組記憶體塊上。

2 – 結構體對齊包括兩個方面的含義

1)結構體總長度；
2)結構體內各資料成員的記憶體對齊，即該資料成員相對結構體的起始位置；

3 – 結構體大小的計算方法和步驟

1)將結構體內所有資料成員的長度值相加，記為sum_a；

2)將各資料成員為了記憶體對齊，按各自對齊模數而填充的位元組數累加到和sum_a上，記為sum_b。對齊模數是#pragma pack指定的數值以及該資料成員自身長度中數值較小者。該資料相對起始位置應該是對齊模式的整數倍;

3)將和sum_b向結構體模數對齊，該模數是【#pragma pack指定的數值】、【未指定#pragma pack時，系統預設的對齊模數（32位系統為4位元組，64位為8位元組）】和【結構體內部最大的基本資料型別成員】長度中數值較小者。結構體的長度應該是該模數的整數倍。

注 ：預設的系統長度應該是比較大的，我在例一中的實際結果顯示結構體對齊模數應該是16，那麼還是小於系統的長度。

4 – 結構體大小計算舉例

在計算之前，我們首先需要明確的是各個資料成員的對齊模數，對齊模數和資料成員本身的長度以及pragma pack編譯引數有關，其值是二者中最小數。如果程式沒有明確指出，就需要知道編譯器預設的對齊模數值。下表是Windows XP/DEV-C++和Linux/GCC中基本資料型別的長度和預設對齊模數。

注 ： 上面這句話初看沒什麼，等到實際操作的時候就會發現他的威力。比如例二，如果不加pragma pack（2），在64位linux下，執行結果為32，但是加上後，變為了18，結構體對齊模數和資料成員對齊模數都出現了變化，變為2.

這裡寫圖片描述

例子1：

struct my_struct 
{ 
    char a; 
    long double b; 
};

此例子Windows和Linux計算方法有些許不一致。
在Windows中計算步驟如下：
步驟1：所有資料成員自身長度和：1B + 8B = 9B –> sum_a = 9B
步驟2：資料成員a放在相對偏移0處，之前不需要填充位元組；資料成員b為了記憶體對齊，根據“結構體大小的計算方法和步驟”中第二條原則，其對齊模數是8，之前需填充7個位元組，sum_a + 7 = 16B –> sum_b = 16 B
步驟3：按照定義，結構體對齊模數是結構體內部最大資料成員長度和pragma pack中較小者，前者為8後者為4，所以結構體對齊模數是4。sum_b是4的4倍，不需再次對齊。
綜上3步，可知結構體的長度是16B，各資料成員在記憶體中的分佈如圖1-1所示。

在Linux中計算步驟如下：
步驟1：所有資料成員自身長度和：1B + 12B = 13B –> sum_a = 13B
步驟2：資料成員a放在相對偏移0處，之前不需要填充位元組；資料成員b為了記憶體對齊，根據“結構體大小的計算方法和步驟”中第二條原則，其對齊模數是4，之前需填充3個位元組，sum_a + 3 = 16B –> sum_b = 16 B
步驟3：按照定義，結構體對齊模數是結構體內部最大資料成員長度和pragma pack中較小者，前者為12後者為4，所以結構體對齊模數是4。sum_b是4的4倍，不需再次對齊。
綜上3步，可知結構體的長度是16B，各資料成員在記憶體中的分佈如圖1-2所示。

這裡寫圖片描述

例子2：

#pragma pack(2) 
struct my_struct 
{ 
    char a; 
    long double b; 
};

例子1和例子2不同之處在於例子2中使用了#pragma pack(2)編譯引數，它強制指定對齊模數是2。此例子Windows和Linux計算方法有些許不一致。

在Windows中計算步驟如下：
步驟1：所有資料成員自身長度和：1B + 8B = 13B –> sum_a = 9B
步驟2：資料成員a放在相對偏移0處，之前不需要填充位元組；資料成員b為了記憶體對齊，根據“結構體大小的計算方法和步驟”中第二條原則，其對齊模數是2，之前需填充1個位元組，sum_a + 1 = 10B –> sum_b = 10 B
步驟3：按照定義，結構體對齊模數是結構體內部最大資料成員長度和pragma pack中較小者，前者為8後者為2，所以結構體對齊模數是2。sum_b是2的5倍，不需再次對齊。
綜上3步，可知結構體的長度是10B，各資料成員在記憶體中的分佈如圖2-1所示。

在Linux中計算步驟如下：
步驟1：所有資料成員自身長度和：1B + 12B = 13B –> sum_a = 13B
步驟2：資料成員a放在相對偏移0處，之前不需要填充位元組；資料成員b為了記憶體對齊，根據“結構體大小的計算方法和步驟”中第二條原則，其對齊模數是2，之前需填充1個位元組，sum_a + 1 = 14B –> sum_b = 14 B
步驟3：按照定義，結構體對齊模數是結構體內部最大資料成員長度和pragma pack中較小者，前者為8後者為2，所以結構體對齊模數是2。sum_b是2的7倍，不需再次對齊。
綜上3步，可知結構體的長度是14B，各資料成員在記憶體中的分佈如圖2-2所示。

這裡寫圖片描述

例子3：

struct my_struct 
{ 
    char a; 
    double b; 
    char c; 
};

前兩例中，資料成員在Linux和Windows下都相同，例3中double的對齊模數在Linux中是4，在Windows下是8，針對這種模數不相同的情況加以分析。
在Windows中計算步驟如下：
步驟1：所有資料成員自身長度和：1B + 8B + 1B = 10B –> sum_a = 10B
步驟2：資料成員a放在相對偏移0處，之前不需要填充位元組；資料成員b為了記憶體對齊，根據“結構體大小的計算方法和步驟”中第二條原則，其對齊模數是8，之前需填充7個位元組，sum_a + 7 = 17B –> sum_b = 17B
步驟3：按照定義，結構體對齊模數是結構體內部最大資料成員長度和pragma pack中較小者，前者為8後者為8，所以結構體對齊模數是8。sum_b應該是8的整數倍，所以要在結構體後填充8*3 - 17 = 7個位元組。
綜上3步，可知結構體的長度是24B，各資料成員在記憶體中的分佈如圖3-1所示。

在Linux中計算步驟如下：
步驟1：所有資料成員自身長度和：1B + 8B + 1B = 10B，sum_a = 10B
步驟2：資料成員a放在相對偏移0處，之前不需要填充位元組；資料成員b為了記憶體對齊，根據“結構體大小的計算方法和步驟”中第二條原則，其對齊模數是4，之前需填充3個位元組，sum_b = sum_a + 3 = 13B
步驟3：按照定義，結構體對齊模數是結構體內部最大資料成員長度和pragma
pack中較小者，前者為8後者為4，所以結構體對齊模數是4。sum_b應該是4的整數倍，所以要在結構體後填充4*4 - 13 = 3個位元組。
綜上3步，可知結構體的長度是16B，各資料成員在記憶體中的分佈如圖3-2所示。

這裡寫圖片描述

例子4：

struct my_struct 
{ 
    char a[11]; 
    int b; 
    char c; 
};

此例子Windows和Linux計算方法一樣，如下：
步驟1：所有資料成員自身長度和：11B + 4B + 1B = 16B –> sum_a = 16B
步驟2：資料成員a放在相對偏移0處，之前不需要填充位元組；資料成員b為了記憶體對齊，根據“結構體大小的計算方法和步驟”中第二條原則，其對齊模數是4，之前需填充3個位元組，sum_a + 1 = 17B –> sum_b = 17B
步驟3：按照定義，結構體對齊模數是結構體內部最大資料成員長度和pragma pack中較小者，前者為4後者為4，所以結構體對齊模數是4。sum_b是4的整數倍，需在結構體後填充4*5 - 17 = 1個位元組。
綜上3步，可知結構體的長度是20B，各資料成員在記憶體中的分佈如圖4所示。

這裡寫圖片描述

例子5：

struct my_test 
{ 
    int my_test_a; 
    char my_test_b; 
}; 
struct my_struct 
{ 
    struct my_test a; 
    double my_struct_a; 
    int my_struct_b; 
    char my_struct_c; 
};

例子5和前幾個例子均不同，在此例子中我們要計算struct my_struct的大小，而my_struct中嵌套了一個my_test結構體。這種結構體應該如何計算呢？原則是將my_test在my_struct中先展開，然後再計算，即是展開成如下結構體：

struct my_struct
{
    int my_test_a;
    char my_test_b;
    double my_struct_a;
    int my_struct_b;
    char my_struct_c;
};

此例子Windows中的計算方法如下：
步驟1：所有資料成員自身長度和：4B + 1B + 8B + 4B + 1B= 18B –> sum_a = 18B
步驟2：資料成員my_struct_a為了記憶體對齊，根據“結構體大小的計算方法和步驟”中第二條原則，其對齊模數是8，之前需填充3個位元組：sum_a + 3 = 21B –> sum_b = 21B
步驟3：按照定義，結構體對齊模數是結構體內部最大資料成員長度和pragma pack中較小者，前者為8後者為8，所以結構體對齊模數是8。sum_b是8的整數倍，需在結構體後填充3*8 - 21 = 3個位元組。
綜上3步，可知結構體的長度是24B，各資料成員在記憶體中的分佈如圖5所示。

此例子Linux中的計算方法如下：
步驟1：所有資料成員自身長度和：4B + 1B + 8B + 4B + 1B= 18B，sum_a = 18B
步驟2：資料成員my_struct_a為了記憶體對齊，根據“結構體大小的計算方法和步驟”中第二條原則，其對齊模數是4，之前需填充3個位元組，sum_b = sum_a + 3 = 21B
步驟3：按照定義，結構體對齊模數是結構體內部最大資料成員長度和pragma
pack中較小者，前者為4後者為4，所以結構體對齊模數是4。sum_b是4的整數倍，需在結構體後填充6*4 - 21 = 3個位元組。
綜上3步，可知結構體的長度是24B，各資料成員在記憶體中的分佈如圖5所示。

這裡寫圖片描述

5 – 原始碼附錄

上面的例子均在Windows(VC++6.0)和Linux(GCC4.1.0)上測試驗證。下面是測試程式。

#include <iostream>

#include <stdio.h>

using namespace std;

int main()
{
    cout << "sizeof(char)        = " << sizeof(char) << endl;
    cout << "sizeof(short)       = " << sizeof(short) << endl;
    cout << "sizeof(int)         = " << sizeof(int) << endl;
    cout << "sizeof(long)        = " << sizeof(long) << endl;
    cout << "sizeof(float)       = " << sizeof(float) << endl;
    cout << "sizeof(double)      = " << sizeof(double) << endl;
    cout << "sizeof(long long)   = " << sizeof(long long) << endl;
    cout << "sizeof(long double) = " << sizeof(long double) << endl << endl;    

    // 例子1
    {
        struct my_struct 
        { 
            char a; 
            long double b; 
        };
        cout << "exapmle-1: sizeof(my_struct) = " << sizeof(my_struct) << endl;

        struct my_struct data;

        printf("my_struct->a: %u\nmy_struct->b: %u\n\n", &data.a, &data.b);
    }

    // 例子2
    {
        #pragma pack(2) 
        struct my_struct 
        { 
            char a; 
            long double b; 
        }; 

        #pragma pack()
        struct my_struct data;

        cout << "exapmle-2: sizeof(my_struct) = " << sizeof(my_struct) << endl;

        printf("my_struct->a: %u\nmy_struct->b: %u\n\n", &data.a, &data.b);
    }

    // 例子3
    {
        struct my_struct 
        { 
            char a; 
            double b; 
            char c; 
        }; 

        struct my_struct data;

        cout << "exapmle-3: sizeof(my_struct) = " << sizeof(my_struct) << endl;

        printf("my_struct->a: %u\nmy_struct->b: %u\nmy_struct->c: %u\n\n", &data.a, &data.b, &data.c);
    }

    // 例子4
    {
        struct my_struct 
        {  
            char a[11];  
            int b;  
            char c;  
        };

        cout << "example-4: sizeof(my_struct) = " << sizeof(struct my_struct) << endl;

        struct my_struct data;
        printf("my_struct->a: %u\nmy_struct->b: %u\nmy_struct->c: %u\n\n", &data, &data.b, &data.c);
    }

    // 例子5 
    {
        struct my_test 
        { 
            int my_test_a; 
            char my_test_b; 
        }; 

        struct my_struct 
        { 
            struct my_test a; 
            double my_struct_a; 
            int my_struct_b; 
            char my_struct_c; 
        }; 
        cout << "example-5: sizeof(my_struct) = " << sizeof(struct my_struct) << endl;

        struct my_struct data;
        printf("my_struct->my_test_a  : %u\n"
            "my_struct->my_test_b  : %u\n"
            "my_struct->my_struct_a: %u\n"
            "my_struct->my_struct_b: %u\n"
            "my_struct->my_struct_c: %u\n", &data.a.my_test_a, &data.a.my_test_b, 
            &data.my_struct_a, &data.my_struct_b, &data.my_struct_c);
    }

    return 0;
}

執行結果：

//Linux localhost 3.4.6-2.10-desktop #1 SMP PREEMPT Thu Jul 28 19:20:26 UTC 2012 (641c197) x86_64 x86_64 x86_64 GNU/Linux
sizeof(char)        = 1
sizeof(short)       = 2
sizeof(int)         = 4
sizeof(long)        = 8
sizeof(float)       = 4
sizeof(double)      = 8
sizeof(long long)   = 8
sizeof(long double) = 16

exapmle-1: sizeof(my_struct) = 32
my_struct->a: 2163695552
my_struct->b: 2163695568

exapmle-2: sizeof(my_struct) = 18
my_struct->a: 2163695680
my_struct->b: 2163695682

exapmle-3: sizeof(my_struct) = 24
my_struct->a: 2163695648
my_struct->b: 2163695656
my_struct->c: 2163695664

example-4: sizeof(my_struct) = 20
my_struct->a: 2163695616
my_struct->b: 2163695628
my_struct->c: 2163695632

example-5: sizeof(my_struct) = 24
my_struct->my_test_a  : 2163695584
my_struct->my_test_b  : 2163695588
my_struct->my_struct_a: 2163695592
my_struct->my_struct_b: 2163695600
my_struct->my_struct_c: 2163695604
//Linux localhost 3.4.6-2.10-desktop #1 SMP PREEMPT Thu Jul 26 09:36:26 UTC 2012 (641c197) i686 i686 i386 GNU/Linux
sizeof(char)        = 1
sizeof(short)       = 2
sizeof(int)         = 4
sizeof(long)        = 4
sizeof(float)       = 4
sizeof(double)      = 8
sizeof(long long)   = 8
sizeof(long double) = 12

exapmle-1: sizeof(my_struct) = 16
my_struct->a: 3213889904
my_struct->b: 3213889908

exapmle-2: sizeof(my_struct) = 14
my_struct->a: 3213889890
my_struct->b: 3213889892

exapmle-3: sizeof(my_struct) = 16
my_struct->a: 3213889872
my_struct->b: 3213889876
my_struct->c: 3213889884

example-4: sizeof(my_struct) = 20
my_struct->a: 3213889852
my_struct->b: 3213889864
my_struct->c: 3213889868

example-5: sizeof(my_struct) = 24
my_struct->my_test_a  : 3213889828
my_struct->my_test_b  : 3213889832
my_struct->my_struct_a: 3213889836
my_struct->my_struct_b: 3213889844
my_struct->my_struct_c: 3213889848

//CYGWIN_NT-6.1 motadou-PC 1.7.20(0.266/5/3) 2013-06-07 11:11 i686 Cygwin
sizeof(char)        = 1
sizeof(short)       = 2
sizeof(int)         = 4
sizeof(long)        = 4
sizeof(float)       = 4
sizeof(double)      = 8
sizeof(long long)   = 8
sizeof(long double) = 12

exapmle-1: sizeof(my_struct) = 16
my_struct->a: 2272336
my_struct->b: 2272340

exapmle-2: sizeof(my_struct) = 14
my_struct->a: 2272322
my_struct->b: 2272324

exapmle-3: sizeof(my_struct) = 24
my_struct->a: 2272296
my_struct->b: 2272304
my_struct->c: 2272312

example-4: sizeof(my_struct) = 20
my_struct->a: 2272276
my_struct->b: 2272288
my_struct->c: 2272292

example-5: sizeof(my_struct) = 24
my_struct->my_test_a  : 2272248
my_struct->my_test_b  : 2272252
my_struct->my_struct_a: 2272256
my_struct->my_struct_b: 2272264
my_struct->my_struct_c: 2272268

相關推薦

結構體對齊詳解

閱讀說明 1、在文中要注意#pragma pack（）函式的使用 2、本文中博主用於演示的是linux32位系統 3、如果有不同意見可以在下面評論區一起討論（windows下的我不是很清楚，聽說例二windows下的那個分析有問題,1B+8B=13B，閱讀

3.c語音結構體成員內存對齊詳解

定義 pre 形狀 sed 兩個 分配 我們 替代 images 一.關鍵一點 最關鍵的一點:結構體在內存中是一個矩形,而不是一個不規則形狀 二.編程實戰 1 #include <stdlib.h> 2 #inc

初夏小談：結構體記憶體對齊詳解

記憶體對齊？什麼是記憶體對齊？ 對於這個問題我們先來看看這樣的一個結構體（在32位系統下） typedef struct Stu1 { char C1; int num1; short S1; }Stu1; 如果我們不知道記憶體對齊或者不清楚記憶體對齊時，我們可能這樣分析

C/C++結構體對齊方式詳解，從記憶體地址進行解析

注意：童鞋們如果仔仔細細看完這篇部落格，肯定能明白結構體的對齊方式。 最近在做一個專案的時候，客戶給的鐳射點雲檔案是二進位制形式，因此需要根據客戶定義的結構體，將點雲檔案儲存為文字檔案方便在第三方軟體如cloudCompare中檢視。但是發現客戶的結構體所佔記憶體空間跟我的

C/C++ 結構體位元組對齊詳解

結構體的sizeof 先看一個結構體： struct S1 { char c; int i; }; 12345 structS1{charc;in

sizeof與strlen用法詳解(結構體對齊)

#include<stdio.h> int main(int argc,char **argv) { unsigned char a[10] ={1,2,1,2,3,4}; unsigned char a1[10] ={0,0,0,0,0,0}; char *

C/C++結構體位元組對齊詳解

前提：為了訪問速度和效率，需要各種型別資料按照一定的規則在空間上排列； 不是所有的硬體平臺都能訪問任意地址上的任意資料的；某些硬體平臺只能在某些地址處取 某些特定型別的資料，否則丟擲硬體異常。 為了訪問未對⻬的記憶體，處理器需要作兩次記憶體訪問；⽽對⻬的記憶體訪問僅需要

#pragma pack，__attribute__選項和結構體對齊相關問題詳解

pack 為 struct, union 和 class 等的成員對齊指定位元組邊界. 與編譯選項的 /Zp 開關不同, 它不針對整個專案, 而僅針對模組, 比如一個編譯單元.1. #pragma pack(show)    以警告資訊的形式顯示當前位元組對齊的值.2. #pragma pack(n)   

13）結構體對齊問題

ngs dmi nts min mage ++ image http c語言 詳細可以看 臺式機的 C:\Documents and Settings\Administrator\桌面\C++基礎教程完整版視頻\01_C語言提高\d

結構體對齊

str center 但是 內存 read 地址 形式參數 class area 1 C語言裏可以在一個存儲區裏記錄多個相關數字這種存儲區的類型叫結構體類型，這種類型需要首先創建出來然後才能使用 2 結構體類型存儲區裏包含多個子存儲區，每個子存儲區可以記錄一個數字，結構體中

可變大小結構體如何定義詳解

pan 動態分配 很多 假設 spa 浪費 使用數組 緩沖 發送 一、背景 　　工作中，在通信協議中常常看到TLV格式數據，不同的type id對應的字符串長度大小不一樣。那麽該怎麽去定義一個結構體去管理這些數據呢？怎麽去定義一種可變大小的結構體？本文將講解如何定義可變大小

linux中結構體對齊【轉】

src double 無需 fine types 查看 真理 blog 多個 轉自：https://blog.csdn.net/suifengpiao_2011/article/details/47260085 linux中定義對齊字節 typedef struct

逆向基礎之結構體對齊

eof 成員對齊 偏移 str 最大 結構體 基礎 數據 sizeof 遵循以下原則，數據成員對齊；結構體大小；結構體有某些成員大，最大對齊，對齊參數筆結構體的sizeof小，偏移以此為準。struct{ char a;int b;char c;}a 1b,補3b 4bc

結構體對齊總結

結構體對齊 結構體對齊到底是什麼，看了網上很多的解答，彙總成個人經驗 什麼是結構體對齊 結構體對齊規則 考慮一個問題，為什麼要設計記憶體對齊的處理方式呢？ ENDING 結構體對齊到底是什麼，看了網上很多

C語言結構體對齊(記憶體對齊問題)

C語言結構體對齊也是老生常談的話題了。基本上是面試題的必考題。內容雖然很基礎，但一不小心就會弄錯。寫出一個struct，然後sizeof，你會不會經常對結果感到奇怪？sizeof的結果往往都比你宣告的變數總長度要大，這是怎麼回事呢？     開始學的時候，

結構體對齊——結構體記憶體佈局

在C語言中，可以通過#pragma pack(n)來指定結構體按n位元組對齊（這裡的n是2的較小整數次冪）。如果程式設計者不指定對齊位元組數，那麼預設的會按照結構體中最長那一項對齊，如在64位作業系統中，當結構體中出現（void *），（long）型別，則必然是按照8位元組對齊；當最大的是int，那麼就按照4

結構體對齊——結構體內存布局

聲明 amp pri 最大的 結構 sdn int spa turn 在C語言中，可以通過#pragma pack(n)來指定結構體按n字節對齊（這裏的n是2的較小整數次冪）。如果程序設計者不指定對齊字節數，那麽默認的會按照結構體中最長那一項對齊，如在64位操作系統中，當結

pragma pack位元組對齊詳解

強調一點： #pragma pack(4) typedef struct {     char buf[3];     word a; }kk; #pragma pack()

C/C++ struct 結構體定義 用法詳解

在C語言中，定義一個結構體型別要用typedef : typedef struct point { int x; int y; }Point; 在宣告變數的時候就可以：Point

C-結構體對齊

技術群的筒子們有時候會提到結構體對齊，說實話這個問題還不是幾句話能講清楚的。這個問題網上一搜一大把，已經有無數的前輩總結過。看了很多網上的資料，根據我個人的一些理解，再總結一下，配了些圖片，希望大家能看懂。 首先是結構體對齊規則： 1、對於n個位元組的元素，它的首地址要能