來源 ：公眾號“TechZone”，作者：HarrisWilde

「本文目錄」

• 結(jié)構(gòu)體的聲明與定義

• 聲明

• 定義

• 訪問結(jié)構(gòu)體成員

• 初始化結(jié)構(gòu)體

• 對齊

• 結(jié)構(gòu)體嵌套

• 結(jié)構(gòu)體數(shù)組

• 結(jié)構(gòu)體指針

• 傳遞結(jié)構(gòu)體信息

• 傳遞結(jié)構(gòu)體變量

• 傳遞指向結(jié)構(gòu)體變量的指針

• 動態(tài)申請結(jié)構(gòu)體

• 實(shí)戰(zhàn)：建立一個圖書館數(shù)據(jù)庫

• 單鏈表

• 在單鏈表中插入元素

• 搜索單鏈表

• 插入結(jié)點(diǎn)到指定位置

• 刪除結(jié)點(diǎn)

• 內(nèi)存池

• typedef

• 給數(shù)據(jù)類型起別名

• 結(jié)構(gòu)體的搭檔

• 進(jìn)階

• 共用體

• 聲明

• 初始化

• 枚舉

• 位域

有的時候，我們所遇到的數(shù)據(jù)結(jié)構(gòu)，不僅僅是一群數(shù)字或者是字符串那么簡單。比如我們每一個人的學(xué)籍信息，學(xué)號是一個長整數(shù)，名字卻是字符；甚至有更復(fù)雜的情況，這種問題在現(xiàn)實(shí)生活中并不少見。我們之前學(xué)過一種叫數(shù)組的數(shù)據(jù)結(jié)構(gòu)，它可以允許我們把很多同類型的數(shù)據(jù)集中在一起處理。相對于之前，這已經(jīng)是一次極大的進(jìn)步。但是，新的問題，往往又會出現(xiàn)，這個時候，我們就得上更高端的裝備——結(jié)構(gòu)體。

相比于數(shù)組，結(jié)構(gòu)體有以下的更強(qiáng)大的優(yōu)勢：

• 批量存儲數(shù)據(jù)
• 存儲不同類型的數(shù)據(jù)
• 支持嵌套

結(jié)構(gòu)體的聲明與定義

聲明

結(jié)構(gòu)體的聲明使用struct關(guān)鍵字，如果我們想要把我們的學(xué)籍信息組織一下的話，可以這樣表示：

這樣，我們就相當(dāng)于描繪好了一個框架，以后要用的話直接定義一個這種類型的變量就好了。

定義

我們剛剛申請了一個名叫Info的結(jié)構(gòu)體類型，那么理論上我們可以像聲明其他變量的操作一樣，去聲明我們的結(jié)構(gòu)體操作，但是C語言中規(guī)定，聲明結(jié)構(gòu)體變量的時候，struct關(guān)鍵字是不可少的。

struct 結(jié)構(gòu)體類型名 結(jié)構(gòu)體變量名

不過，你可以在某個函數(shù)里面定義：

#include <stdio.h>

struct Info
{
    unsigned long identifier;//學(xué)號，用無符號長整數(shù)表示
    char name[20];//名字，用字符數(shù)組表示
    unsigned int year;//入學(xué)年份，用無符號整數(shù)表示
    unsigned int years;//學(xué)制，用無符號整數(shù)表示
};

int main(void)
{
    /**
     *在main函數(shù)中聲明結(jié)構(gòu)體變量
     *結(jié)構(gòu)體變量名叫info
     *struct關(guān)鍵字不能丟
     */
    struct Info info;
    ...
}

也可以在聲明的時候就把變量名定義下來（此時這個變量是全局變量）：

訪問結(jié)構(gòu)體成員

結(jié)構(gòu)體成員的訪問有點(diǎn)不同于以往的任何變量，它是采用點(diǎn)號運(yùn)算符.來訪問成員的。比如，info.name就是引用info結(jié)構(gòu)體的name成員，是一個字符數(shù)組，而info.year則可以查到入學(xué)年份，是個無符號整型。

比如，下面開始錄入學(xué)生的信息：

//Example 01
#include <stdio.h>

struct Info
{
    unsigned long identifier;//學(xué)號，用無符號長整數(shù)表示
    char name[20];//名字，用字符數(shù)組表示
    unsigned int year;//入學(xué)年份，用無符號整數(shù)表示
    unsigned int years;//學(xué)制，用無符號整數(shù)表示
};

int main(void)
{
    struct Info info;

    printf('請輸入學(xué)生的學(xué)號：');
    scanf('%d', &info.identifier);
    printf('請輸入學(xué)生的姓名：');
    scanf('%s', info.name);
    printf('請輸入學(xué)生的入學(xué)年份：');
    scanf('%d', &info.year);
    printf('請輸入學(xué)生的學(xué)制：');
    scanf('%d', &info.years);

    printf('\n數(shù)據(jù)錄入完畢\n\n');

    printf('學(xué)號：%d\n姓名：%s\n入學(xué)年份：%d\n學(xué)制：%d\n畢業(yè)時間：%d\n', \
        info.identifier, info.name, info.year, info.years, info.year + info.years);
    return 0;
}

運(yùn)行結(jié)果如下：

初始化結(jié)構(gòu)體

像數(shù)組一樣，結(jié)構(gòu)體也可以在定義的時候初始化，方法也幾乎一樣：

struct Info info = {
    20191101,
    'Harris',
    2019,
    4
};

在C99標(biāo)準(zhǔn)中，還支持給指定元素賦值（就像數(shù)組一樣）：

對于沒有被初始化的成員，則「數(shù)值型」成員初始化為0，「字符型」成員初始化為'\0’。

對齊

下面這個代碼，大家來看看會發(fā)生什么：

//EXample 02 V1
#include <stdio.h>

int main(void)
{
    struct A
    {
        char a;
        int b;
        char c;
    } a = {'a', 10, 'o'};
    
    printf('size of a = %d\n', sizeof(a));
    
    return 0;
}

我們之前學(xué)過，char類型的變量占1字節(jié)，int類型的變量占4字節(jié)，那么這么一算，一個結(jié)構(gòu)體A型的變量應(yīng)該就是6字節(jié)了。別急，我們看運(yùn)行結(jié)果：

怎么變成12了呢？標(biāo)準(zhǔn)更新了？老師教錯了？都不是。我們把代碼改一下：

//EXample 02 V2
#include <stdio.h>

int main(void)
{
    struct A
    {
        char a;
        char c;
        int b;
    } a = {'a', 'o', 10};
    
    printf('size of a = %d\n', sizeof(a));
    
    return 0;
}

結(jié)果：

實(shí)際上，這是編譯器對我們程序的一種優(yōu)化——內(nèi)存對齊。在第一個例子中，第一個和第三個成員是char類型是1個字節(jié)，而中間的int卻有4個字節(jié)，為了對齊，兩個char也占用了4個字節(jié)，于是就是12個字節(jié)。

而在第二個例子里面，前兩個都是char，最后一個是int，那么前兩個可以一起占用4個字節(jié)（實(shí)際只用2個，第一個例子也同理，只是為了訪問速度更快，而不是為了擴(kuò)展），最后的int占用4字節(jié)，合起來就是8個字節(jié)。

關(guān)于如何聲明結(jié)構(gòu)體來節(jié)省內(nèi)存容量，可以閱讀下面的這篇文章，作者是艾瑞克·雷蒙，時尚最具爭議性的黑客之一，被公認(rèn)為開源運(yùn)動的主要領(lǐng)導(dǎo)者之一：

英文原版，中文版

結(jié)構(gòu)體嵌套

在學(xué)籍里面，如果我們的日期想要更加詳細(xì)一些，精確到day，這時候就可以使用結(jié)構(gòu)體嵌套來完成：

#include <stdio.h>

struct Date
{
    unsigned int year;
    unsigned int month;
    unsigned int day;
};

struct Info
{
    unsigned long identifier;//學(xué)號，用無符號長整數(shù)表示
    char name[20];//名字，用字符數(shù)組表示
    struct Date date;/*---入學(xué)日期，用結(jié)構(gòu)體Date表示---*/
    unsigned int years;//學(xué)制，用無符號整數(shù)表示
};

int main(void)
{
    ...
}

如此一來，比我們單獨(dú)聲明普通變量快多了。

不過，這樣訪問變量，就必須用點(diǎn)號一層層往下訪問。比如要訪問day這個成員，那就只能info.date.day而不能直接info.date或者info,day。

運(yùn)行結(jié)果如下：

//Consequence 03
請輸入學(xué)生的學(xué)號：20191101
請輸入學(xué)生的姓名：Harris
請輸入學(xué)生的入學(xué)年份：2019
請輸入學(xué)生的入學(xué)月份：9
請輸入學(xué)生的入學(xué)日期：7
請輸入學(xué)生的學(xué)制：4

數(shù)據(jù)錄入完畢

學(xué)號：20191101
姓名：Harris
入學(xué)時間：2019/9/7
學(xué)制：4
畢業(yè)時間：2023

結(jié)構(gòu)體數(shù)組

剛剛我們演示了存儲一個學(xué)生的學(xué)籍信息的時候，使用結(jié)構(gòu)體的例子。那么，如果要錄入一批學(xué)生，這時候我們就可以沿用之前的思路，使用結(jié)構(gòu)體數(shù)組。

我們知道，數(shù)組的定義，就是存放一堆相同類型的數(shù)據(jù)的容器。而結(jié)構(gòu)體一旦被我們聲明，那么你就可以把它看作一個類型，只不過是你自己定義的罷了。

定義結(jié)構(gòu)體數(shù)組也很簡單：

結(jié)構(gòu)體指針

既然我們可以把結(jié)構(gòu)體看作一個類型，那么也就必然有對應(yīng)的指針變量。

struct Info* pinfo;

但是在指針這里，結(jié)構(gòu)體和數(shù)組就不一樣了。我們知道，數(shù)組名實(shí)際上就是指向這個數(shù)組第一個元素的地址，所以可以將數(shù)組名直接賦值給指針。而結(jié)構(gòu)體的變量名并不是指向該結(jié)構(gòu)體的地址，所以要使用取地址運(yùn)算符&才能獲取地址：

通過結(jié)構(gòu)體指針來訪問結(jié)構(gòu)體有以下兩種方法：

1. (*結(jié)構(gòu)體指針).成員名
2. 結(jié)構(gòu)體指針->成員名

第一個方法由于點(diǎn)號運(yùn)算符比指針的取值運(yùn)算符優(yōu)先級更高，因此需要加一個小括號來確定優(yōu)先級，讓指針先解引用變成結(jié)構(gòu)體變量，在使用點(diǎn)號的方法去訪問。

相比之下，第二種方法就直觀許多。

這兩種方法在實(shí)現(xiàn)上是完全等價的，但是點(diǎn)號只能用于結(jié)構(gòu)體變量，而箭頭只能夠用于指針。

第一種方法：

#include <stdio.h>
...
int main(void)
{
    struct Info *p;
    p = &info;
    
    printf('學(xué)號：\n', (*p).identifier);
    printf('姓名：\n', (*p).name);
    printf('入學(xué)時間：%d/%d/%d\n', (*p).date.year, (*p).date.month, (*p).date.day);
    printf('學(xué)制：\n', (*p).years);
    return 0;
}

第二種方法：

傳遞結(jié)構(gòu)體信息

傳遞結(jié)構(gòu)體變量

我們先來看看下面的代碼：

//Example 04
#include <stdio.h>

int main(void)
{
    struct Test
    {
        int x;
        int y;
    }t1, t2;

    t1.x = 3;
    t1.y = 4;
    t2 = t1;

    printf('t2.x = %d, t2.y = %d\n', t2.x, t2.y);
    return 0;
}

運(yùn)行結(jié)果如下：

這么看來，結(jié)構(gòu)體是可以直接賦值的。那么既然這樣，作為函數(shù)的參數(shù)和返回值也自然是沒問題的了。

先來試試作為參數(shù):

//Example 05
#include <stdio.h>
struct Date
{
    unsigned int year;
    unsigned int month;
    unsigned int day;
};

struct Info
{
    unsigned long identifier;
    char name[20];
    struct Date date;
    unsigned int years;
};

struct Info getInput(struct Info info);
void printInfo(struct Info info);

struct Info getInput(struct Info info)
{
    printf('請輸入學(xué)號：');
    scanf('%d', &info.identifier);
    printf('請輸入姓名：');
    scanf('%s', info.name);
    printf('請輸入入學(xué)年份：');
    scanf('%d', &info.date.year);
    printf('請輸入月份：');
    scanf('%d', &info.date.month);
    printf('請輸入日期：');
    scanf('%d', &info.date.day);
    printf('請輸入學(xué)制：');
    scanf('%d', &info.years);

    return info;
}

void printInfo(struct Info info)
{
    printf('學(xué)號：%d\n姓名：%s\n入學(xué)時間：%d/%d/%d\n學(xué)制：%d\n畢業(yè)時間：%d\n', \
        info.identifier, info.name, \
        info.date.year, info.date.month, info.date.day, \
        info.years, info.date.year + info.years);
}

int main(void)
{
    struct Info i1 = {};
    struct Info i2 = {};
    printf('請錄入第一個同學(xué)的信息...\n');
    i1 = getInput(i1);
    putchar('\n');
    printf('請錄入第二個學(xué)生的信息...\n');
    i2 = getInput(i2);

    printf('\n錄入完畢，現(xiàn)在開始打印...\n\n');
    printf('打印第一個學(xué)生的信息...\n');
    printInfo(i1);
    putchar('\n');
    printf('打印第二個學(xué)生的信息...\n');
    printInfo(i2);

    return 0;
}

運(yùn)行結(jié)果如下：

傳遞指向結(jié)構(gòu)體變量的指針

早期的C語言是不允許直接將結(jié)構(gòu)體作為參數(shù)直接傳遞進(jìn)去的。主要是考慮到如果結(jié)構(gòu)體的內(nèi)存占用太大，那么整個程序的內(nèi)存開銷就會爆炸。不過現(xiàn)在的C語言已經(jīng)放開了這方面的限制。

不過，作為一名合格的開發(fā)者，我們應(yīng)該要去珍惜硬件資源。那么，傳遞指針就是一個很好的辦法。

將剛才的代碼修改一下：

//Example 06
#include <stdio.h>
struct Date
{
    unsigned int year;
    unsigned int month;
    unsigned int day;
};

struct Info
{
    unsigned long identifier;
    char name[20];
    struct Date date;
    unsigned int years;
};

void getInput(struct Info *info);
void printInfo(struct Info *info);

void getInput(struct Info *info)
{
    printf('請輸入學(xué)號：');
    scanf('%d', &info->identifier);
    printf('請輸入姓名：');
    scanf('%s', info->name);
    printf('請輸入入學(xué)年份：');
    scanf('%d', &info->date.year);
    printf('請輸入月份：');
    scanf('%d', &info->date.month);
    printf('請輸入日期：');
    scanf('%d', &info->date.day);
    printf('請輸入學(xué)制：');
    scanf('%d', &info->years);
}

void printInfo(struct Info *info)
{
    printf('學(xué)號：%d\n姓名：%s\n入學(xué)時間：%d/%d/%d\n學(xué)制：%d\n畢業(yè)時間：%d\n', \
        info->identifier, info->name, \
        info->date.year, info->date.month, info->date.day, \
        info->years, info->date.year + info->years);
}

int main(void)
{
    struct Info i1 = {};
    struct Info i2 = {};
    printf('請錄入第一個同學(xué)的信息...\n');
    getInput(&i1);
    putchar('\n');
    printf('請錄入第二個學(xué)生的信息...\n');
    getInput(&i2);

    printf('\n錄入完畢，現(xiàn)在開始打印...\n\n');
    printf('打印第一個學(xué)生的信息...\n');
    printInfo(&i1);
    putchar('\n');
    printf('打印第二個學(xué)生的信息...\n');
    printInfo(&i2);

    return 0;
}

此時傳遞的就是一個指針，而不是一個龐大的結(jié)構(gòu)體。

動態(tài)申請結(jié)構(gòu)體

結(jié)構(gòu)體也可以在堆里面動態(tài)申請：

實(shí)戰(zhàn)：建立一個圖書館數(shù)據(jù)庫

實(shí)際上，我們建立的數(shù)組可以是指向結(jié)構(gòu)體指針的數(shù)組。

代碼實(shí)現(xiàn)如下：

//Example 02
#include <stdio.h>
#include <stdlib.h>

#define MAX_SIZE 100

struct Date
{
    int year;
    int month;
    int day;
};

struct Book
{
    char title[128];
    char author[48];
    float price;
    struct Date date;
    char publisher[48];
};

void getInput(struct Book* book);//錄入數(shù)據(jù)
void printBook(struct Book* book);//打印數(shù)據(jù)
void initLibrary(struct Book* lib[]);//初始化結(jié)構(gòu)體
void printLibrary(struct Book* lib[]);//打印單本書數(shù)據(jù)
void releaseLibrary(struct Book* lib[]);//釋放內(nèi)存

void getInput(struct Book* book)
{
    printf('請輸入書名：');
    scanf('%s', book->title);
    printf('請輸入作者：');
    scanf('%s', book->author);
    printf('請輸入售價：');
    scanf('%f', &book->price);
    printf('請輸入出版日期：');
    scanf('%d-%d-%d', &book->date.year, &book->date.month, &book->date.day);
    printf('請輸入出版社：');
    scanf('%s', book->publisher);
}

void printBook(struct Book* book)
{
    printf('書名：%s\n', book->title);
    printf('作者：%s\n', book->author);
    printf('售價：%.2f\n', book->price);
    printf('出版日期：%d-%d-%d\n', book->date.year, book->date.month, book->date.day);
    printf('出版社：%s\n', book->publisher);
}

void initLibrary(struct Book* lib[])
{
    for (int i = 0; i < MAX_SIZE; i++)
    {
        lib[i] = NULL;
    }
}

void printLibrary(struct Book* lib[])
{
    for (int i = 0; i < MAX_SIZE; i++)
    {
        if (lib[i] != NULL)
        {
            printBook(lib[i]);
            putchar('\n');
        }
    }
}

void releaseLibrary(struct Book* lib[])
{
    for (int i = 0; i < MAX_SIZE; i++)
    {
        if (lib[i] != NULL)
        {
            free(lib[i]);
        }
    }
}

int main(void)
{
    struct Book* lib[MAX_SIZE];
    struct Book* p = NULL;
    int ch, index = 0;

    initLibrary(lib);

    while (1)
    {
        printf('請問是否要錄入圖書信息(Y/N):');
        do
        {
            ch = getchar();
        } while (ch != 'Y' && ch != 'N');

        if (ch == 'Y')
        {
            if (index < MAX_SIZE)
            {
                p = (struct Book*)malloc(sizeof(struct Book));
                getInput(p);
                lib[index] = p;
                index++;
                putchar('\n');
            }
            else
            {
                printf('數(shù)據(jù)庫已滿！\n');
                break;
            }
        }
        else
        {
            break;
        }
    }

    printf('\n數(shù)據(jù)錄入完畢，開始打印驗(yàn)證...\n\n');
    printLibrary(lib);
    releaseLibrary(lib);

    return 0;
}

運(yùn)行結(jié)果如下：

單鏈表

我們知道，數(shù)組變量在內(nèi)存中，是連續(xù)的，而且不可拓展。顯然在一些情況下，這種數(shù)據(jù)結(jié)構(gòu)擁有很大的局限性。比如移動數(shù)據(jù)的時候，會牽一發(fā)而動全身，尤其是反轉(zhuǎn)這種操作更加令人窒息。那么，需要需要一種數(shù)據(jù)結(jié)構(gòu)來弄出一種更加靈活的“數(shù)組”，那么這，就是「鏈表」。

本節(jié)我們只講講單鏈表。

所謂鏈表，就是由一個個「結(jié)點(diǎn)」組成的一個數(shù)據(jù)結(jié)構(gòu)。每個結(jié)點(diǎn)都有「數(shù)據(jù)域」和「指針域」組成。其中數(shù)據(jù)域用來存儲你想要存儲的信息，而指針域用來存儲下一個結(jié)點(diǎn)的地址。如圖：

當(dāng)然，鏈表最前面還有一個頭指針，用來存儲頭結(jié)點(diǎn)的地址。

這樣一來，鏈表中的每一個結(jié)點(diǎn)都可以不用挨個存放，因?yàn)橛辛酥羔槹阉麄兇饋?。因此結(jié)點(diǎn)放在哪都無所謂，反正指針總是能夠指向下一個元素。我們只需要知道頭指針，就能夠順藤摸瓜地找到整個鏈表。

因此對于學(xué)籍?dāng)?shù)據(jù)庫來說，我們只需要在Info結(jié)構(gòu)體中加上一個指向自身類型的成員即可：

struct Info
{
    unsigned long identifier;
    char name[20];
    struct Date date;
    unsigned int years;
    struct Info* next;
};

在單鏈表中插入元素

頭插法

這種每次都將數(shù)據(jù)插入單鏈表的頭部（頭指針后面）的插入法就叫頭插法。

如果要把學(xué)生信息加入到單鏈表，可以這么寫：

?

由于students存放的是頭指針，因此我們需要傳入它的地址傳遞給函數(shù)，才能夠改變它本身的值。而students本身又是一個指向Info結(jié)構(gòu)體的指針，所以參數(shù)的類型應(yīng)該就是struct Info**。

?

往單鏈表里面添加一個結(jié)點(diǎn)，也就是先申請一個結(jié)點(diǎn)，然后判斷鏈表是否為空。如果為空，那么直接將頭指針指向它，然后next成員指向NULL。若不為空，那么先將next指向頭指針原本指向的結(jié)點(diǎn)，然后將頭指針指向新結(jié)點(diǎn)即可。

那么，打印鏈表也變得很簡單：

void printStu(struct Info* students)
{
    struct Info* info;
    int count = 1;
    
    info = students;
    while (book != NULL)
    {
        printf('Student%d:\n', count);
        printf('姓名：%s\n', info->name);
        printf('學(xué)號：%d\n', info->identifier);
        info = info->next;
        count++;
    }
}

想要讀取單鏈表里面的數(shù)據(jù)，只需要迭代單鏈表中的每一個結(jié)點(diǎn)，直到next成員為NULL，即表示單鏈表的結(jié)束。

最后，當(dāng)然還是別忘了釋放空間：

尾插法

與頭插法類似，尾插法就是把每一個數(shù)據(jù)都插入到鏈表的末尾。

void addInfo(struct Info** students)
{
    struct Info* info, *temp;
    info = (struct Info*)malloc(sizeof(struct Info));
    if (info == NULL)
    {
        printf('內(nèi)存分配失敗！\n');
        exit(1);
    }
    
    getInput(info);
    
    if (*students != NULL)
    {
        temp = *students;
        *students = info;
        //定位到鏈表的末尾的位置
        while (temp->next != NULL)
        {
            temp = temp->next;
        }
        //插入數(shù)據(jù)
        temp->next = info;
        info->next = temp;
    }
    else
    {
        *students = info;
        info->next = NULL;
    }
}

這么一來，程序執(zhí)行的效率難免要降低很多，因?yàn)槊看尾迦霐?shù)據(jù)，都要先遍歷一次鏈表。如果鏈表很長，那么對于插入數(shù)據(jù)來說就是一次災(zāi)難。不過，我們可以給程序添加一個指針，讓它永遠(yuǎn)都指向鏈表的尾部，這樣一來，就可以用很少的空間換取很高的程序執(zhí)行效率。

代碼更改如下：

搜索單鏈表

單鏈表是我們用來存儲數(shù)據(jù)的一個容器，那么有時候需要快速查找信息就需要開發(fā)相關(guān)搜索的功能。比如說輸入學(xué)號，查找同學(xué)的所有信息。

struct Info *searchInfo(struct Info* students, long* target)
{
    struct Info* info;
    info = students;
    while (info != NULL)
    {
        if (info->identifier == target)
        {
            break;
        }
        info = info->next;
    }
    
    return book;
};

void printInfo(struct Info* info)
{
    ...
}
...

int main(void)
{
    ...
    printf('\n請輸入學(xué)生學(xué)號：');
    scanf('%d', input);
    info = searchInfo(students, input);
    if (info == NULL)
    {
        printf('抱歉，未找到相關(guān)結(jié)果！\n');
    }
    else
    {
        do
        {
            printf('相關(guān)結(jié)果如下：\n');
            printInfo(book);
        } while ((info = searchInfo(info->next, input)) != NULL);
    }
    
    releaseInfo(...);
    return 0;
}

插入結(jié)點(diǎn)到指定位置

到了這里，才體現(xiàn)出鏈表真正的優(yōu)勢。

設(shè)想一下，如果有一個有序數(shù)組，現(xiàn)在要求你去插入一個數(shù)字，插入完成之后，數(shù)組依然保持有序。你會怎么做？

沒錯，你應(yīng)該會挨個去比較，然后找到合適的位置（當(dāng)然這里也可以使用二分法，比較節(jié)省算力），把這個位置后面的所有數(shù)都往后移動一個位置，然后將我們要插入的數(shù)字放入剛剛我們騰出來的空間里面。

你會發(fā)現(xiàn)，這樣的處理方法，經(jīng)常需要移動大量的數(shù)據(jù)，對于程序的執(zhí)行效率來說，是一個不利因素。那么鏈表，就無所謂。反正在內(nèi)存中，鏈表的存儲毫無邏輯，我們只需要改變指針的值就可以實(shí)現(xiàn)鏈表的中間插入。

運(yùn)行結(jié)果如下：

//Consequence 03
開始插入整數(shù)...
請輸入一個整數(shù)，輸入-1表示結(jié)束：4
4
請輸入一個整數(shù)，輸入-1表示結(jié)束：5
4 5
請輸入一個整數(shù)，輸入-1表示結(jié)束：3
3 4 5
請輸入一個整數(shù)，輸入-1表示結(jié)束：6
3 4 5 6
請輸入一個整數(shù)，輸入-1表示結(jié)束：2
2 3 4 5 6
請輸入一個整數(shù)，輸入-1表示結(jié)束：5
2 3 4 5 5 6
請輸入一個整數(shù)，輸入-1表示結(jié)束：1
1 2 3 4 5 5 6
請輸入一個整數(shù)，輸入-1表示結(jié)束：7
1 2 3 4 5 5 6 7
請輸入一個整數(shù)，輸入-1表示結(jié)束：-1

刪除結(jié)點(diǎn)

刪除結(jié)點(diǎn)的思路也差不多，首先修改待刪除的結(jié)點(diǎn)的上一個結(jié)點(diǎn)的指針，將其指向待刪除結(jié)點(diǎn)的下一個結(jié)點(diǎn)。然后釋放待刪除結(jié)點(diǎn)的空間。

內(nèi)存池

C語言的內(nèi)存管理，從來都是一個讓人頭禿的問題。要想更自由地管理內(nèi)存，就必須去堆中申請，然后還需要考慮何時釋放，萬一釋放不當(dāng)，或者沒有及時釋放，造成的后果都是難以估量的。

當(dāng)然如果就這些，那倒也還不算什么。問題就在于，如果大量地使用malloc和free函數(shù)來申請內(nèi)存，首先使要經(jīng)歷一個從應(yīng)用層切入系統(tǒng)內(nèi)核層，調(diào)用完成之后，再返回應(yīng)用層的一系列步驟，實(shí)際上使非常浪費(fèi)時間的。更重要的是，還會產(chǎn)生大量的內(nèi)存碎片。比如，先申請了一個1KB的空間，緊接著又申請了一個8KB的空間。而后，這個1KB使用完了，被釋放，但是這個空間卻只有等到下一次有剛好1KB的空間申請，才能夠被重新調(diào)用。這么一來，極限情況下，整個堆有可能被弄得支離破碎，最終導(dǎo)致大量內(nèi)存浪費(fèi)。

那么這種情況下，我們解決這類問題的思路，就是創(chuàng)建一個內(nèi)存池。

內(nèi)存池，實(shí)際上就是我們讓程序創(chuàng)建出來的一塊額外的緩存區(qū)域，如果有需要釋放內(nèi)存，先不必使用free函數(shù)，如果內(nèi)存池有空，那么直接放入內(nèi)存池。同樣的道理，下一次程序申請空間的時候，先檢查下內(nèi)存池里面有沒有合適的內(nèi)存，如果有，則直接拿出來調(diào)用，如果沒有，那么再使用malloc。

其實(shí)內(nèi)存池我們就可以使用單鏈表來進(jìn)行維護(hù)，下面通過一個通訊錄的程序來說明內(nèi)存池的運(yùn)用。

普通的版本：

//Example 04 V1
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct Person
{
 char name[40];
 char phone[20];
 struct Person* next;
};

void getInput(struct Person* person);
void printPerson(struct Person* person);
void addPerson(struct Person** contects);
void changePerson(struct Person* contacts);
void delPerson(struct Person** contacts);
struct Person* findPerson(struct Person* contacts);
void displayContacts(struct Person* contacts);
void releaseContacts(struct Person** contacts);

void getInput(struct Person* person)
{
 printf('請輸入姓名：');
 scanf('%s', person->name);
 printf('請輸入電話：');
 scanf('%s', person->phone);
}

void addPerson(struct Person** contacts)
{
 struct Person* person;
 struct Person* temp;

 person = (struct Person*)malloc(sizeof(struct Person));
 if (person == NULL)
 {
  printf('內(nèi)存分配失?。n');
  exit(1);
 }

 getInput(person);

 //將person添加到通訊錄中
 if (*contacts != NULL)
 {
  temp = *contacts;
  *contacts = person;
  person->next = temp;
 }
 else
 {
  *contacts = person;
  person->next = NULL;
 }
}

void printPerson(struct Person* person)
{
 printf('聯(lián)系人：%s\n', person->name);
 printf('電話：%s\n', person->phone);
}

struct Person* findPerson(struct Person* contacts)
{
 struct Person* current;
 char input[40];

 printf('請輸入聯(lián)系人：');
 scanf('%s', input);

 current = contacts;
 while (current != NULL && strcmp(current->name, input))
 {
  current = current->next;
 }

 return current;
}

void changePerson(struct Person* contacts)
{
 struct Person* person;

 person = findPerson(contacts);
 if (person == NULL)
 {
  printf('找不到聯(lián)系人！\n');
 }
 else
 {
  printf('請輸入聯(lián)系電話：');
  scanf('%s', person->phone);
 }
}

void delPerson(struct Person** contacts)
{
 struct Person* person;
 struct Person* current;
 struct Person* previous;

 //先找到待刪除的節(jié)點(diǎn)的指針
 person = findPerson(*contacts);
 if (person == NULL)
 {
  printf('找不到該聯(lián)系人！\n');
 }
 else
 {
  current = *contacts;
  previous = NULL;

  //將current定位到待刪除的節(jié)點(diǎn)
  while (current != NULL && current != person)
  {
   previous = current;
   current = current->next;
  }

  if (previous == NULL)
  {
   //若待刪除的是第一個節(jié)點(diǎn)
   *contacts = current->next;
  }
  else
  {
   //若待刪除的不是第一個節(jié)點(diǎn)
   previous->next = current->next;
  }

  free(person);//將內(nèi)存空間釋放
 }
}

void displayContacts(struct Person* contacts)
{
 struct Person* current;

 current = contacts;
 while (current != NULL)
 {
  printPerson(current);
  current = current->next;
 }
}

void releaseContacts(struct Person** contacts)
{
 struct Person* temp;

 while (*contacts != NULL)
 {
  temp = *contacts;
  *contacts = (*contacts)->next;
  free(temp);
 }
}

int main(void)
{
 int code;
 struct Person* contacts = NULL;
 struct Person* person;

 printf('| 歡迎使用通訊錄管理程序 |\n');
 printf('|--- 1:插入新的聯(lián)系人 ---|\n');
 printf('|--- 2:查找現(xiàn)有聯(lián)系人 ---|\n');
 printf('|--- 3:更改現(xiàn)有聯(lián)系人 ---|\n');
 printf('|--- 4:刪除現(xiàn)有聯(lián)系人 ---|\n');
 printf('|--- 5:顯示當(dāng)前通訊錄 ---|\n');
 printf('|--- 6:退出通訊錄程序 ---|\n');

 while (1)
 {
  printf('\n請輸入指令代碼：');
  scanf('%d', &code);
  switch (code)
  {
  case 1:addPerson(&contacts); break;
  case 2:person = findPerson(contacts);
   if (person == NULL)
   {
    printf('找不到該聯(lián)系人！\n');
   }
   else
   {
    printPerson(person);
   }
   break;
  case 3:changePerson(contacts); break;
  case 4:delPerson(&contacts); break;
  case 5:displayContacts(contacts); break;
  case 6:goto END;
  }
 }

END://此處直接跳出恒循環(huán)
 releaseContacts(&contacts);

 return 0;

}

運(yùn)行結(jié)果如下：

下面加入內(nèi)存池：

//Example 04 V2
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX 1024

struct Person
{
 char name[40];
 char phone[20];
 struct Person* next;
};

struct Person* pool = NULL;
int count;

void getInput(struct Person* person);
void printPerson(struct Person* person);
void addPerson(struct Person** contects);
void changePerson(struct Person* contacts);
void delPerson(struct Person** contacts);
struct Person* findPerson(struct Person* contacts);
void displayContacts(struct Person* contacts);
void releaseContacts(struct Person** contacts);
void releasePool(void);

void getInput(struct Person* person)
{
 printf('請輸入姓名：');
 scanf('%s', person->name);
 printf('請輸入電話：');
 scanf('%s', person->phone);
}

void addPerson(struct Person** contacts)
{
 struct Person* person;
 struct Person* temp;

 //如果內(nèi)存池不是空的，那么首先從里面獲取空間
 if (pool != NULL)
 {
  person = pool;
  pool = pool->next;
  count--;
 }
 //內(nèi)存池為空，則直接申請
 else
 {
  person = (struct Person*)malloc(sizeof(struct Person));
  if (person == NULL)
  {
   printf('內(nèi)存分配失?。n');
   exit(1);
  }
 }


 getInput(person);

 //將person添加到通訊錄中
 if (*contacts != NULL)
 {
  temp = *contacts;
  *contacts = person;
  person->next = temp;
 }
 else
 {
  *contacts = person;
  person->next = NULL;
 }
}

void printPerson(struct Person* person)
{
 printf('聯(lián)系人：%s\n', person->name);
 printf('電話：%s\n', person->phone);
}

struct Person* findPerson(struct Person* contacts)
{
 struct Person* current;
 char input[40];

 printf('請輸入聯(lián)系人：');
 scanf('%s', input);

 current = contacts;
 while (current != NULL && strcmp(current->name, input))
 {
  current = current->next;
 }

 return current;
}

void changePerson(struct Person* contacts)
{
 struct Person* person;

 person = findPerson(contacts);
 if (person == NULL)
 {
  printf('找不到聯(lián)系人！\n');
 }
 else
 {
  printf('請輸入聯(lián)系電話：');
  scanf('%s', person->phone);
 }
}

void delPerson(struct Person** contacts)
{
 struct Person* person;
 struct Person* current;
 struct Person* previous;
 struct Person* temp;
 {

 };

 //先找到待刪除的節(jié)點(diǎn)的指針
 person = findPerson(*contacts);
 if (person == NULL)
 {
  printf('找不到該聯(lián)系人！\n');
 }
 else
 {
  current = *contacts;
  previous = NULL;

  //將current定位到待刪除的節(jié)點(diǎn)
  while (current != NULL && current != person)
  {
   previous = current;
   current = current->next;
  }

  if (previous == NULL)
  {
   //若待刪除的是第一個節(jié)點(diǎn)
   *contacts = current->next;
  }
  else
  {
   //若待刪除的不是第一個節(jié)點(diǎn)
   previous->next = current->next;
  }

  //判斷內(nèi)存池中有沒有空位
  if (count < MAX)
  {
   //使用頭插法將person指向的空間插入內(nèi)存池中
   if (pool != NULL)
   {
    temp = pool;
    pool = person;
    person->next = temp;
   }
   else
   {
    pool = person;
    person->next = NULL;
   }
   count++;
  }
  //沒有空位，直接釋放
  else
  {
   free(person);//將內(nèi)存空間釋放
  }
 }
}

void displayContacts(struct Person* contacts)
{
 struct Person* current;

 current = contacts;
 while (current != NULL)
 {
  printPerson(current);
  current = current->next;
 }
}

void releaseContacts(struct Person** contacts)
{
 struct Person* temp;

 while (*contacts != NULL)
 {
  temp = *contacts;
  *contacts = (*contacts)->next;
  free(temp);
 }
}

void releasePool(void)
{
 struct Person* temp;
 while (pool != NULL)
 {
  temp = pool;
  pool = pool->next;
  free(temp);
 }
}

int main(void)
{
 int code;
 struct Person* contacts = NULL;
 struct Person* person;

 printf('| 歡迎使用通訊錄管理程序 |\n');
 printf('|--- 1:插入新的聯(lián)系人 ---|\n');
 printf('|--- 2:查找現(xiàn)有聯(lián)系人 ---|\n');
 printf('|--- 3:更改現(xiàn)有聯(lián)系人 ---|\n');
 printf('|--- 4:刪除現(xiàn)有聯(lián)系人 ---|\n');
 printf('|--- 5:顯示當(dāng)前通訊錄 ---|\n');
 printf('|--- 6:退出通訊錄程序 ---|\n');

 while (1)
 {
  printf('\n請輸入指令代碼：');
  scanf('%d', &code);
  switch (code)
  {
  case 1:addPerson(&contacts); break;
  case 2:person = findPerson(contacts);
   if (person == NULL)
   {
    printf('找不到該聯(lián)系人！\n');
   }
   else
   {
    printPerson(person);
   }
   break;
  case 3:changePerson(contacts); break;
  case 4:delPerson(&contacts); break;
  case 5:displayContacts(contacts); break;
  case 6:goto END;
  }
 }

END://此處直接跳出恒循環(huán)
 releaseContacts(&contacts);
 releasePool();

 return 0;

}

typedef

給數(shù)據(jù)類型起別名

C語言是一門古老的語言，它是在1969至1973年間，由兩位天才丹尼斯·里奇和肯·湯普遜在貝爾實(shí)驗(yàn)室以B語言為基礎(chǔ)開發(fā)出來的，用于他們的重寫UNIX計(jì)劃（這也為后來UNIX系統(tǒng)的可移植性打下了基礎(chǔ)，之前的UNIX是使用匯編語言編寫的，當(dāng)然也是這兩位為了玩一個自己設(shè)計(jì)的游戲而編寫的）。天才就是和咱常人不一樣，不過他倆的故事，在這篇里面不多啰嗦，我們回到話題。

雖然C語言誕生的很早，但是卻依舊不是最早的高級編程語言。目前公認(rèn)的最早的高級編程語言，是IBM公司于1957年開發(fā)的FORTRAN語言。C語言誕生之時，F(xiàn)ORTRAN已經(jīng)統(tǒng)領(lǐng)行業(yè)數(shù)十年之久。因此，C語言要想快速吸納FORTRAN中的潛在用戶，就必須做出一些妥協(xié)。

我們知道，不同的語言的語法，一般來說是不同的，甚至還有較大的差距。比如：

C:

而FORTRAN語言是這樣的：

integer :: a, b, c;
real :: i, j, k;

如果讓FORTRAN用戶使用原來的變量名稱進(jìn)行使用，那么就能夠快速遷移到C語言上面來，這就是typedef的用處之一。

我們使用FORTRAN語言的類型名，那就這么辦：

結(jié)構(gòu)體的搭檔

雖然結(jié)構(gòu)體的出現(xiàn)能夠讓我們有一個更科學(xué)的數(shù)據(jù)結(jié)構(gòu)來管理數(shù)據(jù)，但是每次使用結(jié)構(gòu)體都需要struct...，未免顯得有些冗長和麻煩。有了typedef的助攻，我們就可以很輕松地給結(jié)構(gòu)體類型起一個容易理解的名字：

typedef struct date
{
    int year;
    int month;
    int day;
} DATE;//為了區(qū)分，一般用全大寫

int main(void)
{
    DATE* date;
    ...
}

甚至還可以順便給它的指針也定義一個別名：

進(jìn)階

我們還可以利用typedef來簡化一些比較復(fù)雜的命令。

比如：

int (*ptr) [5];

我們知道這是一個數(shù)組指針，指向一個5元素的數(shù)組。那么我們可以改寫成這樣：

這樣就可以把很復(fù)雜的聲明變得很簡單：

PTR_TO_ARRAY a = &array;

取名的時候要盡量使用容易理解的名字，這樣才能達(dá)到使用typedef的最終目的。

共用體

共用體也稱聯(lián)合體。

聲明

和結(jié)構(gòu)體還是有點(diǎn)像：

但是兩者有本質(zhì)的不同。共用體的每一個成員共用一段內(nèi)存，那么這也就意味著它們不可能同時被正確地訪問。如：

//Example 05
#include <stdio.h>
#include <string.h>

union Test
{
 int i;
 double pi;
 char str[9];
};

int main(void)
{
 union Test test;

 test.i = 10;
 test.pi = 3.14;
 strcpy(test.str, 'TechZone');

 printf('test.i: %d\n', test.i);
 printf('test.pi: %.2f\n', test.pi);
 printf('test.str: %s\n', test.str);

 return 0;
}

執(zhí)行結(jié)果如下：

可以看到，共用體只能正確地展示出最后一次被賦值的成員。共用體的內(nèi)存應(yīng)該要能夠滿足最大的成員能夠正常存儲。但是并不一定等于最大的成員的尺寸，因?yàn)檫€要考慮內(nèi)存對齊的問題。

共用體可以類似結(jié)構(gòu)體一樣來定義和聲明，但是共用體還可以允許不帶名字：

union
{
 int i;
 char ch;
 float f;
} a, b;

初始化

共用體不能在同一時間存放多個成員，所以不能批量初始化

枚舉

枚舉是一個基本的數(shù)據(jù)類型，它可以讓數(shù)據(jù)更簡潔。

如果寫一個判斷星期的文章，我們當(dāng)然可以使用宏定義來使代碼更加易懂，不過：

#define MON 1
#define TUE 2
#define WED 3
#define THU 4
#define FRI 5
#define SAT 6
#define SUN 7

這樣的寫法有點(diǎn)費(fèi)鍵盤。那么枚舉就簡單多了：

?

**注意：**第一個枚舉成員的默認(rèn)值為整型的 0，后續(xù)枚舉成員的值在前一個成員上加 1。我們在這個實(shí)例中把第一個枚舉成員的值定義為 1，第二個就為 2，以此類推。

?

枚舉變量的定義和聲明方法和共用體一樣，也可以省略枚舉名，直接聲明變量名。

//Example 06
#include <stdio.h>
#include <stdlib.h>

int main()
{

    enum color { red = 1, green, blue };

    enum  color favorite_color;

    printf('請輸入你喜歡的顏色: (1. red, 2. green, 3. blue): ');
    scanf('%d', &favorite_color);

    //輸出結(jié)果
    switch (favorite_color)
    {
    case red:
        printf('你喜歡的顏色是紅色');
        break;
    case green:
        printf('你喜歡的顏色是綠色');
        break;
    case blue:
        printf('你喜歡的顏色是藍(lán)色');
        break;
    default:
        printf('你沒有選擇你喜歡的顏色');
    }

    return 0;
}

執(zhí)行結(jié)果如下：

也可以把整數(shù)轉(zhuǎn)換為枚舉類型：

//Example 07

#include <stdio.h>
#include <stdlib.h>

int main()
{
    enum day
    {
        saturday,
        sunday,
        monday,
        tuesday,
        wednesday,
        thursday,
        friday
    } workday;

    int a = 1;
    enum day weekend;
    weekend = (enum day) a;  //使用強(qiáng)制類型轉(zhuǎn)換
    //weekend = a; //錯誤
    printf('weekend:%d', weekend);
    return 0;
}

運(yùn)行結(jié)果如下：

位域

C語言除了開發(fā)桌面應(yīng)用等，還有一個很重要的領(lǐng)域，那就是「單片機(jī)」開發(fā)。單片機(jī)上的硬件資源十分有限，容不得我們?nèi)ニ烈鈸]灑。單片機(jī)使一種集成電路芯片，使采用超大規(guī)模集成電路技術(shù)把具有數(shù)據(jù)處理能力的CPU、RAM、ROM、I/O、中斷系統(tǒng)、定時器/計(jì)數(shù)器等功能（有的還包括顯示驅(qū)動電路、脈寬調(diào)制電路、模擬多路轉(zhuǎn)換器、A/D轉(zhuǎn)換器等電路）集成到一塊硅片上構(gòu)成的一個小而完善的微型計(jì)算機(jī)系統(tǒng)，在工控領(lǐng)域使用廣泛。

對于這樣的設(shè)備，通常內(nèi)存只有256B，那么能夠給我們利用的資源就十分珍貴了。在這種情況下，如果我們只需要定義一個變量來存放布爾值，一般就申請一個整型變量，通過1和0來間接存儲。但是，顯然1和0只用1個bit就能夠放完，而一個整型卻是4個字節(jié)，也就是32bit。這就造成了內(nèi)存的浪費(fèi)。

好在，C語言為我們提供了一種數(shù)據(jù)結(jié)構(gòu)，稱為「位域」（也叫位端、位字段）。也就是把一個字節(jié)中的二進(jìn)制位劃分，并且你能夠指定每個區(qū)域的位數(shù)。每個域有一個域名，并允許程序中按域名進(jìn)行單獨(dú)操作。

使用位域的做法是在結(jié)構(gòu)體定義的時候，在結(jié)構(gòu)體成員后面使用冒號（:）和數(shù)字來表示該成員所占的位數(shù)。

//Example 08
#include <stdio.h>

int main(void)
{
 struct Test
 {
  unsigned int a : 1;
  unsigned int b : 1;
  unsigned int c : 2;
 } test;
 
 test.a = 0;
 test.b = 1;
 test.c = 2;

 printf('a = %d, b = %d, c = %d\n', test.a, test.b, test.c);
 printf('size of test = %d\n', sizeof(test));

 return 0;
}

運(yùn)行結(jié)果如下：

如此一來，結(jié)構(gòu)體test只用了4bit，卻存放下了0、1、2三個整數(shù)。但是由于2在二進(jìn)制中是10，因此占了2個bit。如果把test.b賦值為2，那么：

//Consequence 08 V2
a = 0, b = 0, c = 2
size of test = 4

可以看到，b中的10溢出了，只剩下0。

當(dāng)然，位域的寬度不能夠超過本身類型的長度，比如：

那么就會報錯：

錯誤C2034“main::test::a”: 位域類型對位數(shù)太小

位域成員也可以沒有名稱，只要給出類型和寬度即可：

無名位域一般用來作為填充或者調(diào)整成員的位置，因?yàn)闆]有名稱，所以無名位域并不能夠拿來使用。

?

C語言的標(biāo)準(zhǔn)只說明unsigned int和signed int支持位域，然后C99增加了_Bool類型也支持位域，其他數(shù)據(jù)類型理論上是不支持的。不過大多數(shù)編譯器在具體實(shí)現(xiàn)時都進(jìn)行了擴(kuò)展，額外支持了signed char、unsigned char以及枚舉類型，所以如果對char類型的結(jié)構(gòu)體成員使用位域，基本上也沒什么問題。但如果考慮到程序的可移植性，就需要謹(jǐn)慎對待了。另外，由于內(nèi)存的基本單位是字節(jié)，而位域只是字節(jié)的一部分，所以并不能對位域進(jìn)行取地址運(yùn)算。

?

雖然科技發(fā)展日新月異，但是秉承著節(jié)約成本這個放之四海而皆準(zhǔn)的原則，還是要注意使用！畢竟5毛錢可能是小錢，但是乘以5000萬呢？