C語言探索之旅 | 第二部分第四課：字符串

時間 2020-06-09

標籤 c語言探索之旅第二部分第四字符串简体版

原文原文鏈接

做者謝恩銘，公衆號「程序員聯盟」（微信號：coderhub）。
轉載請註明出處。
原文： https://www.jianshu.com/p/2be...
《C語言探索之旅》全系列程序員

內容簡介

前言
字符類型
顯示字符
字符串其實就是字符的數組
字符串的建立和初始化
從 scanf 函數取得一個字符串
操縱字符串的一些經常使用函數
總結
第二部分第五課預告

1. 前言

上一課 C語言探索之旅 | 第二部分第三課：數組，咱們結束了關於數組的旅程。編程

好了，這課我不說「廢話」，直接進入主題（但又好像不是個人風格...）。這一課咱們仍是會涉及一些指針和數組的知識。數組

字符串，這是一個編程的術語，用來描述「一段文字」。微信

一個字符串，就是咱們能夠在內存中以變量的形式儲存的「一段文字」。架構

好比，用戶名是一個字符串，「程序員聯盟」是一個字符串。函數

可是咱們以前的課說過，呆萌的電腦兄只認得數字，「衆裏尋他千百度，電腦卻只認得數。」學習

因此實際上，電腦是不認得字母的，可是「古靈精怪」的計算機先驅們是如何使電腦能夠「識別」字母呢？測試

接下來咱們會看到，他們仍是很聰明的。網站

2. 字符類型

在這個小部分，咱們把注意力先集中在字符類型上。編碼

若是你還記得，以前的課程中咱們說過：char（有符號字符類型）是用來儲存範圍從 -128 到 127 的數的；unsigned char（無符號字符類型）用來儲存範圍從 0 到 255 的數。

注意：雖然 char 類型能夠用來儲存數值，可是在 C語言中卻鮮少用 char 來儲存一個數。
一般，即便咱們要表示的數比較小，咱們也會用 int 類型來儲存。
固然了，用 int 來儲存比用 char 來儲存在內存上更佔空間。可是今天的電腦基本上是不缺那點內存的，「有內存任性嘛」。

char 類型通常用來儲存一個字符，注意，是一個字符。

前面的課程也提到了，由於電腦只認得數字，因此計算機先驅們創建了一個表格（比較常見的有 ASCII 表，更完整一些的有 Unicode 表），用來約定字符和數字之間的轉換關係，例如大寫字母 A 對應的數字是 65。

C語言能夠很容易地轉換字符和其對應的數值。爲了獲取到某個字符對應的數值（電腦底層其實都是數值），只須要把該字符用單引號括起來，像這樣：

'A'

在編譯的時候，'A' 會被替換成實際的數值 65。

咱們來測試一下：

#include <stdio.h>

int main(int argc, char *argv[])
{
    char letter = 'A';

    printf("%d\n", letter);

    return 0;
}

程序輸出：

因此，咱們能夠確信大寫字母 A 的對應數值是 65。相似地，大寫字母 B 對應 66， C 對應 67，以此類推。

若是咱們測試小寫字母，那你會看到 a 和 A 的數值是不同的，小寫字母 a 的數值是 97。

實際上，在大寫字母和小寫字母之間有一個很簡單的轉換公式，就是

小寫字母的數值 = 大寫字母的數值 + 32

因此電腦是區分大小寫的，看似呆萌的電腦兄仍是能夠的麼。

大部分所謂「基礎」的字符都被編碼成 0 到 127 之間的數值了。在 ASCII 表（發音 [aski]）的官網 http://www.asciitable.com 上，咱們能夠看到大部分經常使用的字符的對應數值。

固然這個表咱們也能夠在其餘網站上找到，好比維基百科，百度百科，等等。

3. 顯示字符

要顯示一個字符，最經常使用的仍是 printf 函數啦。這個函數真的很強大，咱們會常常用到。

上面的例子中，咱們用 %d 格式，因此顯示的是字符對應的數值（%d 是整型）。若是要顯示字符實際的樣子，須要用到 %c 格式（c 是英語 character 的首字母，表示「字符」）：

int main(int argc, char *argv[])
{
    char letter = 'A';

    printf("%c\n", letter);

    return 0;
}

程序輸出：

固然咱們也能夠用常見的 scanf 函數來請求用戶輸入一個字符，然後用 printf 函數打印：

int main(int argc, char *argv[])
{
    char letter = 0;

    scanf("%c", &letter);

    printf("%c\n", letter);

    return 0;
}

若是我輸入 C，那我將看到：

C
C

第一個字母 C 是我輸入給 scanf 函數的，第二個 C 是 printf 函數打印的。

以上就是對於字符類型 char 咱們大體須要知道的，請牢記如下幾點：

signed char（有符號字符類型）用來儲存範圍從 -128 到 127 的數。
unsigned char（無符號字符類型）用來儲存範圍從 0 到 255 的數。
C語言中，若是你沒寫 signed 或 unsigned 關鍵字，默認狀況下是 signed（有符號）。
計算機先驅們給電腦規定了一個表，電腦能夠遵守裏面的轉換原則來轉換字符和數值，通常這個表是 ASCII 表。
char 類型只能儲存一個字符。
'A' 在編譯時會被替換成實際的數值：65 。所以，咱們使用單引號來得到一個字符的值。

4. 字符串其實就是字符的數組

這一部分的內容，就如這個小標題所言。

事實上：一個字符串就是一個「字符的數組」，僅此而已。

到這裏，你是否對字符串有了更直觀的理解呢？

若是咱們建立一個字符數組：

char string[5];

而後咱們在數組的第一個成員上儲存 'H'，就是 string[0] = 'H'，第二個成員上儲存 'E'（string[1] = 'H'），第三個成員上儲存 'L'（string[2] = 'L'），第四個成員儲存 'L'（string[3] = 'L'），第五個成員儲存 'O'（string[4] = 'O'），那麼咱們就構造了一個字符串。

下圖對於字符串在內存中是怎麼存儲的，能夠給出一個比較直觀的印象（注意：實際的狀況比這個圖演示的要略微複雜一些，待會兒會解釋）：

上圖中，咱們能夠看到一個數組，擁有 5 個成員，在內存上連續存放，構成一個字符串 "HELLO"（表示「喂，你好」）。

對於每個儲存在內存地址上的字符，咱們用了單引號把它括起來，是爲了突出實際上儲存的是數值，而不是字符。在內存上，儲存的就是此字符對應的數值。

實際上，一個字符串可不是就這樣結束了，上面的圖示其實不完整。

一個字符串必須在最後包含一個特殊的字符，稱爲「字符串結束符」，它是 '0'，對應的數值是 0。

「爲何要在字符串結尾加這麼一個多餘的字符呢？」

問得好！

那是爲了讓電腦知道一個字符串到哪裏結束。

'0' 用於告訴電腦：「中止，字符串到此結束了，不要再讀取了，先退下吧」。

所以，爲了在內存中存儲字符串 "HELLO"（5 個字符），用 5 個成員的字符數組是不夠的，須要 6 個！

所以每次建立字符串時，須要記得在字符數組的結尾留一個字符給 '0'。

忘記字符串結束符是 C語言中一個常見的錯誤。

所以，下面纔是正確展現咱們的字符串 "HELLO" 在內存中實際存放狀況的示意圖：

如上圖所見，這個字符串包含 6 個字符，而不是 5 個。

也多虧了這個字符串結束符 '0'，咱們就無需記得字符串的長度了，由於它會告訴電腦字符串在哪裏結束。

所以，咱們就能夠將咱們的字符數組做爲參數傳遞給函數，而不須要傳遞字符數組的大小了。

這個好處只針對字符數組，你能夠在傳遞給函數時將其寫爲 char * 或者 char[] 類型。

對於其餘類型的數組，咱們老是要在某處記錄下它的長度。

5. 字符串的建立和初始化

若是咱們想要用 "Hello" 來初始化字符數組 string，咱們能夠用如下的方式來實現。固然，有點沒效率：

char string[6];  // 六個 char 構成的數組，爲了儲存：H-e-l-l-o + \0

string[0] = 'H';
string[1] = 'e';
string[2] = 'l';
string[3] = 'l';
string[4] = 'o';
string[5] = '\0';

雖然是笨辦法，但至少行得通。

咱們用 printf 函數來測試一下。

要使 printf 函數能顯示字符串，咱們須要用到 %s 這個符號（s 就是英語 string 的首字母，表示「字符串」）：

#include <stdio.h>

int main(int argc, char *argv[])
{

    char string[6];  // 六個 char 構成的數組，爲了儲存：H-e-l-l-o + \0

    string[0] = 'H';
    string[1] = 'e';
    string[2] = 'l';
    string[3] = 'l';
    string[4] = 'o';
    string[5] = '\0';

    // 顯示字符串內容
    printf("%s\n", string);

    return 0;
}

程序輸出：

Hello

若是咱們的字符串內容多起來，上面的方法就更顯拙劣了。其實啊，初始化字符串還有更簡單的一種方式（讀者：「你好‘奸詐’，不早講，害我寫代碼這麼辛苦...」）：

int main(int argc, char *argv[])
{
    char string[] = "Hello";  // 字符數組的長度會被自動計算

    printf("%s\n", string);

    return 0;
}

以上程序的第一行，咱們寫了一個char [] 類型的變量，其實也能夠寫成 char * ，一樣是能夠運行的：

char *string = "Hello";

這種方法就比以前一個字符一個字符初始化的方法高大上多了，由於只須要在雙引號裏輸入你想要建立的字符串，C語言的編譯器就很智能地爲你計算好字符串的大小。

編譯器計算你輸入的字符的數目，而後再加上一個 '0' 的長度（是 1），就把你的字符串裏的字符一個接一個寫到內存某個地方，在最後加上 '0' 這個字符串結束符，就像咱們剛纔用第一種方式本身一步步作的。

可是簡便也有缺陷。咱們會發現，對於字符數組來講，這種方法只能用於初始化，你在以後的程序中就不能再用這種方式來給整個數組賦值了，好比你不能這樣：

char string[] = "Hello";
string = "nihao";   // --> 出錯！

只能一個字符一個字符地改，例如：

string[0] = 'j';   // --> 能夠！

可是問題又來了，對於用 char * 來聲明的字符串，咱們能夠在以後整個從新賦值，可是不能夠單獨修改某個字符：

char *string = "Hello";
string = "nihao";   // --> 能夠！

這樣是能夠的。可是若是修改其中的一個字符，就不能夠：

string[1] = 'a'; // --> 出錯！

頗有意思吧。你們能夠親自動手試試。因此這裏就引出了一個話題：

指針和數組根本就是兩碼事！

爲何會出現上述的狀況呢？（請注意：下面的這塊內容比較難，若是看不懂，也能夠暫時跳過。不過建議測試一下給出的代碼）。

那是由於：

char stringArray[] = "Hello";

這樣聲明的是一個字符數組，裏面的字符串是儲存在內存的變量區，是在棧上，因此能夠修改每一個字符的內容，可是不能夠經過數組名總體修改：

stringArray = "nihao";  // --> 出錯！

只能一個個單獨改：

stringArray[0] = 'a';  // --> 能夠！

由於以前的課程裏說過，stringArray 這個數組的名字表示的是數組首元素的首地址。

char *stringPointer = "Hello";

這樣聲明的是一個指針，stringPointer 是指針的名字。指針變量在 32 位系統下，永遠佔 4 個 byte（字節）；在 64 位系統下，永遠佔 8 個 byte（字節）。其值爲某一個內存的地址。

因此 stringPointer 裏面只是存放了一個地址，這個地址上存放的字符串是常量字符串。這個常量字符串存放在內存的靜態區，不能夠更改。

和上面的字符數組狀況不同，上面的字符數組是自己存放了那一整個字符串。

stringPointer[0] = 'a';  // --> 出錯！

可是能夠改變 stringPointer 指針的指向：

stringPointer = "nihao";  // --> 能夠！（由於能夠修改指針指向哪裏）

你們能夠本身測試一下：

char *n1 = "it";
char *n2 = "it";

printf("%p\n%p\n", n1, n2);  //用 %p 查看地址

會發現兩者的結果是同樣的，指向同一個地址！

再進一步測試（生命在於折騰...）：

char *n1 = "it";
char *n2 = "it";
 
printf("%p\n%p\n", n1, n2);
 
n1 = "haha";
 
printf("%p\n%p\n", n1, n2);

你會發現以上程序，指針 n2 所指向的地址一直沒變，而 n1 在通過

n1 = "haha";

以後，它所指向的地址就改變了。

通過上面地分析，可能不少朋友仍是有點暈，特別是可能不太清楚內存各個區域的區別。

若是有興趣深刻探究，既能夠本身去看相關的 C語言書籍。也能夠參考下表和一些解釋，若是暫時不想把本身搞得更暈，能夠跳過，之後講到相關內容時天然更好理解。

名稱	內容
代碼段	可執行代碼、字符串常量
數據段	已初始化全局變量、已初始化全局靜態變量、局部靜態變量、常量數據
BSS 段	未初始化全局變量，未初始化全局靜態變量
棧	局部變量、函數參數
堆	動態內存分配

通常狀況下，一個可執行二進制程序（更確切的說，在 Linux 操做系統下爲一個進程單元）在存儲（沒有調入到內存運行）時擁有 3 個部分，分別是代碼段、數據段和 BSS 段。

這 3 個部分一塊兒組成了該可執行程序的文件。

(1) 代碼段（code segment / text segment）：存放 CPU 執行的機器指令。一般代碼段是可共享的，這使得須要頻繁被執行的程序只須要在內存中擁有一份拷貝便可。代碼段也一般是隻讀的，這樣能夠防止其餘程序意外地修改其指令。另外，代碼段還規劃了局部數據所申請的內存空間信息。
代碼段一般是指用來存放程序執行代碼的一塊內存區域。這部分區域的大小在程序運行前就已經肯定，而且內存區域一般屬於只讀，某些架構也容許代碼段爲可寫，即容許修改程序。在代碼段中，也有可能包含一些只讀的常數變量，例如字符串常量等。

(2) 數據段（data segment）：或稱全局初始化數據段/靜態數據段(initialized data segment / data segment)。該段包含了在程序中明確被初始化的全局變量、靜態變量(包括全局靜態變量和局部靜態變量)和常量數據。

(3) 未初始化數據段：也稱 BSS（Block Started by Symbol）。該段存入的是全局未初始化變量、靜態未初始化變量。

而當程序被加載到內存單元時，則須要另外兩個域：棧和堆。

(4) 棧（stack）：存放函數的參數值、局部變量的值，以及在進行任務切換時存放當前任務的上下文內容。

(5) 堆（heap）：用於動態內存分配（以後的課程立刻會講到），就是使用 malloc / free 系列函數來管理的內存空間。

在將應用程序加載到內存空間執行時，操做系統負責代碼段、數據段和 BSS 段的加載，並將在內存中爲這些段分配空間。

棧也由操做系統分配和管理，而不須要程序員顯式地管理；堆由程序員本身管理，即顯式地申請和釋放空間。

不少 C語言的初學者搞不懂指針和數組到底有什麼樣的關係。

如今就告訴你們：指針和數組之間沒有任何關係！它們是「清白」的...

指針就是指針：指針變量在 32 位系統下，永遠佔 4 個 byte（字節）；在 64 位系統下，永遠佔 8 個 byte（字節）。其值爲某一個內存的地址。指針能夠指向任何地方，但不是任何地方你都能經過這個指針變量訪問到。
數組就是數組：其大小與元素的類型和個數有關。定義數組時必須指定其元素的類型和個數。數組能夠存任何類型的數據，但不能存函數。

推薦你們去看《C語言深度解剖》這本只有 100 多頁的 PDF，是國人寫的，裏面對於指針和數組分析得很全面。

不由感嘆，C語言果真是博（xiang）大（dang）精（ke）深（pa）。

6. 從 scanf 函數取得一個字符串

咱們能夠用 scanf 函數獲取用戶輸入的一個字符串，也要用到 %s 符號。

可是有一個問題：就是你不能知道用戶究竟會輸入多少字符。

假如咱們的程序是問用戶他的名字是什麼。那麼他可能回答 Tom，只有三個字符，或者 Bruce LI，就有 8 個字符了。

因此咱們只能用一個足夠大的數組來存儲名字，例如 char[100]。你會說這樣太浪費內存了，可是前面咱們也說過了，目前的電腦通常不在意這點內存。

因此咱們的程序會是這樣：

int main(int argc, char *argv[])
{
    char name[100];

    printf("請問您叫什麼名字 ? ");

    scanf("%s", name);

    printf("您好, %s, 很高興認識您!\n", name);

    return 0;
}

運行程序：

請問您叫什麼名字？Oscar
您好，Oscar，很高興認識您！

7. 操縱字符串的一些經常使用函數

字符串在 C語言裏是很經常使用的。事實上，此刻你在電腦或手機屏幕上看到的這些單詞、句子等，都是在電腦內存裏的字符數組。

爲了方便咱們操縱字符串，C語言的設計者們在 string 這個標準庫中已經寫好了不少函數，可供咱們使用。

固然在這之前，須要在你的 .c 源文件中引入這個頭文件：

#include <string.h>

下面咱們就來介紹它們之中最經常使用的一些吧：

strlen：計算字符串的長度

strlen 函數返回一個字符串的長度（不包括 '0'）。

爲何名字是 strlen？其實很好記：

str 是 string（表示「字符串」）的前三個字母。
len 是 length（表示「長度」）的前三個字母。

所以，strlen 就是「字符串長度」。

函數原型是這樣：

size_t strlen(const char* string);

注意：size_t 是一個特殊的類型，它意味着函數返回一個對應大小的數目。
不是像 int，char，long，double 之類的基本類型，而是一個被「創造」出來的類型。
在接下來的課程中咱們就會學到如何建立本身的變量類型。
暫時說來，咱們先知足於將 strlen 函數的返回值存到一個 int 變量裏（電腦會把 size_t 自動轉換成 int）。固然，嚴格來講應該用 size_t 類型，可是咱們這裏暫時不深究了。

函數的參數是 const char * 類型，以前的課程中咱們學過，const（只讀的變量）代表此類型的變量是不能被改變的，因此函數 strlen 並不會改變它的參數的值。

寫個程序測試一下 strlen 函數：

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

int main(int argc, char *argv[])
{
    char string[] = "Hello";
    int stringLength = 0;

    // 將字符串的長度儲存到 stringLength 中
    stringLength = strlen(string);

    printf("字符串 %s 中有 %d 個字符\n", string, stringLength);

    return 0;
}

程序運行，顯示：

字符串 Hello 中有 5 個字符

固然了，這個 strlen 函數，其實咱們本身也能夠很容易地實現。只須要用一個循環，從開始一直讀入字符串中的字符，計算數目，一直讀到 '0' 字符結束循環。

咱們就來實現咱們本身的 strlen 函數好了：

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

int stringLength(const char *string);

int main(int argc, char *argv[])
{
    char string[] = "Hello";
    int length = 0;

    length = stringLength(string);

    printf("字符串 %s 中有 %d 個字符\n", string, length);

    return 0;
}

int stringLength(const char *string)
{
    int charNumber = 0;
    char currentChar = 0;

    do
    {
        currentChar = string[charNumber];
        charNumber++;
    } while (currentChar != '\0');  // 咱們作循環，直到遇到 '\0'，跳出循環

    charNumber--;  // 咱們將 charNumber 減一，使其不包含 '\0' 的長度

    return charNumber;
}

程序輸出：

字符串 Hello 中有 5 個字符

strcpy：把一個字符串的內容複製到另外一個字符串裏

爲何名字是 strcpy？其實很好記：

str 是 string 的前三個字母。
cpy 是 copy（表示「拷貝，複製」）的縮寫。

所以，strcpy 就是「字符串拷貝」。

函數原型：

char* strcpy(char* targetString, const char* stringToCopy);

這個函數有兩個參數：

targetString：這是一個指向字符數組的指針，咱們要複製字符串到這個字符數組裏。
stringToCopy：這是一個指向要被複制的字符串的指針。

函數返回一個指向 targetString 的指針，一般咱們不須要獲取這個返回值。

用如下程序測試此函數：

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

int main(int argc, char *argv[])
{
    /* 咱們建立了一個字符數組 string，裏面包含了幾個字符。
    咱們又建立了另外一個字符數組 copy，包含 100 個字符，爲了足夠容納拷貝過來的字符 */
    char string[] = "Hello", copy[100] = {0};

    strcpy(copy, string);  // 咱們把 string 複製到 copy 中

    // 若是一切順利，copy 的值應該和 string 是同樣的
    printf("string 是 %s\n", string);
    printf("copy 是 %s\n", copy);

    return 0;
}

程序輸出：

string 是 Hello
copy 是 Hello

若是咱們的 copy 數組的長度小於 6，那麼程序會出錯，由於 string 的總長度是 6（最後有一個 '0' 字符串結束符）。

strcpy 的原理圖解以下：

strcat：鏈接兩個字符串

爲何名字是 strcat？其實很好記：

str 是 string 的前三個字母。
cat 是 concatenate （表示「連結，使連鎖」）的縮寫。

所以，strcat 就是「字符串連結」。

strcat 函數的做用是鏈接兩個字符串，就是把一個字符串接到另外一個的結尾。

函數原型：

char* strcat(char* string1, const char* string2);

由於 string2 是 const 類型，因此咱們就想到了，這個函數確定是將 string2 的內容接到 string1 的結尾，改變了 string1 所指向的字符指針，而後返回指向 string1 所指字符數組的指針。

略微有點拗口，但不難理解吧。

寫個程序測試一下：

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

int main(int argc, char *argv[])
{
    /* 咱們建立了兩個字符串，字符數組 string1 須要足夠長，由於咱們要將 string2 的內容接到其後 */
    char string1[100] = "Hello ", string2[] = "Oscar!";

    strcat(string1, string2);  // 將 string2 接到 string1 後面

    // 若是一切順利，那麼 string1 的值應該會變爲 "Hello Oscar!"
    printf("string1 是 %s\n", string1);

    // string2 沒有變
    printf("string2 始終是 %s\n", string2);

    return 0;
}

程序輸出：

string1 是 Hello Oscar!
string2 始終是 Oscar!

strcat 的原理以下：

當 strcat 函數將 string2 鏈接到 string1 的尾部時，它須要先刪去 string1 字符串最後的 '0'。

strcmp：比較兩個字符串

爲何名字是 strcmp？其實很好記：

str 是string 的前三個字母。
cmp 是 compare（英語「比較」）的縮寫。

所以，strcmp 就是「字符串比較」。

函數原型：

int strcmp(const char* string1, const char* string2);

能夠看到，strcmp 函數不能改變參數 string1 和 string2，由於它們都是 const 類型。

此次，函數的返回值有用了。strcmp 返回：

0：當兩個字符串相等時。
非零的整數（負數或正數）：當兩個字符串不等時。

用如下程序測試 strcmp 函數：

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

int main(int argc, char *argv[])
{
    char string1[] = "Text of test", string2[] = "Text of test";

    if (strcmp(string1, string2) == 0) // 若是兩個字符串相等
    {
        printf("兩個字符串相等\n");
    }
    else
    {
        printf("兩個字符串不相等\n");
    }

    return 0;
}

程序輸出：

兩個字符串相等

sprintf：向一個字符串寫入

固然，這個函數其實不是在 string.h 這個頭文件裏，而是在 stdio.h 頭文件裏。可是它也與字符串的操做有關，因此咱們也介紹一下，並且這個函數是很經常使用的。

看到 sprintf 函數的名字，你們是否想到了printf 函數呢？

printf 函數是向標準輸出（通常是屏幕）寫入東西，而 sprintf 是向一個字符串寫入東西。最前面的 s 就是英語 string 的首字母。

寫個程序測試一下此函數：

#include <stdio.h>

int main(int argc, char *argv[])
{
    char string[100];
    int age = 18;

    // 咱們向 string 裏寫入"你18歲了"
    sprintf(string, "你 %d 歲了", age);

    printf("%s\n", string);

    return 0;
}

程序輸出：

你 18 歲了

其餘經常使用的還有一些函數，如 strstr（在字符串中查找一個子串），strchr（在字符串裏查找一個字符），等等，咱們就不一一介紹了。

8. 總結

電腦不認識字符，它只認識數字（0 和 1）。爲了解決這個問題，計算機先驅們用一個表格規定了字符與數值的對應關係，最經常使用的是 ASCII 表和 Unicode 表。
字符類型 char 用來存儲一個字符，且只能存儲一個字符。實際上存儲的是一個數值，可是電腦會在顯示時將其轉換成對應的字符。
爲了建立一個詞或一句話，咱們須要構建一個字符串，咱們用字符數組來實現。
全部的字符串都是以 '0' 結尾，這個特殊的字符 '0' 標誌着字符串的結束。
在 string 這個 C語言標準庫中，有不少操縱字符串的函數，只須要引入頭文件 string.h 便可。