C語言筆記 08_函數指針&回調函數&字符串&結構體&位域

時間  2019-12-22
標籤 c語言 筆記 函數 指針 字符串 結構 简体版
原文   原文鏈接

函數指針

函數指針是指向函數的指針變量。html

一般咱們說的指針變量是指向一個整型、字符型或數組等變量，而函數指針是指向函數。node

函數指針能夠像通常函數同樣，用於調用函數、傳遞參數。編程

函數指針變量的聲明：數組

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

如下實例聲明瞭函數指針變量 p，指向函數 max：數據結構

#include <stdio.h>
 
int max(int x, int y)
{
    return x > y ? x : y;
}
 
int main(void)
{
    /* p 是函數指針 */
    int (* p)(int, int) = & max; // &能夠省略
    int a, b, c, d;
 
    printf("請輸入三個數字:");
    scanf("%d %d %d", & a, & b, & c);
 
    /* 與直接調用函數等價，d = max(max(a, b), c) */
    d = p(p(a, b), c); 
 
    printf("最大的數字是: %d\n", d);
 
    return 0;
}

編譯執行，輸出結果以下：dom

請輸入三個數字:1 2 3
最大的數字是: 3編程語言

回調函數

函數指針做爲某個函數的參數

函數指針變量能夠做爲某個函數的參數來使用的，回調函數就是一個經過函數指針調用的函數。函數

簡單講：回調函數是由別人的函數執行時調用你實現的函數。指針

如下是來自知乎做者常溪玲的解說：code

你到一個商店買東西，恰好你要的東西沒有貨，因而你在店員那裏留下了你的電話，過了幾天店裏有貨了，店員就打了你的電話，而後你接到電話後就到店裏去取了貨。在這個例子裏，你的電話號碼就叫回調函數，你把電話留給店員就叫登記回調函數，店裏後來有貨了叫作觸發了回調關聯的事件，店員給你打電話叫作調用回調函數，你到店裏去取貨叫作響應回調事件。

實例

實例中 populate_array 函數定義了三個參數，其中第三個參數是函數的指針，經過該函數來設置數組的值。

實例中咱們定義了回調函數 getNextRandomValue，它返回一個隨機值，它做爲一個函數指針傳遞給 populate_array 函數。

populate_array 將調用 10 次回調函數，並將回調函數的返回值賦值給數組。

注意：size_t 是一種數據類型，近似於無符號整型，但容量範圍通常大於 int 和 unsigned。這裏使用 size_t 是爲了保證 arraysize 變量可以有足夠大的容量來儲存可能大的數組個數值。

#include <stdlib.h>  
#include <stdio.h>
 
// 回調函數
void populate_array(int *array, size_t arraySize, int (*getNextValue)(void))
{
    for (size_t i=0; i<arraySize; i++)
        array[i] = getNextValue();
}
 
// 獲取隨機值
int getNextRandomValue(void)
{
    return rand();
}
 
int main(void)
{
    int myarray[10];
    populate_array(myarray, 10, getNextRandomValue);
    for(int i = 0; i < 10; i++) {
        printf("%d ", myarray[i]);
    }
    printf("\n");
    return 0;
}

編譯執行，輸出結果以下：

16807 282475249 1622650073 984943658 1144108930 470211272 101027544 1457850878 1458777923 2007237709

字符串

在 C 語言中，字符串其實是使用 null 字符 '\0' 終止的一維字符數組。所以，一個以 null 結尾的字符串，包含了組成字符串的字符。

下面的聲明和初始化建立了一個 "Hello" 字符串。因爲在數組的末尾存儲了空字符，因此字符數組的大小比單詞 "Hello" 的字符數多一個。

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

依據數組初始化規則，您能夠把上面的語句寫成如下語句：

char greeting[] = "Hello";

如下是 C/C++ 中定義的字符串的內存表示：

img

其實，不須要把 null 字符放在字符串常量的末尾。C 編譯器會在初始化數組時，自動把 '\0' 放在字符串的末尾。讓咱們嘗試輸出上面的字符串：

#include <stdio.h>
 
int main ()
{
   char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
 
   printf("Greeting message: %s\n", greeting );
 
   return 0;
}

當上面的代碼被編譯和執行時，它會產生下列結果：

Greeting message: Hello

操做字符串的函數

序號 函數 & 目的
1 strcpy(s1, s2); 複製字符串 s2 到字符串 s1。
2 strcat(s1, s2); 鏈接字符串 s2 到字符串 s1 的末尾。
3 strlen(s1); 返回字符串 s1 的長度。
4 strcmp(s1, s2); 若是 s1 和 s2 是相同的，則返回 0；若是 s1<s2 則返回小於 0；若是 s1>s2 則返回大於 0。
5 strchr(s1, ch); 返回一個指針，指向字符串 s1 中字符 ch 的第一次出現的位置。
6 strstr(s1, s2); 返回一個指針，指向字符串 s1 中字符串 s2 的第一次出現的位置。

下面的實例使用了上述的一些函數：

#include <stdio.h>
#include <string.h>
 
int main ()
{
   char str1[12] = "Hello";
   char str2[12] = "World";
   char str3[12];
   int  len ;
 
   /* 複製 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 );
 
   return 0;
}

當上面的代碼被編譯和執行時，它會產生下列結果：

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

C 標準庫中還有更多字符串相關的函數。

結構體

結構是 C 編程中一種用戶自定義的可用的數據類型，它容許您存儲不一樣類型的數據項。結構用於表示一條記錄。

定義結構

爲了定義結構，您必須使用 struct 語句。struct 語句定義了一個包含多個成員的新的數據類型，struct 語句的格式以下：

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

tag 是結構體標籤。

member-list 是標準的變量定義，好比 int i; 或者 float f，或者其餘有效的變量定義。

variable-list 結構變量，定義在結構的末尾，最後一個分號以前，您能夠指定一個或多個結構變量。下面是聲明 Book 結構的方式：

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

在通常狀況下，tag、member-list、variable-list 這 3 部分至少要出現 2 個。如下爲實例：

//此聲明聲明瞭擁有3個成員的結構體，分別爲整型的a，字符型的b和雙精度的c
//同時又聲明告終構體變量s1
//這個結構體並無標明其標籤
struct 
{
    int a;
    char b;
    double c;
} s1;
 
//此聲明聲明瞭擁有3個成員的結構體，分別爲整型的a，字符型的b和雙精度的c
//結構體的標籤被命名爲SIMPLE,沒有聲明變量
struct SIMPLE
{
    int a;
    char b;
    double c;
};
//用SIMPLE標籤的結構體，另外聲明瞭變量t一、t二、t3
struct SIMPLE t1, t2[20], *t3;
 
//也能夠用typedef建立新類型
typedef struct
{
    int a;
    char b;
    double c; 
} Simple2;
//如今能夠用Simple2做爲類型聲明新的結構體變量
Simple2 u1, u2[20], *u3;

在上面的聲明中，第一個和第二聲明被編譯器看成兩個徹底不一樣的類型，即便他們的成員列表是同樣的。

結構體的成員能夠包含其餘結構體，也能夠包含指向本身結構體類型的指針，而一般這種指針的應用是爲了實現一些更高級的數據結構如鏈表和樹等。

//此結構體的聲明包含了其餘的結構體
struct COMPLEX
{
    char string[100];
    struct SIMPLE a;
};
 
//此結構體的聲明包含了指向本身類型的指針
struct NODE
{
    char string[100];
    struct NODE *next_node;
};

若是兩個結構體互相包含，則須要對其中一個結構體進行不完整聲明，以下所示：

struct B;    //對結構體B進行不完整聲明
 
//結構體A中包含指向結構體B的指針
struct A
{
    struct B *partner;
    //other members;
};
 
//結構體B中包含指向結構體A的指針，在A聲明完後，B也隨之進行聲明
struct B
{
    struct A *partner;
    //other members;
};

結構體變量的初始化

和其它類型變量同樣，對結構體變量能夠在定義時指定初始值。

#include <stdio.h>
 
struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
} book = {"C 語言", "RUNOOB", "編程語言", 123456};
 
int main()
{
    printf("title : %s\nauthor: %s\nsubject: %s\nbook_id: %d\n", book.title, book.author, book.subject, book.book_id);
}

執行輸出結果爲：

title : C 語言
author: RUNOOB
subject: 編程語言
book_id: 123456

訪問結構成員

爲了訪問結構的成員，咱們使用成員訪問運算符（.）。成員訪問運算符是結構變量名稱和咱們要訪問的結構成員之間的一個句號。您可使用 struct 關鍵字來定義結構類型的變量。下面的實例演示告終構的用法：

#include <stdio.h>
#include <string.h>
 
struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
};
 
int main( )
{
   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);
 
   return 0;
}

當上面的代碼被編譯和執行時，它會產生下列結果：

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

結構做爲函數參數

您能夠把結構做爲函數參數，傳參方式與其餘類型的變量或指針相似。

#include <stdio.h>
#include <string.h>
 
struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
};
 
/* 函數聲明 */
void printBook( struct Books book );
int main( )
{
   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 信息 */
   printBook( Book1 );
 
   /* 輸出 Book2 信息 */
   printBook( Book2 );
 
   return 0;
}
void printBook( 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);
}

當上面的代碼被編譯和執行時，它會產生下列結果：

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

指向結構的指針

您能夠定義指向結構的指針，方式與定義指向其餘類型變量的指針類似，以下所示：

struct Books *struct_pointer;

如今，您能夠在上述定義的指針變量中存儲結構變量的地址。爲了查找結構變量的地址，請把 & 運算符放在結構名稱的前面，以下所示：

struct_pointer = &Book1;

爲了使用指向該結構的指針訪問結構的成員，您必須使用 -> 運算符，以下所示：

struct_pointer->title;

讓咱們使用結構指針來重寫上面的實例，這將有助於理解結構指針的概念：

#include <stdio.h>
#include <string.h>
 
struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
};
 
/* 函數聲明 */
void printBook( struct Books *book );
int main( )
{
   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 的地址來輸出 Book1 信息 */
   printBook( &Book1 );
 
   /* 經過傳 Book2 的地址來輸出 Book2 信息 */
   printBook( &Book2 );
 
   return 0;
}
void printBook( 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);
}

當上面的代碼被編譯和執行時，它會產生下列結果：

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

位域

有些信息在存儲時，並不須要佔用一個完整的字節，而只需佔幾個或一個二進制位。例如在存放一個開關量時，只有 0 和 1 兩種狀態，用 1 位二進位便可。爲了節省存儲空間，並使處理簡便，C 語言又提供了一種數據結構，稱爲"位域"或"位段"。

所謂"位域"是把一個字節中的二進位劃分爲幾個不一樣的區域，並說明每一個區域的位數。每一個域有一個域名，容許在程序中按域名進行操做。這樣就能夠把幾個不一樣的對象用一個字節的二進制位域來表示。

典型的實例：

  • 用 1 位二進位存放一個開關量時，只有 0 和 1 兩種狀態。
  • 讀取外部文件格式——能夠讀取非標準的文件格式。例如：9 位的整數。

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

位域定義與結構定義相仿，其形式爲：

struct 位域結構名 
{

 位域列表

};

其中位域列表的形式爲：

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

例如：

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

說明 data 爲 bs 變量，共佔兩個字節。其中位域 a 佔 8 位，位域 b 佔 2 位，位域 c 佔 6 位。

1字節=1B=8個二進制位

讓咱們再來看一個實例：

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 位的標識符 f1..f四、一個 4 位的 type 和一個 9 位的 my_int。

對於位域的定義尚有如下幾點說明：

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

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

    在這個位域定義中，a 佔第一字節的 4 位，後 4 位填 0 表示不使用，b 從第二字節開始，佔用 4 位，c 佔用 4 位。

  • 因爲位域不容許跨兩個字節，所以位域的長度不能大於一個字節的長度，也就是說不能超過8位二進位。若是最大長度大於計算機的整數字長，一些編譯器可能會容許域的內存重疊，另一些編譯器可能會把大於一個域的部分存儲在下一個字中。

  • 位域能夠是無名位域，這時它只用來做填充或調整位置。無名的位域是不能使用的。例如：

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

從以上分析能夠看出，位域在本質上就是一種結構類型，不過其成員是按二進位分配的。

實例

若是程序的結構中包含多個開關量，只有 TRUE/FALSE 變量，以下：

struct
{
  unsigned int widthValidated;
  unsigned int heightValidated;
} status;

這種結構須要 8 字節的內存空間，但在實際上，在每一個變量中，咱們只存儲 0 或 1。上面的結構能夠重寫成：

struct
{
  unsigned int widthValidated : 1;
  unsigned int heightValidated : 1;
} status;

如今，上面的結構中，status 變量將佔用 4 個字節的內存空間，可是隻有 2 位被用來存儲值。若是您用了 32 個變量，每個變量寬度爲 1 位，那麼 status 結構將使用 4 個字節，但只要您再多用一個變量，若是使用了 33 個變量，那麼它將分配內存的下一段來存儲第 33 個變量，這個時候就開始使用 8 個字節。讓咱們看看下面的實例來理解這個概念：

#include <stdio.h>
#include <string.h>
 
/* 定義簡單的結構 */
struct
{
  unsigned int widthValidated;
  unsigned int heightValidated;
} status1;
 
/* 定義位域結構 */
struct
{
  unsigned int widthValidated : 1;
  unsigned int heightValidated : 1;
} status2;
 
int main( )
{
   printf( "Memory size occupied by status1 : %d\n", sizeof(status1));
   printf( "Memory size occupied by status2 : %d\n", sizeof(status2));
 
   return 0;
}

當上面的代碼被編譯和執行時，它會產生下列結果：

Memory size occupied by status1 : 8
Memory size occupied by status2 : 4

位域聲明

在結構內聲明位域的形式以下：

struct
{
  type [member_name] : width ;
};

下面是有關位域中變量元素的描述：

元素 描述
type 只能爲 int(整型)，unsigned int(無符號整型)，signed int(有符號整型) 三種類型，決定了如何解釋位域的值。
member_name 位域的名稱。
width 位域中位的數量。寬度必須小於或等於指定類型的位寬度。

帶有預約義寬度的變量被稱爲位域。位域能夠存儲多於 1 位的數，例如，須要一個變量來存儲從 0 到 7 的值，您能夠定義一個寬度爲 3 位（2進制位）的位域，以下：

struct
{
  unsigned int age : 3;
} Age;

上面的結構定義指示 C 編譯器，age 變量將只使用 3 位來存儲這個值，若是您試圖使用超過 3 位，則沒法完成。讓咱們來看下面的實例：

#include <stdio.h>
#include <string.h>
 
struct
{
  unsigned int age : 3;
} Age;
 
int main( )
{
   Age.age = 4;
   printf( "Sizeof( Age ) : %d\n", sizeof(Age) );
   printf( "Age.age : %d\n", Age.age );
 
   Age.age = 7;
   printf( "Age.age : %d\n", Age.age );
 
   Age.age = 8; // 二進制表示爲 1000 有四位，超出
   printf( "Age.age : %d\n", Age.age );
 
   return 0;
}

當上面的代碼被編譯時，它會帶有警告，當上面的代碼被執行時，它會產生下列結果：

Sizeof( Age ) : 4
Age.age : 4
Age.age : 7
Age.age : 0

位域的使用

位域的使用和結構成員的使用相同，其通常形式爲：

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

位域容許用各類格式輸出。

請看下面的實例：

#include <stdio.h>
int main(){
    struct bs{
        unsigned a:1;
        unsigned b:3;
        unsigned c:4;
    } bit,*pbit;
    bit.a=1;    /* 給位域賦值（應注意賦值不能超過該位域的容許範圍） */
    bit.b=7;    /* 給位域賦值（應注意賦值不能超過該位域的容許範圍） */
    bit.c=15;    /* 給位域賦值（應注意賦值不能超過該位域的容許範圍） */
    printf("%d,%d,%d\n",bit.a,bit.b,bit.c);    /* 以整型量格式輸出三個域的內容 */
    pbit=&bit;    /* 把位域變量 bit 的地址送給指針變量 pbit */
    pbit->a=0;    /* 用指針方式給位域 a 從新賦值，賦爲 0 */
    pbit->b&=3;    /* 使用了複合的位運算符 "&="，至關於：pbit->b=pbit->b&3，位域 b 中原有值爲 7，與 3 做按位與運算的結果爲 3（111&011=011，十進制值爲 3） */
    pbit->c|=1;    /* 使用了複合位運算符"|="，至關於：pbit->c=pbit->c|1，其結果爲 15 */
    printf("%d,%d,%d\n",pbit->a,pbit->b,pbit->c);    /* 用指針方式輸出了這三個域的值 */
  return 0;
}

獲得如下結果

1,7,15
0,3,15

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

參考自：https://www.runoob.com/cprogramming/c-tutorial.html

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程