函數(shù)指針

函數(shù)指針是指向函數(shù)的指針變量。

通常我們說的指針變量是指向一個整型、字符型或數(shù)組等變量，而函數(shù)指針是指向函數(shù)。

函數(shù)指針可以像一般函數(shù)一樣，用于調(diào)用函數(shù)、傳遞參數(shù)。

函數(shù)指針變量的聲明：

typedef int (*fun_ptr)(int,int); // 聲明一個指向同樣參數(shù)、返回值的函數(shù)指針類型

實例

以下實例聲明了函數(shù)指針變量 p，指向函數(shù) max：

void test_function_pointer(){
    /* p 是函數(shù)指針 */
    int (* p)(int, int) = & max_num; // &可以省略
    int a, b, c, d;
    printf("please input three nums:");
    scanf("%d %d %d", & a, & b, & c);
    /* 與直接調(diào)用函數(shù)等價，d = max(max(a, b), c) */
    d = p(p(a, b), c);

    printf("max num is : %d\n", d);
}

int max_num(int num, int numT) {
    return num > numT ? num : numT;
}

please input three nums:3 69 12
3 69 12
max num is : 69

Process finished with exit code 0

回調(diào)函數(shù)

函數(shù)指針作為某個函數(shù)的參數(shù)

函數(shù)指針變量可以作為某個函數(shù)的參數(shù)來使用的，回調(diào)函數(shù)就是一個通過函數(shù)指針調(diào)用的函數(shù)。

簡單講：回調(diào)函數(shù)是由別人的函數(shù)執(zhí)行時調(diào)用你實現(xiàn)的函數(shù)。

你到一個商店買東西，剛好你要的東西沒有貨，于是你在店員那里留下了你的電話，過了幾天店里有貨了，店員就打了你的電話，然后你接到電話后就到店里去取了貨。在這個例子里，你的電話號碼就叫回調(diào)函數(shù)，你把電話留給店員就叫登記回調(diào)函數(shù)，店里后來有貨了叫做觸發(fā)了回調(diào)關(guān)聯(lián)的事件，店員給你打電話叫做調(diào)用回調(diào)函數(shù)，你到店里去取貨叫做響應(yīng)回調(diào)事件。

實例

實例中 assignment_array函數(shù)定義了三個參數(shù)，其中第三個參數(shù)是函數(shù)的指針，通過該函數(shù)來設(shè)置數(shù)組的值。

實例中我們定義了回調(diào)函數(shù) get_random_value，它返回一個隨機值，它作為一個函數(shù)指針傳遞給 assignment_array函數(shù)。

assignment_array將調(diào)用 10 次回調(diào)函數(shù)，并將回調(diào)函數(shù)的返回值賦值給數(shù)組。

int get_random_value() {
    return rand();
}

void assignment_array(int *array, size_t arraySize, int(*get_dom_value(void))) {
    //從此處可以看出   函數(shù)指針作為某個函數(shù)的參數(shù)   時，方法名稱不需一一對應(yīng)
    for (size_t i = 0; i < arraySize; i++) {
        array[i] = get_dom_value();
    }

}

void test_assignment_array() {
    int myarray[10];
    assignment_array(myarray, 10, get_random_value);
    for(int i = 0; i < 10; i++) {
        printf("%d ", myarray[i]);
    }
    printf("\n");
}

41 18467 6334 26500 19169 15724 11478 29358 26962 24464

Process finished with exit code 0

size_t 類型在C語言標(biāo)準(zhǔn)庫函數(shù)原型使用的很多，數(shù)值范圍一般是要大于int和unsigned.

但凡不涉及負(fù)值范圍的表示size取值的，都可以用size_t；比如array[size_t]。

size_t 在stddef.h頭文件中定義。

在其他常見的宏定義以及函數(shù)中常用到有：

1，sizeof運算符返回的結(jié)果是size_t類型；

2，void *malloc(size_t size)...

字符串

在 C 語言中，字符串實際上是使用 null 字符 '\0' 終止的一維字符數(shù)組。因此，一個以 null 結(jié)尾的字符串，包含了組成字符串的字符。

下面的聲明和初始化創(chuàng)建了一個 "Hello" 字符串。由于在數(shù)組的末尾存儲了空字符，所以字符數(shù)組的大小比單詞 "Hello" 的字符數(shù)多一個。

char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};

依據(jù)數(shù)組初始化規(guī)則，您可以把上面的語句寫成以下語句：

char greeting[] = "Hello";

以下是 C/C++ 中定義的字符串的內(nèi)存表示：

image

C 中有大量操作字符串的函數(shù)：

下面的實例使用了上述的一些函數(shù)：

void string_test() {
    char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
    printf("Greeting message: %s\n", greeting);
    
    char str1[12] = "Hello";
    char str2[12] = "World";
    char str3[12];
    int len;

    /* 復(fù)制 str1 到 str3 */
    strcpy(str3, str1);
    printf("strcpy( str3, str1) :  %s\n", str3);

    /* 連接 str1 和 str2 */
    strcat(str1, str2);
    printf("strcat( str1, str2):   %s\n", str1);

    /* 連接后，str1 的總長度 */
    len = strlen(str1);
    printf("strlen(str1) :  %d\n", len);
}

Greeting message: Hello
strcpy( str3, str1) :  Hello
strcat( str1, str2):   HelloWorld
strlen(str1) :  10

Process finished with exit code 0

您可以在 C 標(biāo)準(zhǔn)庫中找到更多字符串相關(guān)的函數(shù)。

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

C 數(shù)組允許定義可存儲相同類型數(shù)據(jù)項的變量，結(jié)構(gòu)是 C 編程中另一種用戶自定義的可用的數(shù)據(jù)類型，它允許您存儲不同類型的數(shù)據(jù)項。

結(jié)構(gòu)用于表示一條記錄，假設(shè)您想要跟蹤圖書館中書本的動態(tài)，您可能需要跟蹤每本書的下列屬性：

• Title

• Author

• Subject

• Book ID

定義結(jié)構(gòu)

為了定義結(jié)構(gòu)，您必須使用 struct 語句。struct 語句定義了一個包含多個成員的新的數(shù)據(jù)類型，struct 語句的格式如下：

struct tag { 
    member-list
    member-list 
    member-list  
    ...
} variable-list ;

tag 是結(jié)構(gòu)體標(biāo)簽。

member-list 是標(biāo)準(zhǔn)的變量定義，比如 int i; 或者 float f，或者其他有效的變量定義。

variable-list 結(jié)構(gòu)變量，定義在結(jié)構(gòu)的末尾，最后一個分號之前，您可以指定一個或多個結(jié)構(gòu)變量。下面是聲明 Book 結(jié)構(gòu)的方式：

struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
} book;

在一般情況下，tag、member-list、variable-list 這 3 部分至少要出現(xiàn) 2 個。以下為實例：

//此聲明聲明了擁有3個成員的結(jié)構(gòu)體，分別為整型的a，字符型的b和雙精度的c
//同時又聲明了結(jié)構(gòu)體變量s1
//這個結(jié)構(gòu)體并沒有標(biāo)明其標(biāo)簽
struct 
{
    int a;
    char b;
    double c;
} s1;
 
//此聲明聲明了擁有3個成員的結(jié)構(gòu)體，分別為整型的a，字符型的b和雙精度的c
//結(jié)構(gòu)體的標(biāo)簽被命名為SIMPLE,沒有聲明變量
struct SIMPLE
{
    int a;
    char b;
    double c;
};
//用SIMPLE標(biāo)簽的結(jié)構(gòu)體，另外聲明了變量t1、t2、t3
struct SIMPLE t1, t2[20], *t3;
 
//也可以用typedef創(chuàng)建新類型
typedef struct
{
    int a;
    char b;
    double c; 
} Simple2;
//現(xiàn)在可以用Simple2作為類型聲明新的結(jié)構(gòu)體變量
Simple2 u1, u2[20], *u3;

在上面的聲明中，第一個和第二聲明被編譯器當(dāng)作兩個完全不同的類型，即使他們的成員列表是一樣的，如果令 t3=&s1，則是非法的。

結(jié)構(gòu)體的成員可以包含其他結(jié)構(gòu)體，也可以包含指向自己結(jié)構(gòu)體類型的指針，而通常這種指針的應(yīng)用是為了實現(xiàn)一些更高級的數(shù)據(jù)結(jié)構(gòu)如鏈表和樹等。

//此結(jié)構(gòu)體的聲明包含了其他的結(jié)構(gòu)體
struct COMPLEX
{
    char string[100];
    struct SIMPLE a;
};
 
//此結(jié)構(gòu)體的聲明包含了指向自己類型的指針
struct NODE
{
    char string[100];
    struct NODE *next_node;
};

如果兩個結(jié)構(gòu)體互相包含，則需要對其中一個結(jié)構(gòu)體進行不完整聲明，如下所示：

struct B;    //對結(jié)構(gòu)體B進行不完整聲明
 
//結(jié)構(gòu)體A中包含指向結(jié)構(gòu)體B的指針
struct A
{
    struct B *partner;
    //other members;
};
 
//結(jié)構(gòu)體B中包含指向結(jié)構(gòu)體A的指針，在A聲明完后，B也隨之進行聲明
struct B
{
    struct A *partner;
    //other members;
};

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

和其它類型變量一樣，對結(jié)構(gòu)體變量可以在定義時指定初始值。

//需要注意下 結(jié)構(gòu)體的聲明位置，和Java略有不同
struct Books
{
    char  title[50];
    char  author[50];
    char  subject[100];
    int   book_id;
} book = {"C ", "RUNOOB", "programa laguege", 123456};

void book_init() {
    printf("title : %s\nauthor: %s\nsubject: %s\nbook_id: %d\n", book.title, book.author, book.subject, book.book_id);
}

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

為了訪問結(jié)構(gòu)的成員，我們使用成員訪問運算符（.）。成員訪問運算符是結(jié)構(gòu)變量名稱和我們要訪問的結(jié)構(gòu)成員之間的一個句號。您可以使用 struct 關(guān)鍵字來定義結(jié)構(gòu)類型的變量。下面的實例演示了結(jié)構(gòu)的用法：

void book_set(){
    struct Books Book1;        /* 聲明 Book1，類型為 Books */
    struct Books Book2;        /* 聲明 Book2，類型為 Books */

    /* Book1 詳述 */
    strcpy( Book1.title, "C Programming");
    strcpy( Book1.author, "Nuha Ali");
    strcpy( Book1.subject, "C Programming Tutorial");
    Book1.book_id = 6495407;

    /* Book2 詳述 */
    strcpy( Book2.title, "Telecom Billing");
    strcpy( Book2.author, "Zara Ali");
    strcpy( Book2.subject, "Telecom Billing Tutorial");
    Book2.book_id = 6495700;

    /* 輸出 Book1 信息 */
    printf( "Book 1 title : %s\n", Book1.title);
    printf( "Book 1 author : %s\n", Book1.author);
    printf( "Book 1 subject : %s\n", Book1.subject);
    printf( "Book 1 book_id : %d\n", Book1.book_id);

    /* 輸出 Book2 信息 */
    printf( "Book 2 title : %s\n", Book2.title);
    printf( "Book 2 author : %s\n", Book2.author);
    printf( "Book 2 subject : %s\n", Book2.subject);
    printf( "Book 2 book_id : %d\n", Book2.book_id);
}

Book 1 title : C Programming
Book 1 author : Nuha Ali
Book 1 subject : C Programming Tutorial
Book 1 book_id : 6495407
Book 2 title : Telecom Billing
Book 2 author : Zara Ali
Book 2 subject : Telecom Billing Tutorial
Book 2 book_id : 6495700

Process finished with exit code 0

結(jié)構(gòu)作為函數(shù)參數(shù)

您可以把結(jié)構(gòu)作為函數(shù)參數(shù)，傳參方式與其他類型的變量或指針類似。您可以使用上面實例中的方式來訪問結(jié)構(gòu)變量：

void print_book( struct Books book )
{
    printf( "Book title : %s\n", book.title);
    printf( "Book author : %s\n", book.author);
    printf( "Book subject : %s\n", book.subject);
    printf( "Book book_id : %d\n", book.book_id);
}

將上方代碼做修改。

void book_set(){
    struct Books Book1;        /* 聲明 Book1，類型為 Books */
    struct Books Book2;        /* 聲明 Book2，類型為 Books */

    /* Book1 詳述 */
    strcpy( Book1.title, "C Programming");
    strcpy( Book1.author, "Nuha Ali");
    strcpy( Book1.subject, "C Programming Tutorial");
    Book1.book_id = 6495407;

    /* Book2 詳述 */
    strcpy( Book2.title, "Telecom Billing");
    strcpy( Book2.author, "Zara Ali");
    strcpy( Book2.subject, "Telecom Billing Tutorial");
    Book2.book_id = 6495700;

    /* 輸出 Book1 信息 */
    print_book(Book1);

    /* 輸出 Book2 信息 */
    print_book(Book2);
}

Book title : C Programming
Book author : Nuha Ali
Book subject : C Programming Tutorial
Book book_id : 6495407
Book title : Telecom Billing
Book author : Zara Ali
Book subject : Telecom Billing Tutorial
Book book_id : 6495700

Process finished with exit code 0

指向結(jié)構(gòu)的指針

您可以定義指向結(jié)構(gòu)的指針，方式與定義指向其他類型變量的指針相似，如下所示：

struct Books *struct_pointer;

現(xiàn)在，您可以在上述定義的指針變量中存儲結(jié)構(gòu)變量的地址。為了查找結(jié)構(gòu)變量的地址，請把 & 運算符放在結(jié)構(gòu)名稱的前面，如下所示：

struct_pointer = &Book1;

為了使用指向該結(jié)構(gòu)的指針訪問結(jié)構(gòu)的成員，您必須使用 -> 運算符，如下所示：

struct_pointer->title;

讓我們使用結(jié)構(gòu)指針來重寫上面的實例，這將有助于您理解結(jié)構(gòu)指針的概念：

我們來再次修改上述代碼：

void print_books(struct Books *book) {
    printf("Book title : %s\n", book->title);
    printf("Book author : %s\n", book->author);
    printf("Book subject : %s\n", book->subject);
    printf("Book book_id : %d\n", book->book_id);
}

在C語言中，為了使用方便和使之直觀，可以把 (*p).num 改用 p->num 來代替，它表示 p 所指向的結(jié)構(gòu)體變量中的 num 成員，同樣，(p).name 等價于 p->name。

也就是說以下三種形式等價：

a. 結(jié)構(gòu)體變量.成員名
b. (*p).成員名
c. p-> 成員名

位域

有些信息在存儲時，并不需要占用一個完整的字節(jié)，而只需占幾個或一個二進制位。例如在存放一個開關(guān)量時，只有 0 和 1 兩種狀態(tài)，用 1 位二進位即可。為了節(jié)省存儲空間，并使處理簡便，C 語言又提供了一種數(shù)據(jù)結(jié)構(gòu)，稱為"位域"或"位段"。

所謂"位域"是把一個字節(jié)中的二進位劃分為幾個不同的區(qū)域，并說明每個區(qū)域的位數(shù)。每個域有一個域名，允許在程序中按域名進行操作。這樣就可以把幾個不同的對象用一個字節(jié)的二進制位域來表示。

典型的實例：

• 用 1 位二進位存放一個開關(guān)量時，只有 0 和 1 兩種狀態(tài)。
• 讀取外部文件格式——可以讀取非標(biāo)準(zhǔn)的文件格式。例如：9 位的整數(shù)。

位域的定義和位域變量的說明

位域定義與結(jié)構(gòu)定義相仿，其形式為：

struct 位域結(jié)構(gòu)名 
{

 位域列表

};

其中位域列表的形式為：

類型說明符 位域名: 位域長度 

例如：

struct bs{
    int a:8;
    int b:2;
    int c:6;
}data;

說明 data 為 bs 變量，共占兩個字節(jié)。其中位域 a 占 8 位，位域 b 占 2 位，位域 c 占 6 位。

讓我們再來看一個實例：

struct packed_struct {
  unsigned int f1:1;
  unsigned int f2:1;
  unsigned int f3:1;
  unsigned int f4:1;
  unsigned int type:4;
  unsigned int my_int:9;
} pack;

在這里，packed_struct 包含了 6 個成員：四個 1 位的標(biāo)識符 f1..f4、一個 4 位的 type 和一個 9 位的 my_int。

對于位域的定義尚有以下幾點說明：

• 一個位域存儲在同一個字節(jié)中，如一個字節(jié)所剩空間不夠存放另一位域時，則會從下一單元起存放該位域。也可以有意使某位域從下一單元開始。例如：

  
  struct bs{
      unsigned a:4;
      unsigned  :4;    /* 空域 */
      unsigned b:4;    /* 從下一單元開始存放 */
      unsigned c:4
  }
  
  

  在這個位域定義中，a 占第一字節(jié)的 4 位，后 4 位填 0 表示不使用，b 從第二字節(jié)開始，占用 4 位，c 占用 4 位。

• 由于位域不允許跨兩個字節(jié)，因此位域的長度不能大于一個字節(jié)的長度，也就是說不能超過8位二進位。如果最大長度大于計算機的整數(shù)字長，一些編譯器可能會允許域的內(nèi)存重疊，另外一些編譯器可能會把大于一個域的部分存儲在下一個字中。

• 位域可以是無名位域，這時它只用來作填充或調(diào)整位置。無名的位域是不能使用的。例如：

  
  struct k{
      int a:1;
      int  :2;    /* 該 2 位不能使用 */
      int b:3;
      int c:2;
  };
  
  

  從以上分析可以看出，位域在本質(zhì)上就是一種結(jié)構(gòu)類型，不過其成員是按二進位分配的。

  位域的使用

  位域的使用和結(jié)構(gòu)成員的使用相同，其一般形式為：

  位域變量名.位域名
  位域變量名->位域名
  

位域允許用各種格式輸出。

請看下面的實例：

void test_bit_field(){
    struct bs{
        unsigned a:1;
        unsigned b:3;
        unsigned c:4;
    } bit,*pbit;
    bit.a=1;    /* 給位域賦值（應(yīng)注意賦值不能超過該位域的允許范圍） */
    bit.b=7;    /* 給位域賦值（應(yīng)注意賦值不能超過該位域的允許范圍） */
    bit.c=15;    /* 給位域賦值（應(yīng)注意賦值不能超過該位域的允許范圍） */
    printf("%d,%d,%d\n",bit.a,bit.b,bit.c);    /* 以整型量格式輸出三個域的內(nèi)容 */
    pbit=&bit;    /* 把位域變量 bit 的地址送給指針變量 pbit */
    pbit->a=0;    /* 用指針方式給位域 a 重新賦值，賦為 0 */
    pbit->b&=3;    /* 使用了復(fù)合的位運算符 "&="，相當(dāng)于：pbit->b=pbit->b&3，位域 b 中原有值為 7，與 3 作按位與運算的結(jié)果為 3（111&011=011，十進制值為 3） */
    pbit->c|=1;    /* 使用了復(fù)合位運算符"|="，相當(dāng)于：pbit->c=pbit->c|1，其結(jié)果為 15 */
    printf("%d,%d,%d\n",pbit->a,pbit->b,pbit->c);    /* 用指針方式輸出了這三個域的值 */
}

上例程序中定義了位域結(jié)構(gòu) bs，三個位域為 a、b、c。說明了 bs 類型的變量 bit 和指向 bs 類型的指針變量 pbit。這表示位域也是可以使用指針的。

結(jié)構(gòu)體中成員變量分配的空間是按照成員變量中占用空間最大的來作為分配單位,同樣成員變量的存儲空間也是不能跨分配單位的,如果當(dāng)前的空間不足,則會存儲到下一個分配單位中。

#include <stdio.h>

typedef struct
{
    unsigned char a;
    unsigned int  b;
    unsigned char c;
} debug_size1_t;
typedef struct
{
    unsigned char a;
    unsigned char b;
    unsigned int  c;
} debug_size2_t;

int main(void)
{
    printf("debug_size1_t size=%lu,debug_size2_t size=%lu\r\n", sizeof(debug_size1_t), sizeof(debug_size2_t));
    return 0;
}

編譯執(zhí)行輸出結(jié)果：

debug_size1_t size=12,debug_size2_t size=8

結(jié)構(gòu)體占用存儲空間,以32位機為例

• 1.debug_size1_t 存儲空間分布為a(1byte)+空閑(3byte)+b(4byte)+c(1byte)+空閑(3byte)=12(byte)。

• 1.debug_size2_t 存儲空間分布為a(1byte)+b(1byte)+空閑(2byte)+c(4byte)=8(byte)。

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

一個結(jié)構(gòu)體變量中可以存放一組數(shù)據(jù)（如一個學(xué)生的學(xué)號，姓名，成績等數(shù)據(jù)）。如果有10個學(xué)生的數(shù)據(jù)需要參加運算，顯然應(yīng)該用數(shù)組，這就是結(jié)構(gòu)體數(shù)組。結(jié)構(gòu)體數(shù)組與以前介紹過的數(shù)據(jù)值型數(shù)組不同之處在于每個數(shù)組元素都一個結(jié)構(gòu)體類型的數(shù)據(jù)，它們分別包括各個成員（分量）項。

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

和定義結(jié)構(gòu)體變量的方法相仿，只需說明其為數(shù)組即可。

struct student
{
    int num;
    char name[20];
    char sex;
    int age;
    float score;
    char addr[30];
};
struct student stu[3];

以上定義了一個數(shù)組 stu，其元素為 struct student 類型數(shù)據(jù)，數(shù)組有 3 個元素。也可以直接定義一個結(jié)構(gòu)體數(shù)組。如：

struct student
{
    int num;
    ....

}stu[3];

或

struct

{
    int num;
    　...
}stu[3];

結(jié)構(gòu)體數(shù)組的初始化

與其它類型數(shù)組一樣，對結(jié)構(gòu)體數(shù)組可以初始化如：

struct student
{
    int mum;
    char name[20];
    char sex;
    int age;
    float score;
    char addr[30];
}stu[3] = {{10101,"Li Lin", 'M', 18, 87.5, "103 Beijing Road"},
            {10101,"Li Lin", 'M', 18, 87.5, "103 Beijing Road"},
            {10101,"Li Lin", 'M', 18, 87.5, "103 Beijing Road"}};

定義數(shù)組 stu 時，元素個數(shù)可以不指定，即寫成以下形式：

stu[] = {{...},{...},{...}};

編譯時，系統(tǒng)會根據(jù)給出初值的結(jié)構(gòu)體常量的個數(shù)來確定數(shù)組元素的個數(shù)。

當(dāng)然，數(shù)組的初始化也可以用以下形式：

struct student
{
    int num;
    ...
};
struct student stu[] = {{...},{...},{...}};

即先聲明結(jié)構(gòu)體類型，然后定義數(shù)組為該結(jié)構(gòu)體類型，在定義數(shù)組時初始化。

從以上可以看到，結(jié)構(gòu)體數(shù)組初始化的一般形式是在定義數(shù)組的后面加上：

結(jié)構(gòu)體數(shù)組應(yīng)用舉例

下面例子說明結(jié)構(gòu)體數(shù)組的定義和引用。

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

struct person
{
    char name[20];
    int count;

}leader[3] = {{"Li", 0},
            　{"Zhang", 0},
            　{"Fun", 0}};

void main()
{
    int i, j;
    char leader_name[20];
    for(i = 1; i<= 10;i++)
    {
        scanf("%s", leader_name);
        for(j=0;j<3;j++)
            if(strcmp(leader_name, leader[j].name) == 0)
                leader[j].count ++;
    }
    printf("\n");
    for(i=0;i<3;i++)
        printf("%5s: %d\n", leader[i].name, leader[i].count);
    system("pause");
}

代碼已上傳github，點擊此處即可到達