版權聲明：本文爲博主原創文章，未經博主允許不得轉載。 https://blog.csdn.net/JourneyX/article/details/78287559
一、C語言
【
1、C標準庫
{
（C 語言是一種通用的、面向過程式的計算機程序設計語言。1972 年，爲了移植與開發 UNIX 操作系統，丹尼斯·裏奇在貝爾電話實驗室設計開發了 C 語言。）
#include <stdio.h>
---<assert.h>：提供了一個名爲 assert 的宏，它可用於驗證程序做出的假設，並在假設爲假時輸出診斷消息。
---<ctype.h>：提供了一些函數，可用於測試和映射字符。
---<errno.h>：定義了整數變量 errno，它是通過系統調用設置的，在錯誤事件中的某些庫函數表明了什麼發生了錯誤。
---<float.h>：文件包含了一組與浮點值相關的依賴於平臺的常量。
---<limits.h>：文件決定了各種變量類型的各種屬性。定義在該頭文件中的宏限制了各種變量類型（比如 char、int 和 long）的值。
---文件定義了特定地域的設置，比如日期格式和貨幣符號。接下來我們將介紹一些宏，以及一個重要的結構 struct lconv 和兩個重要的函數。
---<math.h>：文件定義了各種數學函數和一個宏。在這個庫中所有可用的功能都帶有一個 double 類型的參數，且都返回 double 類型的結果。
---<setjmp.h>：文件定義了宏 setjmp()、函數 longjmp() 和變量類型 jmp_buf，該變量類型會繞過正常的函數調用和返回規則。
---<signal.h>：文件定義了一個變量類型 sig_atomic_t、兩個函數調用和一些宏來處理程序執行期間報告的不同信號。
---<stdarg.h>：文件定義了一個變量類型 va_list 和三個宏，這三個宏可用於在參數個數未知（即參數個數可變）時獲取函數中的參數。
---<stddef.h>：文件定義了各種變量類型和宏。這些定義中的大部分也出現在其它頭文件中。
---<stdio.h>：文件定義了三個變量類型、一些宏和各種函數來執行輸入和輸出。
---<stdlib.h>：文件定義了四個變量類型、一些宏和各種通用工具函數。
---<string.h>：文件定義了一個變量類型、一個宏和各種操作字符數組的函數。
---<time.h>：文件定義了四個變量類型、兩個宏和各種操作日期和時間的函數。
}
2、基礎理論知識
{
---程序結構：預處理器指令、函數、變量、語句&表達式、註釋。 return 0; ---退出main()函數。
---關鍵字：auto else long switch break enum register typedef case extern return union char float short unsigned
const for signed void continue goto sizeof volatile default if static while do int struct _Packed
double
---數據類型：
@1：基本類型<char、unsigned char、signed char、int、unsigned int、short、unsigned short、long、unsigned long>
@2：枚舉類型<float、double、long double>
@3：Void類型<函數返回爲空、函數參數爲空、指針指向 void>
@4：派生類型<指針類型、數組類型、結構類型、共用體類型和函數類型>
---變量：變量的定義-type variable_list; 變量的聲明<extern>-extern int i; //變量的聲明 int i；//變量的定義 --除非有extern關鍵字，否則都是變量的定義。
---常量：字符常量<\\--\ \'--' \"--" \?--? \a--警報鈴聲 \b--退格鍵 \f--換頁符 \n--換行符 \r--回車 \t--水平製表符
\v--垂直製表符 \ooo--一到三位的八進制數 \xhh--一個或多個數字的十六進制數>
定義常量：@1：使用 #define 預處理器<#define identifier value --#define LENGTH 10 >
@2：使用 const 關鍵字<const type variable = value;--const int LENGTH = 10;>。
---存儲類：存儲類定義 C 程序中變量/函數的範圍（可見性）和生命週期。這些說明符放置在它們所修飾的類型之前。<auto、register、static、extern>
@1auto：是所有局部變量默認的存儲類。auto 只能用在函數內，即 auto 只能修飾局部變量。
@2register：用於定義存儲在寄存器中而不是 RAM 中的局部變量。這意味着變量的最大尺寸等於寄存器的大小（通常是一個詞），且不能對它應用一元的 '&' 運算符（因爲它沒有內存位置）。寄存器只用於需要快速訪問的變量，比如計數器。還應注意的是，定義 'register' 並不意味着變量將被存儲在寄存器中，它意味着變量可能存儲在寄存器中，這取決於硬件和實現的限制。
@3static：指示編譯器在程序的生命週期內保持局部變量的存在，而不需要在每次它進入和離開作用域時進行創建和銷燬。因此，使用 static 修飾局部變量可以在函數調用之間保持局部變量的值。 static 修飾符也可以應用於全局變量。當 static 修飾全局變量時，會使變量的作用域限制在聲明它的文件內。 static 是全局變量的默認存儲類，以下兩個變量
(count 和 road) 都有一個 static 存儲類。
@4extern：extern 存儲類用於提供一個全局變量的引用，全局變量對所有的程序文件都是可見的。extern 修飾符通常用於當有兩個或多個文件共享相同的全局變量或函數的時候。
(auto 是局部變量的默認存儲類, 限定變量只能在函數內部使用；
register 代表了寄存器變量，不在內存中使用；
static是全局變量的默認存儲類,表示變量在程序生命週期內可見；
extern 表示全局變量，即對程序內所有文件可見，類似於Java中的public關鍵字；)
---運算符：(算術運算符、關係運算符、邏輯運算符、位運算符、賦值運算符、雜項運算符){
@1：邏輯運算符--&&、||、！
@2：位運算符--&(與)、|<或>、^<異或>、>>、<<
@3：雜項運算符--sizeof()<返回變量的大小>、&<返回變量的地址>、*<指向一個變量>、?:<條件表達式>
}
--循環：while 循環、for 循環、do...while 循環、嵌套循環{
@1:循環控制語句：break 語句、continue 語句、goto 語句
@2：無限循環---for( ; ; )
}
--函數：返回類型、函數名稱、參數、函數主體
--作用域規則：{ 局部變量、全局變量和形式參數
@1：局部變量的值會覆蓋全局變量的值。
@2：當局部變量被定義時，系統不會對其初始化，您必須自行對其初始化。定義全局變量時，系統會自動對其初始化。
}
--數組：存儲一個固定大小的相同類型元素的順序集合。
--指針{--指針是一個變量，其值爲另一個變量的地址，即，內存位置的直接地址。就像其他變量或常量一樣，您必須在使用指針存儲其他變量地址之前，對其進行聲明。
每一個變量都有一個內存位置，每一個內存位置都定義了可使用連字號（&）運算符訪問的地址。
@1使用指針： int *ip; /* 指針變量的聲明 */ ip = &var; /* 在指針變量中存儲 var 的地址 */
printf("Address stored in ip variable: %p\n", ip ); /* 在指針變量中存儲的地址 */
printf("Value of *ip variable: %d\n", *ip ); /* 使用指針訪問值 */
@2空指針：賦爲 NULL 值的指針被稱爲空指針。NULL 指針是一個定義在標準庫中的值爲零的常量。程序不允許訪問地址爲 0 的內存，因爲該內存是操作系統保留的。所以大多情況下要做非空判斷。
}
--函數指針和回調函數{
@1：函數指針--是指向函數的指針變量。可以像一般函數一樣，用於調用函數、傳遞參數。 聲明：typedef int (*fun_ptr)(int,int); // 聲明一個指向同樣參數、返回值的函數指針類型
實例： /* p 是函數指針 */ int (* p)(int, int) = & max; // &可以省略
/* 與直接調用函數等價，d = max(max(a, b), c) */ d = p(p(a, b), c);
@2：回調函數--函數指針作爲某個函數的參數，函數指針變量可以作爲某個函數的參數來使用的，回調函數就是一個通過函數指針調用的函數。 簡單講：回調函數是由別人的函數執行時調用你實現的函數。
// 回調函數： void populate_array(int *array, size_t arraySize, int (*getNextValue)(void)) { }
}
--字符串{
@1：在 C 語言中，字符串實際上是使用 null 字符 '\0' 終止的一維字符數組。因此，一個以 null 結尾的字符串，包含了組成字符串的字符。 字符串操作函數。。。
}
--結構體{
@1定義：C 數組允許定義可存儲相同類型數據項的變量，結構是 C 編程中另一種用戶自定義的可用的數據類型，它允許您存儲不同類型的數據項。 struct 語句定義了一個包含多個成員的新的數據類型。
@2訪問結構成員：使用成員訪問運算符（.）。
struct Books{ char title[50]; char author[50]; char subject[100]; int book_id; };
struct Books Book1; /* 聲明 Book1，類型爲 Books */
/* Book1 詳述 */ strcpy( Book1.title, "C Programming"); Book1.book_id = 6495407;
/* 輸出 Book1 信息 */ printf( "Book 1 title : %s\n", Book1.title);
@3結構作爲函數參數： /* 函數聲明 */ void printBook( struct Books book ); printBook( Book1 );
@4指向結構的指針： 定義指向結構的指針，方式與定義指向其他類型變量的指針相似--struct Books *struct_pointer;
指針變量中存儲結構變量的地址：struct_pointer = &Book1;
使用指向該結構的指針訪問結構的成員，您必須使用 -> 運算符：struct_pointer->title;
實例： /* 函數聲明 */ void printBook( struct Books *book );
struct Books Book1; /* 聲明 Book1，類型爲 Books */
/* 通過傳 Book1 的地址來輸出 Book1 信息 */ printBook( &Book1 );
@5：位域
}
--共用體{
@1說明：共用體是一種特殊的數據類型，允許您在相同的內存位置存儲不同的數據類型。您可以定義一個帶有多成員的共用體，但是任何時候只能有一個成員帶有值。共用體提供了一種使用相同的內存位置的有效方式。
@2定義：使用 union 語句，方式與定義結構類似。union 語句定義了一個新的數據類型，帶有多個成員。
union Data{ int i; float f; char str[20]; } data;
@3訪問共用體成員： union Data data; data.i = 10; strcpy( data.str, "C Programming"); printf( "data.i : %d\n", data.i);
}
--位域{ 如果程序的結構中包含多個開關量，只有 TRUE/FALSE 變量。
@1定義位域：/* 定義位域結構 */ struct{ unsigned int widthValidated : 1; unsigned int heightValidated : 1; } status2;
@2位域聲明：struct{ type [member_name] : width ;}; 帶有預定義寬度的變量被稱爲位域。
}
--typedef{
typedef 關鍵字，您可以使用它來爲類型取一個新的名字。下面的實例爲單字節數字定義了一個術語 BYTE： typedef unsigned char BYTE; ---- BYTE b1, b2;
typedef vs #define --#define 是 C 指令，用於爲各種數據類型定義別名，與 typedef 類似，但是它們有以下幾點不同：
@1：typedef 僅限於爲類型定義符號名稱，#define 不僅可以爲類型定義別名，也能爲數值定義別名，比如您可以定義 1 爲 ONE。
@2：typedef 是由編譯器執行解釋的，#define 語句是由預編譯器進行處理的。
}
--輸入 & 輸出{
標準文件：<標準輸入 stdin 鍵盤 | 標準輸出 stdout 屏幕 | 標準錯誤 stderr 屏幕>
C 語言中的 I/O (輸入/輸出) 通常使用 printf() 和 scanf() 兩個函數。 scanf() 函數用於從標準輸入（鍵盤）讀取並格式化， printf() 函數發送格式化輸出到標準輸出（屏幕）。
@ 格式化數據形式： %d 格式化輸出整數 %f 格式化輸出浮點型數據
@ getchar() & putchar() 函數：
--int getchar(void) 函數從屏幕讀取下一個可用的字符，並把它返回爲一個整數。這個函數在同一個時間內只會讀取一個單一的字符。您可以在循環內使用這個方法，以便從屏幕上讀取多個字符。
--int putchar(int c) 函數把字符輸出到屏幕上，並返回相同的字符。這個函數在同一個時間內只會輸出一個單一的字符。您可以在循環內使用這個方法，以便在屏幕上輸出多個字符。
@ gets() & puts() 函數：
--char *gets(char *s) 函數從 stdin 讀取一行到 s 所指向的緩衝區，直到一個終止符或 EOF。 int puts(const char *s) 函數把字符串 s 和一個尾隨的換行符寫入到 stdout。
@ scanf() 和 printf() 函數：
--int scanf(const char *format, ...) 函數從標準輸入流 stdin 讀取輸入，並根據提供的 format 來瀏覽輸入。
--int printf(const char *format, ...) 函數把輸出寫入到標準輸出流 stdout ，並根據提供的格式產生輸出。
--format 可以是一個簡單的常量字符串，但是您可以分別指定 %s、%d、%c、%f 等來輸出或讀取字符串、整數、字符或浮點數。還有許多其他可用的格式選項，可以根據需要使用。
}
--文件讀寫{
@ 1 打開文件：使用 fopen( ) 函數來創建一個新的文件或者打開一個已有的文件，這個調用會初始化類型 FILE 的一個對象，類型 FILE 包含了所有用來控制流的必要的信息。 FILE *fopen( const char * filename, const char * mode ); <mode：r、w、a、r+、w+、a+>
@ 2 關閉文件 -- ;爲了關閉文件，請使用 fclose( ) 函數。函數的原型如下：int fclose( FILE *fp );
@ 如果成功關閉文件，fclose( ) 函數返回零，如果關閉文件時發生錯誤，函數返回 EOF。
@ 3、寫入文件：字符寫入到流中的最簡單的函數：int fputc( int c, FILE *fp ); 函數 fputc() 把參數 c 的字符值寫入到 fp 所指向的輸出流中。如果寫入成功，它會返回寫入的字符，如果發生錯誤，則會返回 EOF。
int fputs( const char *s, FILE *fp ); 函數 fputs() 把字符串 s 寫入到 fp 所指向的輸出流中。如果寫入成功，它會返回一個非負值，如果發生錯誤，則會返回 EOF。
@ 4、讀取文件：int fgetc( FILE * fp ); fgetc() 函數從 fp 所指向的輸入文件中讀取一個字符。返回值是讀取的字符，如果發生錯誤則返回 EOF。 char *fgets( char *buf, int n, FILE *fp ); 函數 fgets() 從 fp 所指向的輸入流中讀取 n - 1 個字符。它會把讀取的字符串複製到緩衝區 buf，並在最後追加一個 null 字符來終止字符串。
@5、二進制 I/O 函數：size_t fread(void *ptr, size_t size_of_elements, size_t number_of_elements, FILE *a_file);
size_t fwrite(const void *ptr, size_t size_of_elements, size_t number_of_elements, FILE *a_file);
}
--預處理器{
@1、定義：C 預處理器不是編譯器的組成部分，但是它是編譯過程中一個單獨的步驟。簡言之，C 預處理器只不過是一個文本替換工具而已，它們會指示編譯器在實際編譯之前完成所需的預處理。我們將把 C 預處理器（C Preprocessor）簡寫爲 CPP。
所有的預處理器命令都是以井號（#）開頭。它必須是第一個非空字符，爲了增強可讀性，預處理器指令應從第一列開始。
<#define 定義宏
#include 包含一個源代碼文件
#undef 取消已定義的宏
#ifdef 如果宏已經定義，則返回真
#ifndef 如果宏沒有定義，則返回真
#if 如果給定條件爲真，則編譯下面代碼
#else #if 的替代方案
#elif 如果前面的 #if 給定條件不爲真，當前條件爲真，則編譯下面代碼
#endif 結束一個 #if……#else 條件編譯塊
#error 當遇到標準錯誤時，輸出錯誤消息
#pragma 使用標準化方法，向編譯器發佈特殊的命令到編譯器中
>
@2、預處理器實例：
<
--#define MAX_ARRAY_LENGTH 20 宏定義
--#include <stdio.h> 引進系統文件
--#include "myheader.h" 引進本地文件
--#undef FILE_SIZE 取消宏定義
--#define FILE_SIZE 42 重新定義宏
--#ifndef MESSAGE #define MESSAGE "You wish!" #endif 只有當未定義時，才重新定義。
--#ifdef DEBUG /* Your debugging statements here */ #endif 判斷如果定義了，執行。。
>
@3、預定義宏：
<
__DATE__ 當前日期，一個以 "MMM DD YYYY" 格式表示的字符常量。
__TIME__ 當前時間，一個以 "HH:MM:SS" 格式表示的字符常量。
__FILE__ 這會包含當前文件名，一個字符串常量。
__LINE__ 這會包含當前行號，一個十進制常量。
__STDC__ 當編譯器以 ANSI 標準編譯時，則定義爲 1。
>
@4、預處理器運算符
<
--宏延續運算符（\）:一個宏通常寫在一個單行上。但是如果宏太長，一個單行容納不下，則使用宏延續運算符（\）。例如：
#define message_for(a, b) \
printf(#a " and " #b ": We love you!\n")
--字符串常量化運算符（#）：在宏定義中，當需要把一個宏的參數轉換爲字符串常量時，則使用字符串常量化運算符（#）。在宏中使用的該運算符有一個特定的參數或參數列表。例如：#define message_for(a, b) \ printf(#a " and " #b ": We love you!\n")
==調用： message_for(Carole, Debra);
--標記粘貼運算符（##）：宏定義內的標記粘貼運算符（##）會合並兩個參數。它允許在宏定義中兩個獨立的標記被合併爲一個標記。例如：#define tokenpaster(n) printf ("token" #n " = %d", token##n) tokenpaster(34);
--defined() 運算符：
>
}
}
--頭文件{
@1、頭文件：頭文件是擴展名爲 .h 的文件，包含了 C 函數聲明和宏定義，被多個源文件中引用共享。有兩種類型的頭文件：程序員編寫的頭文件和編譯器自帶的頭文件。 =在程序中要使用頭文件，需要使用 C 預處理指令 #include 來引用它。 =引用頭文件相當於複製頭文件的內容。 =C 或 C++ 程序中，建議把所有的常量、宏、系統全局變量和函數原型寫在頭文件中，在需要的時候隨時引用這些頭文件。
@2、引用頭文件的方法：使用預處理指令 #include 可以引用用戶和系統頭文件。它的形式有以下兩種：#include <file>--這種形式用於引用系統頭文件。它在系統目錄的標準列表中搜索名爲 file 的文件。在編譯源代碼時，您可以通過 -I 選項把目錄前置在該列表前。
=#include "file"--這種形式用於引用用戶頭文件。它在包含當前文件的目錄中搜索名爲 file 的文件。在編譯源代碼時，您可以通過 -I 選項把目錄前置在該列表前。
@3、只引用一次頭文件：如果一個頭文件被引用兩次，編譯器會處理兩次頭文件的內容，這將產生錯誤。爲了防止這種情況，標準的做法是把文件的整個內容放在條件編譯語句中，如下：
#ifndef HEADER_FILE
#define HEADER_FILE
the entire header file file
#endif
@4、有條件引用：有時需要從多個不同的頭文件中選擇一個引用到程序中。例如，需要指定在不同的操作系統上使用的配置參數。您可以通過一系列條件來實現這點，如下：
#if SYSTEM_1
# include "system_1.h"
#elif SYSTEM_2
# include "system_2.h"
#elif SYSTEM_3
...
#endif
}
--強制類型轉換{
@1、強制類型轉換：強制類型轉換是把變量從一種類型轉換爲另一種數據類型。即把高精度的數據類型轉換成低精度的數據類型。(type_name) expression
@2、整數提升：整數提升是指把小於 int 或 unsigned int 的整數類型轉換爲 int 或 unsigned int 的過程。char c = 'c'; /* ascii 值是 99 */
@3、常用的算數轉換：常用的算術轉換是隱式地把值強制轉換爲相同的類型。編譯器首先執行整數提升，如果操作數類型不同。常用的算術轉換不適用於賦值運算符、邏輯運算符 && 和 ||。
}
--錯誤處理{
@1、錯誤處理：C 語言不提供對錯誤處理的直接支持，但是作爲一種系統編程語言，它以返回值的形式允許您訪問底層數據。在發生錯誤時，大多數的 C 或 UNIX 函數調用返回 1 或 NULL，同時會設置一個錯誤代碼 errno，該錯誤代碼是全局變量，表示在函數調用期間發生了錯誤。您可以在 <error.h> 頭文件中找到各種各樣的錯誤代碼。
=C 程序員可以通過檢查返回值，然後根據返回值決定採取哪種適當的動作。開發人員應該在程序初始化時，把 errno 設置爲 0，這是一種良好的編程習慣。0 值表示程序中沒有錯誤。
@2、errno、perror() 和 strerror()：C 語言提供了 perror() 和 strerror() 函數來顯示與 errno 相關的文本消息。
=perror() 函數顯示您傳給它的字符串，後跟一個冒號、一個空格和當前 errno 值的文本表示形式。
=strerror() 函數，返回一個指針，指針指向當前 errno 值的文本表示形式。
@3、被零除的錯誤：在進行除法運算時，如果不檢查除數是否爲零，則會導致一個運行時錯誤。爲了避免這種情況發生，下面的代碼在進行除法運算前會先檢查除數是否爲零：
if( divisor == 0){
fprintf(stderr, "除數爲 0 退出運行...\n");
exit(-1);
}
@4、程序退出狀態：通常情況下，程序成功執行完一個操作正常退出的時候會帶有值 EXIT_SUCCESS。在這裏，EXIT_SUCCESS 是宏，它被定義爲 0。 =如果程序中存在一種錯誤情況，當您退出程序時，會帶有狀態值 EXIT_FAILURE，被定義爲 -1。所以，上面的程序可以寫成：
if( divisor == 0){
fprintf(stderr, "除數爲 0 退出運行...\n");
exit(EXIT_FAILURE);
}
}
--遞歸{
@1、遞歸：遞歸指的是在函數的定義中使用函數自身的方法。即函數自己調用自己，關鍵是滿足某條件時的遞歸出口，否則會造成死循環。 形式如：void recursion(){ recursion(); /* 函數調用自身 */ } int main(){ recursion();}
=遞歸函數在解決許多數學問題上起了至關重要的作用，比如計算一個數的階乘、生成斐波那契數列，等等。
@2、數的階乘：
#include <stdio.h>
double factorial(unsigned int i)
{
if(i <= 1)
{
return 1;
}
return i * factorial(i - 1);
}
int main()
{
int i = 15;
printf("%d 的階乘爲 %f\n", i, factorial(i));
return 0;
}
@3、斐波那契數列：
}
--可變參數{
@1、可變參數：希望函數帶有可變數量的參數，而不是預定義數量的參數。C 語言爲這種情況提供了一個解決方案，它允許您定義一個函數，能根據具體的需求接受可變數量的參數。下面的實例演示了這種函數的定義。
int func(int, ... )
{
.
.
.
}
int main()
{
func(1, 2, 3);
func(1, 2, 3, 4);
}
函數 func() 最後一個參數寫成省略號，即三個點號（...），省略號之前的那個參數是 int，代表了要傳遞的可變參數的總數。爲了使用這個功能，您需要使用 stdarg.h 頭文件，該文件提供了實現可變參數功能的函數和宏。
}
--內存管理{
@1、內存管理：C 語言爲內存的分配和管理提供了幾個函數。這些函數可以在 <stdlib.h> 頭文件中找到。
=void *calloc(int num, int size);--在內存中動態地分配 num 個長度爲 size 的連續空間，並將每一個字節都初始化爲 0。所以它的結果是分配了 num*size 個字節長度的內存空間，並且每個字節的值都是0。
=void free(void *address);--該函數釋放 address 所指向的內存塊,釋放的是動態分配的內存空間。
=void *malloc(int num);--在堆區分配一塊指定大小的內存空間，用來存放數據。這塊內存空間在函數執行完成後不會被初始化，它們的值是未知的。
=void *realloc(void *address, int newsize);--該函數重新分配內存，把內存擴展到 newsize。
@2、動態分配內存：編程時，如果您預先知道數組的大小，那麼定義數組時就比較容易。例如：char name[100];
=但是，如果您預先不知道需要存儲的文本長度，例如您向存儲有關一個主題的詳細描述。在這裏，我們需要定義一個指針，該指針指向未定義所學內存大小的字符，後續再根據需求來分配內存，如下所示：/* 動態分配內存 */ description = malloc( 200 * sizeof(char) ); =上面的程序也可以使用 calloc() 來編寫，只需要把 malloc 替換爲 calloc 即可，如下所示：calloc(200, sizeof(char)); =當動態分配內存時，有完全控制權，可以傳遞任何大小的值。而那些預先定義了大小的數組，一旦定義則無法改變大小。
@3、重新調整內存的大小和釋放內存：當程序退出時，操作系統會自動釋放所有分配給程序的內存，但是，建議在不需要內存時，都應該調用函數 free() 來釋放內存。 =或者，可以通過調用函數 realloc() 來增加或減少已分配的內存塊的大小。讓我們使用 realloc() 和 free() 函數，再次查看上面的實例 /* 使用 free() 函數釋放內存 */ free(description);
}
--命令行參數{
@1、命令行參數：執行程序時，可以從命令行傳值給 C 程序。這些值被稱爲命令行參數，它們對程序很重要，特別是當您想從外部控制程序，而不是在代碼內對這些值進行硬編碼時，就顯得尤爲重要了。
}
-- 標準庫 - <assert.h>{
@1、簡介：C 標準庫的 assert.h頭文件提供了一個名爲 assert 的宏，它可用於驗證程序做出的假設，並在假設爲假時輸出診斷消息。已定義的宏 assert 指向另一個宏 NDEBUG，宏 NDEBUG 不是 <assert.h> 的一部分。如果已在引用 <assert.h> 的源文件中定義 NDEBUG 爲宏名稱，則 assert 宏的定義如下：#define assert(ignore) ((void)0)
@2、庫宏：void assert(int expression)----這實際上是一個宏，不是一個函數，可用於在 C 程序中添加診斷。
}
-- 標準庫 - <ctype.h>{
@1、簡介：C 標準庫的 ctype.h 頭文件提供了一些函數，可用於測試和映射字符。 =這些函數接受 int 作爲參數，它的值必須是 EOF 或表示爲一個無符號字符。 =如果參數 c 滿足描述的條件，則這些函數返回非零（true）。如果參數 c 不滿足描述的條件，則這些函數返回零。
@2、
}
--標準庫 - <ctype.h>{
@1、簡介：C 標準庫的 ctype.h 頭文件提供了一些函數，可用於測試和映射字符。 =這些函數接受 int 作爲參數，它的值必須是 EOF 或表示爲一個無符號字符。 =如果參數 c 滿足描述的條件，則這些函數返回非零（true）。如果參數 c 不滿足描述的條件，則這些函數返回零。
@2、庫函數：
=int isalnum(int c)----該函數檢查所傳的字符是否是字母和數字。
=int isalpha(int c)-----該函數檢查所傳的字符是否是字母。
=int iscntrl(int c)------該函數檢查所傳的字符是否是控制字符。
=int isdigit(int c)------該函數檢查所傳的字符是否是十進制數字。
=int isgraph(int c)-----該函數檢查所傳的字符是否有圖形表示法。
=int islower(int c)-----該函數檢查所傳的字符是否是小寫字母。
=int isprint(int c)------該函數檢查所傳的字符是否是可打印的。
=int ispunct(int c)-----該函數檢查所傳的字符是否是標點符號字符。
=int isspace(int c)-----該函數檢查所傳的字符是否是空白字符。
=int isupper(int c)-----該函數檢查所傳的字符是否是大寫字母。
=int isxdigit(int c)-----該函數檢查所傳的字符是否是十六進制數字。
=int tolower(int c)-----該函數把大寫字母轉換爲小寫字母。
=int toupper(int c)----該函數把小寫字母轉換爲大寫字母。
@3、字符類：
=數字
=十六進制數字
=小寫字母
=大寫字母
=字母
=字母數字字符
=標點符字符
=圖像字符
=空格字符
=可打印字符
=控制字符
=空白字符
=字母字符
}
--標準庫 - <errno.h>{
@1、簡介：C 標準庫的 errno.h 頭文件定義了整數變量 errno，它是通過系統調用設置的，在錯誤事件中的某些庫函數表明了什麼發生了錯誤。該宏擴展爲類型爲 int 的可更改的左值，因此它可以被一個程序讀取和修改。 =在程序啓動時，errno 設置爲零，C 標準庫中的特定函數修改它的值爲一些非零值以表示某些類型的錯誤。您也可以在適當的時候修改它的值或重置爲零。 =errno.h 頭文件也頂了以一系列表示不同錯誤代碼的宏，這些宏應擴展爲類型爲 int 的整數常量表達式。
@2、庫宏：
=extern int errno-----這是通過系統調用設置的宏，在錯誤事件中的某些庫函數表明了什麼發生了錯誤。
=EDOM Domain Error----這個宏表示一個域錯誤，它在輸入參數超出數學函數定義的域時發生，errno 被設置爲 EDOM。
=ERANGE Range Error----這個宏表示一個範圍錯誤，它在輸入參數超出數學函數定義的範圍時發生，errn。
}
--標準庫 - <float.h>{
@1、簡介：C 標準庫的 float.h 頭文件包含了一組與浮點值相關的依賴於平臺的常量。這些常量是由 ANSI C 提出的，這讓程序更具有可移植性。在講解這些常量之前，最好先弄清楚浮點數是由下面四個元素組成的：
=S 符號 ( +/- )
=b 指數表示的基數，2 表示二進制，10 表示十進制，16 表示十六進制，等等...
=e 指數，一個介於最小值 emin 和最大值 emax 之間的整數。
=p 精度，基數 b 的有效位數
}
--標準庫 - <limits.h>{
@1、簡介：limits.h 頭文件決定了各種變量類型的各種屬性。定義在該頭文件中的宏限制了各種變量類型（比如 char、int 和 long）的值。 =這些限制指定了變量不能存儲任何超出這些限制的值，例如一個無符號可以存儲的最大值是 255。
@2、庫宏：
=CHAR_BIT 8 定義一個字節的比特數。
=SCHAR_MIN -128 定義一個有符號字符的最小值。
=SCHAR_MAX 127 定義一個有符號字符的最大值。
=UCHAR_MAX 255 定義一個無符號字符的最大值。
=CHAR_MIN 0 定義類型 char 的最小值，如果 char 表示負值，則它的值等於 SCHAR_MIN，否則等於 0。
=CHAR_MAX 127 定義類型 char 的最大值，如果 char 表示負值，則它的值等於 SCHAR_MAX，否則等於 UCHAR_MAX。
=MB_LEN_MAX 1 定義多字節字符中的最大字節數。
=SHRT_MIN -32768 定義一個短整型的最小值。
=SHRT_MAX +32767 定義一個短整型的最大值。
=USHRT_MAX 65535 定義一個無符號短整型的最大值。
=INT_MIN -32768 定義一個整型的最小值。
=INT_MAX +32767 定義一個整型的最大值。
=UINT_MAX 65535 定義一個無符號整型的最大值。
=LONG_MIN -2147483648 定義一個長整型的最小值。
=LONG_MAX +2147483647 定義一個長整型的最大值。
=ULONG_MAX 4294967295 定義一個無符號長整型的最大值。
}
--標準庫 - <locale.h>{
@1、簡介：locale.h 頭文件定義了特定地域的設置，比如日期格式和貨幣符號。接下來我們將介紹一些宏，以及一個重要的結構 struct lconv 和兩個重要的函數。
@2、庫宏：
=LC_ALL----設置下面的所有選項。
=LC_COLLATE-----影響 strcoll 和 strxfrm 函數。
=LC_CTYPE-----影響所有字符函數。
=LC_MONETARY--影響 localeconv 函數提供的貨幣信息。
=LC_NUMERIC---影響 localeconv 函數提供的小數點格式化和信息。
=LC_TIME------影響 strftime 函數。
@3、庫函數：
=char *setlocale(int category, const char *locale)----設置或讀取地域化信息。
=struct lconv *localeconv(void)------設置或讀取地域化信息。
}
--標準庫 - <math.h>{
@1、簡介：math.h 頭文件定義了各種數學函數和一個宏。在這個庫中所有可用的功能都帶有一個 double 類型的參數，且都返回 double 類型的結果。
@2、庫宏：
=HUGE_VAL-----當函數的結果不可以表示爲浮點數時。如果是因爲結果的幅度太大以致於無法表示，則函數會設置 errno 爲 ERANGE 來表示範圍錯誤，並返回一個由宏 HUGE_VAL 或者它的否定（- HUGE_VAL）命名的一個特定的很大的值。如果結果的幅度太小，則會返回零值。在這種情況下，error 可能會被設置爲 ERANGE，也有可能不會被設置爲 ERANGE。
@3、庫函數：
=double acos(double x)-----返回以弧度表示的 x 的反餘弦。
=double asin(double x)-----返回以弧度表示的 x 的反正弦。
=double atan(double x)-----返回以弧度表示的 x 的反正切。
=double atan2(double y, double x)----返回以弧度表示的 y/x 的反正切。y 和 x 的值的符號決定了正確的象限。
=double cos(double x)------返回弧度角 x 的餘弦。
=double cosh(double x)-----返回 x 的雙曲餘弦。
=double sin(double x)------返回弧度角 x 的正弦。
=double sinh(double x)-----返回 x 的雙曲正弦。
=double tanh(double x)-----返回 x 的雙曲正切。
=double exp(double x)------返回 e 的 x 次冪的值。
=double frexp(double x, int *exponent)-----把浮點數 x 分解成尾數和指數。返回值是尾數，並將指數存入 exponent 中。所得的值是 x = mantissa * 2 ^ exponent。
=double ldexp(double x, int exponent)------返回 x 乘以 2 的 exponent 次冪。
=double log(double x)------返回 x 的自然對數（基數爲 e 的對數）。
=double log10(double x)----返回 x 的常用對數（基數爲 10 的對數）。
=double modf(double x, double *integer)----返回值爲小數部分（小數點後的部分），並設置 integer 爲整數部分。
=double pow(double x, double y)------------返回 x 的 y 次冪。
=double sqrt(double x)-----返回 x 的平方根。
=double ceil(double x)-----返回大於或等於 x 的最小的整數值。
=double fabs(double x)-----返回 x 的絕對值。
=double floor(double x)----返回小於或等於 x 的最大的整數值。
=double fmod(double x, double y)-----------返回 x 除以 y 的餘數。
}
--標準庫 - <setjmp.h>{
@1、簡介：setjmp.h 頭文件定義了宏 setjmp()、函數 longjmp() 和變量類型 jmp_buf，該變量類型會繞過正常的函數調用和返回規則。
@2、庫變量：
=jmp_buf ------這是一個用於存儲宏 setjmp() 和函數 longjmp() 相關信息的數組類型。
@3、庫宏：
=int setjmp(jmp_buf environment)----這個宏把當前環境保存在變量 environment 中，以便函數 longjmp() 後續使用。如果這個宏直接從宏調用中返回，則它會返回零，但是如果它從 longjmp() 函數調用中返回，則它會返回一個非零值。
@4、庫函數：
=void longjmp(jmp_buf environment, int value)----該函數恢復最近一次調用 setjmp() 宏時保存的環境，jmp_buf 參數的設置是由之前調用 setjmp() 生成的。
}
--標準庫 - <signal.h>{
@1、簡介：signal.h 頭文件定義了一個變量類型 sig_atomic_t、兩個函數調用和一些宏來處理程序執行期間報告的不同信號。
@2、庫變量：
=sig_atomic_t-----這是 int 類型，在信號處理程序中作爲變量使用。它是一個對象的整數類型，該對象可以作爲一個原子實體訪問，即使存在異步信號時，該對象可以作爲一個原子實體訪問。
@3、庫宏：
=SIG_DFL----默認的信號處理程序。
=SIG_ERR----表示一個信號錯誤。
=SIG_IGN----忽視信號。
=SIGABRT----程序異常終止。
=SIGFPE-----算術運算出錯，如除數爲 0 或溢出。
=SIGILL-----非法函數映象，如非法指令。
=SIGINT-----中斷信號，如 ctrl-C。
=SIGSEGV----非法訪問存儲器，如訪問不存在的內存單元。
=SIGTERM----發送給本程序的終止請求信號。
@4、庫函數：
=void (*signal(int sig, void (*func)(int)))(int)----該函數設置一個函數來處理信號，即信號處理程序。
=int raise(int sig)-----該函數會促使生成信號 sig。sig 參數與 SIG 宏兼容。
}
--標準庫 - <stdarg.h>{
@1、簡介：stdarg.h 頭文件定義了一個變量類型 va_list 和三個宏，這三個宏可用於在參數個數未知（即參數個數可變）時獲取函數中的參數。 =可變參數的函數通在參數列表的末尾是使用省略號(,...)定義的。
@2、庫變量：
=va_list -----這是一個適用於 va_start()、va_arg() 和 va_end() 這三個宏存儲信息的類型。
@3、庫宏：
=void va_start(va_list ap, last_arg)-----這個宏初始化 ap 變量，它與 va_arg 和 va_end 宏是一起使用的。last_arg 是最後一個傳遞給函數的已知的固定參數，即省略號之前的參數。
=type va_arg(va_list ap, type)-----這個宏檢索函數參數列表中類型爲 type 的下一個參數。
=void va_end(va_list ap)-----這個宏允許使用了 va_start 宏的帶有可變參數的函數返回。如果在從函數返回之前沒有調用 va_end，則結果爲未定義。
}
--標準庫 - <stddef.h>{
@1、簡介：stddef .h 頭文件定義了各種變量類型和宏。這些定義中的大部分也出現在其它頭文件中。
@2、庫變量：
=ptrdiff_t----這是有符號整數類型，它是兩個指針相減的結果。
=size_t ------這是無符號整數類型，它是 sizeof 關鍵字的結果。
=wchar_t -----這是一個寬字符常量大小的整數類型。
@3、庫宏：
=NULL-----這個宏是一個空指針常量的值。
=offsetof(type, member-designator)-----這會生成一個類型爲 size_t 的整型常量，它是一個結構成員相對於結構開頭的字節偏移量。成員是由 member-designator 給定的，結構的名稱是在 type 中給定的。
}
--標準庫 - <stdio.h>{
@1、簡介：stdio .h 頭文件定義了三個變量類型、一些宏和各種函數來執行輸入和輸出。
@2、庫變量：
=size_t ----這是無符號整數類型，它是 sizeof 關鍵字的結果。
=FILE ------這是一個適合存儲文件流信息的對象類型。
=fpos_t ----這是一個適合存儲文件中任何位置的對象類型。
@3、庫宏：
=NULL----這個宏是一個空指針常量的值。
=_IOFBF、_IOLBF 和 _IONBF ----這些宏擴展了帶有特定值的整型常量表達式，並適用於 setvbuf 函數的第三個參數。
=BUFSIZ----這個宏是一個整數，該整數代表了 setbuf 函數使用的緩衝區大小。
=EOF ------這個宏是一個表示已經到達文件結束的負整數。
=FOPEN_MAX ----這個宏是一個整數，該整數代表了系統可以同時打開的文件數量。
=FILENAME_MAX --這個宏是一個整數，該整數代表了字符數組可以存儲的文件名的最大長度。如果實現沒有任何限制，則該值應爲推薦的最大值。
=L_tmpnam ------這個宏是一個整數，該整數代表了字符數組可以存儲的由 tmpnam 函數創建的臨時文件名的最大長度。
=SEEK_CUR、SEEK_END 和 SEEK_SET ---這些宏是在These macros are used in the fseek 函數中使用，用於在一個文件中定位不同的位置。
=TMP_MAX -------這個宏是 tmpnam 函數可生成的獨特文件名的最大數量。
=stderr、stdin 和 stdout ----------這些宏是指向 FILE 類型的指針，分別對應於標準錯誤、標準輸入和標準輸出流。
@4、庫函數：
=int fclose(FILE *stream)------關閉流 stream。刷新所有的緩衝區。
=void clearerr(FILE *stream)---清除給定流 stream 的文件結束和錯誤標識符。
=int feof(FILE *stream)--------測試給定流 stream 的文件結束標識符。
=int ferror(FILE *stream)------測試給定流 stream 的錯誤標識符。
=int fflush(FILE *stream)------刷新流 stream 的輸出緩衝區。
=int fgetpos(FILE *stream, fpos_t *pos)-----獲取流 stream 的當前文件位置，並把它寫入到 pos。
=FILE *fopen(const char *filename, const char *mode)-----使用給定的模式 mode 打開 filename 所指向的文件。
=size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream)-----從給定流 stream 讀取數據到 ptr 所指向的數組中。
=FILE *freopen(const char *filename, const char *mode, FILE *stream)-----把一個新的文件名 filename 與給定的打開的流 stream 關聯，同時關閉流中的舊文件。
=int fseek(FILE *stream, long int offset, int whence)-----設置流 stream 的文件位置爲給定的偏移 offset，參數 offset 意味着從給定的 whence 位置查找的字節數。
=int fsetpos(FILE *stream, const fpos_t *pos)------設置給定流 stream 的文件位置爲給定的位置。參數 pos 是由函數 fgetpos 給定的位置。
=long int ftell(FILE *stream)---------返回給定流 stream 的當前文件位置。
=size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)-----把 ptr 所指向的數組中的數據寫入到給定流 stream 中。
=int remove(const char *filename)-------刪除給定的文件名 filename，以便它不再被訪問。
=int rename(const char *old_filename, const char *new_filename)-----把 old_filename 所指向的文件名改爲 new_filename。
=void rewind(FILE *stream)------設置文件位置爲給定流 stream 的文件的開頭。
=void setbuf(FILE *stream, char *buffer)------定義流 stream 應如何緩衝。
=int setvbuf(FILE *stream, char *buffer, int mode, size_t size)-----另一個定義流 stream 應如何緩衝的函數。
=FILE *tmpfile(void)-----以二進制更新模式(wb+)創建臨時文件。
=char *tmpnam(char *str)----生成並返回一個有效的臨時文件名，該文件名之前是不存在的。
=int fprintf(FILE *stream, const char *format, ...)-----發送格式化輸出到流 stream 中。
=int printf(const char *format, ...)------發送格式化輸出到標準輸出 stdout。
=int sprintf(char *str, const char *format, ...)-----發送格式化輸出到字符串。
=int vfprintf(FILE *stream, const char *format, va_list arg)------使用參數列表發送格式化輸出到流 stream 中。
=int vprintf(const char *format, va_list arg)-----使用參數列表發送格式化輸出到標準輸出 stdout。
=int vsprintf(char *str, const char *format, va_list arg)---------使用參數列表發送格式化輸出到字符串。
=int fscanf(FILE *stream, const char *format, ...)--------從流 stream 讀取格式化輸入。
=int scanf(const char *format, ...)------從標準輸入 stdin 讀取格式化輸入。
=int sscanf(const char *str, const char *format, ...)-----從字符串讀取格式化輸入。
=int fgetc(FILE *stream)------從指定的流 stream 獲取下一個字符（一個無符號字符），並把位置標識符往前移動。
=char *fgets(char *str, int n, FILE *stream)--------從指定的流 stream 讀取一行，並把它存儲在 str 所指向的字符串內。當讀取 (n-1) 個字符時，或者讀取到換行符時，或者到達文件末尾時，它會停止，具體視情況而定。
=int fputc(int char, FILE *stream)------把參數 char 指定的字符（一個無符號字符）寫入到指定的流 stream 中，並把位置標識符往前移動。
=int fputs(const char *str, FILE *stream)-------把字符串寫入到指定的流 stream 中，但不包括空字符。
=int getc(FILE *stream)------從指定的流 stream 獲取下一個字符（一個無符號字符），並把位置標識符往前移動。
=int getchar(void)------從標準輸入 stdin 獲取一個字符（一個無符號字符）。
=char *gets(char *str)---從標準輸入 stdin 讀取一行，並把它存儲在 str 所指向的字符串中。當讀取到換行符時，或者到達文件末尾時，它會停止，具體視情況而定。
=int putc(int char, FILE *stream)------把參數 char 指定的字符（一個無符號字符）寫入到指定的流 stream 中，並把位置標識符往前移動。
=int putchar(int char)-----把參數 char 指定的字符（一個無符號字符）寫入到標準輸出 stdout 中。
=int puts(const char *str)-----把一個字符串寫入到標準輸出 stdout，直到空字符，但不包括空字符。換行符會被追加到輸出中。
=int ungetc(int char, FILE *stream)-------把字符 char（一個無符號字符）推入到指定的流 stream 中，以便它是下一個被讀取到的字符。
=void perror(const char *str)------把一個描述性錯誤消息輸出到標準錯誤 stderr。首先輸出字符串 str，後跟一個冒號，然後是一個空格。
}
--標準庫 - <stdlib.h>{
@1、簡介：stdlib .h 頭文件定義了四個變量類型、一些宏和各種通用工具函數。
@2、庫變量：
=size_t ----- 這是無符號整數類型，它是 sizeof 關鍵字的結果。
=wchar_t ----- 這是一個寬字符常量大小的整數類型。
=div_t ----- 這是 div 函數返回的結構。
=ldiv_t ----- 這是 ldiv 函數返回的結構。
@3、庫宏：
=NULL ---- 這個宏是一個空指針常量的值。
=EXIT_FAILURE ----- 這是 exit 函數失敗時要返回的值。
=EXIT_SUCCESS ----- 這是 exit 函數成功時要返回的值。
=RAND_MAX ----- 這個宏是 rand 函數返回的最大值。
=MB_CUR_MAX ----- 這個宏表示在多字節字符集中的最大字符數，不能大於 MB_LEN_MAX。
@4、庫函數：
=double atof(const char *str)---- 把參數 str 所指向的字符串轉換爲一個浮點數（類型爲 double 型）。
=int atoi(const char *str) ----- 把參數 str 所指向的字符串轉換爲一個整數（類型爲 int 型）。
=long int atol(const char *str) ----- 把參數 str 所指向的字符串轉換爲一個長整數（類型爲 long int 型）。
=double strtod(const char *str, char **endptr) ------ 把參數 str 所指向的字符串轉換爲一個浮點數（類型爲 double 型）。
=long int strtol(const char *str, char **endptr, int base) ----- 把參數 str 所指向的字符串轉換爲一個長整數（類型爲 long int 型）。
=unsigned long int strtoul(const char *str, char **endptr, int base) ----- 把參數 str 所指向的字符串轉換爲一個無符號長整數（類型爲 unsigned long int 型）。
=void *calloc(size_t nitems, size_t size) ----- 分配所需的內存空間，並返回一個指向它的指針。
=void free(void *ptr) ----- 釋放之前調用 calloc、malloc 或 realloc 所分配的內存空間。
=void *malloc(size_t size) ----- 分配所需的內存空間，並返回一個指向它的指針。
=void *realloc(void *ptr, size_t size) ------ 嘗試重新調整之前調用 malloc 或 calloc 所分配的 ptr 所指向的內存塊的大小。
=void abort(void) ------ 使一個異常程序終止。
=int atexit(void (*func)(void)) ----- 當程序正常終止時，調用指定的函數 func。
=void exit(int status) ----- 使程序正常終止。
=char *getenv(const char *name) ----- 搜索 name 所指向的環境字符串，並返回相關的值給字符串。
=int system(const char *string) ----- 由 string 指定的命令傳給要被命令處理器執行的主機環境。
=void *bsearch(const void *key, const void *base, size_t nitems, size_t size, int (*compar)(const void *, const void *)) ---- 執行二分查找。
void qsort(void *base, size_t nitems, size_t size, int (*compar)(const void *, const void*)) ----- 數組排序。
=int abs(int x) ----- 返回 x 的絕對值。
=div_t div(int numer, int denom) ----- 分子除以分母。
=long int labs(long int x) ----- 返回 x 的絕對值。
=ldiv_t ldiv(long int numer, long int denom) ----- 分子除以分母。
=int rand(void) ----- 返回一個範圍在 0 到 RAND_MAX 之間的僞隨機數。
=void srand(unsigned int seed) ------ 該函數播種由函數 rand 使用的隨機數發生器。
=int mblen(const char *str, size_t n) ----- 返回參數 str 所指向的多字節字符的長度。
=size_t mbstowcs(schar_t *pwcs, const char *str, size_t n) ----- 把參數 str 所指向的多字節字符的字符串轉換爲參數 pwcs 所指向的數組。
=int mbtowc(whcar_t *pwc, const char *str, size_t n) ----- 檢查參數 str 所指向的多字節字符。
=size_t wcstombs(char *str, const wchar_t *pwcs, size_t n) ----- 把數組 pwcs 中存儲的編碼轉換爲多字節字符，並把它們存儲在字符串 str 中。
=int wctomb(char *str, wchar_t wchar) ----- 檢查對應於參數 wchar 所給出的多字節字符的編碼。
}
--標準庫 - <string.h>{
@1、簡介：string .h 頭文件定義了一個變量類型、一個宏和各種操作字符數組的函數。
@2、庫變量：size_t ----- 這是無符號整數類型，它是 sizeof 關鍵字的結果。
@3、庫宏：NULL ----- 這個宏是一個空指針常量的值。
@4、庫函數：
=void *memchr(const void *str, int c, size_t n) ----- 在參數 str 所指向的字符串的前 n 個字節中搜索第一次出現字符 c（一個無符號字符）的位置。
=int memcmp(const void *str1, const void *str2, size_t n) ----- 把 str1 和 str2 的前 n 個字節進行比較。
=void *memcpy(void *dest, const void *src, size_t n) ----- 從 src 複製 n 個字符到 dest。
=void *memmove(void *dest, const void *src, size_t n) ----- 另一個用於從 str2 複製 n 個字符到 str1 的函數。
=void *memset(void *str, int c, size_t n) ----- 複製字符 c（一個無符號字符）到參數 str 所指向的字符串的前 n 個字符。
=char *strcat(char *dest, const char *src) ---- 把 src 所指向的字符串追加到 dest 所指向的字符串的結尾。
=char *strncat(char *dest, const char *src, size_t n) ----- 把 src 所指向的字符串追加到 dest 所指向的字符串的結尾，直到 n 字符長度爲止。
=char *strchr(const char *str, int c) ---- 在參數 str 所指向的字符串中搜索第一次出現字符 c（一個無符號字符）的位置。
=int strcmp(const char *str1, const char *str2) ----- 把 str1 所指向的字符串和 str2 所指向的字符串進行比較。
=int strncmp(const char *str1, const char *str2, size_t n) ----- 把 str1 和 str2 進行比較，最多比較前 n 個字節。
=int strcoll(const char *str1, const char *str2) ----- 把 str1 和 str2 進行比較，結果取決於 LC_COLLATE 的位置設置。
=char *strcpy(char *dest, const char *src) ----- 把 src 所指向的字符串複製到 dest。
=char *strncpy(char *dest, const char *src, size_t n) ----- 把 src 所指向的字符串複製到 dest，最多複製 n 個字符。
=size_t strcspn(const char *str1, const char *str2) ----- 檢索字符串 str1 開頭連續有幾個字符都不含字符串 str2 中的字符。
=char *strerror(int errnum) ----- 從內部數組中搜索錯誤號 errnum，並返回一個指向錯誤消息字符串的指針。
=size_t strlen(const char *str) ----- 計算字符串 str 的長度，直到空結束字符，但不包括空結束字符。
=char *strpbrk(const char *str1, const char *str2) ----- 檢索字符串 str1 中第一個匹配字符串 str2 中字符的字符，不包含空結束字符。也就是說，依次檢驗字符串 str1 中的字符，當被檢驗字符在字符串 str2 中也包含時，則停止檢驗，並返回該字符位置。
=char *strrchr(const char *str, int c) ----- 在參數 str 所指向的字符串中搜索最後一次出現字符 c（一個無符號字符）的位置。
=size_t strspn(const char *str1, const char *str2) ----- 檢索字符串 str1 中第一個不在字符串 str2 中出現的字符下標。
=char *strstr(const char *haystack, const char *needle) ----- 在字符串 haystack 中查找第一次出現字符串 needle（不包含空結束字符）的位置。
=char *strtok(char *str, const char *delim) ----- 分解字符串 str 爲一組字符串，delim 爲分隔符。
=size_t strxfrm(char *dest, const char *src, size_t n) ----- 根據程序當前的區域選項中的 LC_COLLATE 來轉換字符串 src 的前 n 個字符，並把它們放置在字符串 dest 中。
}
--標準庫 - <time.h>{
@1、簡介：time.h 頭文件定義了四個變量類型、兩個宏和各種操作日期和時間的函數。
@2、庫變量：
=size_t ----- 是無符號整數類型，它是 sizeof 關鍵字的結果。
=clock_t ----- 這是一個適合存儲處理器時間的類型。
=time_t is --- 這是一個適合存儲日曆時間類型。
=struct tm ---- 這是一個用來保存時間和日期的結構。
@3、庫宏：
=NULL ----- 這個宏是一個空指針常量的值。
=CLOCKS_PER_SEC ----- 這個宏表示每秒的處理器時鐘個數。
@4、庫函數：
=char *asctime(const struct tm *timeptr) ----- 返回一個指向字符串的指針，它代表了結構 timeptr 的日期和時間。
=clock_t clock(void) ----- 返回程序執行起（一般爲程序的開頭），處理器時鐘所使用的時間。
=char *ctime(const time_t *timer) ----- 返回一個表示當地時間的字符串，當地時間是基於參數 timer。
=double difftime(time_t time1, time_t time2) ----- 返回 time1 和 time2 之間相差的秒數 (time1-time2)。
=struct tm *gmtime(const time_t *timer) ---- timer 的值被分解爲 tm 結構，並用協調世界時（UTC）也被稱爲格林尼治標準時間（GMT）表示。
=struct tm *localtime(const time_t *timer) ----- timer 的值被分解爲 tm 結構，並用本地時區表示。
=time_t mktime(struct tm *timeptr) ----- 把 timeptr 所指向的結構轉換爲一個依據本地時區的 time_t 值。
=size_t strftime(char *str, size_t maxsize, const char *format, const struct tm *timeptr) ----- 根據 format 中定義的格式化規則，格式化結構 timeptr 表示的時間，並把它存儲在 str 中。
=time_t time(time_t *timer) ----- 計算當前日曆時間，並把它編碼成 time_t 格式。
}
】