C語言相關的基礎字串函式

學習之凱發表於2021-03-03

C語言中沒有專門的字串型別,所以就用字元陣列和字元指標形式表示

1 char arr[]="abcdef"; //字元陣列表示的字串
2 char*arr="abcef"; //常量字串

對字串進行操作的函式,可以稱為字串函式,比較常見的有:strlen,strcmp,strcpy,strcat,strncpy,strncat,strncmp,strstr,strtok,strerror

strlen

strlen是用來計算字串長度的函式,函式的引數是指標,從指標指向位置開始計數,遇到‘\0'為止,計數個數為\0前出現的字元個數(不包括'\0')

#include <stdio.h>
#include <string.h>
int main()
{
    char arr[] = "abcdef";
    char p[] = { 'a', 'b', 'c', 'd' };
    int i=strlen(arr);
    int j=strlen(arr + 1);
    int k = strlen(p);
    printf("%d   %d    %d", i, j,k);
    //結果是6  5  隨機值
    //6和5表示了strlen是從指標指向的地方開始計算字串的長度的,而不只是簡單從第一個字元開始計算。
    //隨機值的出現是因為字元陣列p沒有'\0'的存在,所以計數會一直進行,直到在界外遇到\0才停下
    //所以引數指向的字串必須以\0結束才能用到strlen
    return 0;
}

strlen作為一個函式他有屬於自己的返回值型別,它的型別是unsigned int 也就是無符號的整型,所以在strlen的返回值中是不存在負數的 。這個很好理解,因為字串的字元個數肯定是正數。但是,當遇到strlen的加減法時,也要注意這是無符號整型的加減,最後得出的結果不會是負數。

本來strlen(str2)-strlen(str1)這個結果應該是3-6,但在無符號整型中-3寫成二進位制表達是10000000000000000000000000000011沒有符號位,顯然是一個龐大的正數。這是strlen的一個細節,值得注意。

模擬實現strlen函式(原來的strlen返回型別應該是unsigned int此處使用int來返回與原來不一致,但不影響執行)

三種方法:1、計數器法 2、遞迴求解 3、指標減指標

1、計數器法

int my_strlen(const char*str)
{
    //計數器法,字元指標每走一位,計數器加一,一直到'\0'停下
    assert(str);
    int count = 0;
    while (*str != '\0')
    {
        str++;
        count++;
    }
    return count;
}

int main()
{
    char arr[] = "abcd";
    int n=my_strlen(arr);
    printf("%d", n);
    return 0;
}

2、遞迴法

3、指標減指標

模擬實現strlen這個函式是字串函式裡面比較基礎的內容,有助於加深對strlen的理解。

strcmp

strcmp這個函式是用來比較字串的,可以稱為字串比較函式。字串之間的比較不能使用大於小於等於這種數學符號,所以C語言專門規定了一個函式叫strcmp用來比較兩個字串。strcmp這個比較函式接受的引數是字元指標

int strcmp(const char*p1,const char*p2)
//這是他的型別
//返回值是一個整數,第一個字串大於第二個字串,則返回大於0的數字 第一個字串等於第二個字串,則返回0 第一個字串小於第二個字串,則返回小於0的數字

字串的比較並不是比較字串的長度,而是比較字元的ASCII碼值,如果ASCII碼值相同就比較下一個字元的ASCII值,直到比出大小。

上圖展示了strcmp的比較方法,比較字元的ASCII碼值。這裡的編譯器使用了vs2013,預設返回值-1。返回值是一個負數,表示在這兩個函式中第一個字串都小於第二個字串。但是並不是所有編譯器都返回-1這個值,在這種情況下,只要返回值是一個負數,就是合理的。

 模擬實現strcmp函式

 1 int my_strcmp(const char*str1, const char* str2)
 2 {
 3        
 4     assert(str1&&str2);
 5     while (*str1&&*str2 && (*str1 == *str2))
 6     {
 7         //字元出現不相等或者出現字串結束時,進入比較環節
 8         str1++;
 9         str2++;
10     }
11     if (*str1 > *str2)
12         return 1;
13     else if (*str1 < *str2)
14         return -1;
15     else
16         return 0;
17 
18 }

此處沒有寫主函式,這只是一個模擬字串比較函式,寫得較為簡單。基本思想就是利用指標,逐個字元對比ASCII碼值大小。

相應的,對於不是字串的型別也可以在記憶體中進行類似的操作,這時候要用到函式memcmp。(這是記憶體函式並非字串函式)

int memcmp ( const void * ptr1,const void * ptr2,size_t num );

基本模型如上。比較的是ptr1和ptr2指標開始的num個位元組,返回值類似於strcmp,返回大於0的數就是ptr1指向的資料有更大的值,返回0就是前num個位元組相等,返回小於0的數就是ptr1指向的資料在記憶體中值比ptr2所指向的更小。

strcpy,strncpy

strcpy是字串拷貝函式,即將一個字串的內容拷貝到另一個字串中。

char* strcpy(char * destination, const char * source );

這是strcpy的基本模型,返回值型別是字元指標。引數寫的也很清楚,第一個是目的地字串,也就是用來存放拷貝內容的字串,第二個是來源字串,就是把這個字串的內容拷貝到目的地中。

明顯可見,函式呼叫時把arr2的‘\0’也拷貝了過來。這裡要注意的是,來源字串必須以\0’結束,這樣才能被正常拷貝。其次便是,目標空間必須足夠大,目標空間必須可變。

模擬實現strcpy函式

 1 char*my_strcpy(char*dest, const char* src)
 2 {
 3     assert(dest&&src);
 4     char* ret = dest;
 5     while (*src != '\0')
 6     {
 7         *dest = *src;
 8         dest++;
 9         src++;
10     }//迴圈結束,src指向'\0',再把'\0'拷貝進去函式就完成了
11     *dest = *src;
12     return ret;
13 }
14 char*my_strcpy(char*dest, const char* src)
15 {
16     assert(dest&&src);//更為簡潔的寫法
17     while (*dest++ = *src++)//直接在條件裡面賦值
18     {
19         ;
20     }
21 }

strncpy就是把來源字串的前n個字元拷貝到目的字串中,如果來源字串字元個數小於n,拷貝的字元後面自動補0

char* strncpy(char * destination, const char * source ,size_t num);

面對非字串型別的資料,可以用memcpy來進行拷貝(這是記憶體函式並非字串函式)

void * memcpy ( void * destination, const void * source, size_t num )

基本模型如上。這個函式把num個位元組的內容從來源拷貝到目的處。但是函式在遇到‘\0'時並不會停下來。如果來源和目的有任何重疊,這個結果都是未定義的。

整型陣列的拷貝,把來源陣列前12個位元組的資料拷貝過來替換了目的陣列的前3個數字,後面的數字不變。

模擬實現memcpy

void* my_memcpy(void*dest, void* src, int num)
{
    assert(dest&&src);
    void* ret = dest; 
    int i = 0;
    for (i = 0; i < num; i++)
    {
        *(char*)dest = *(char*)src;//每一個位元組進行拷貝
        ((char*)src)++;//void*指標不能進行加減操作,轉成char*指標可以每次移動一個位元組
        ((char*)dest)++;//要在++之前整體加上一個括號,不然指標先和++結合,強制型別轉換無效
    }
    return ret;

}

當出現記憶體重疊,有時候不能使用memcpy函式,這時候就有函式memmove可以使用(這是記憶體函式並非字串函式)

模擬實現memmove

 1 void* my_memmove(void* dest, void* src, int count)
 2 {
 3     assert(dest&&src);
 4     void* ret = dest;
 5     if (dest < src)//分析從前向後拷貝還是從後向前拷貝
 6         //如果dest在src前面只能從前向後拷貝,和memcpy類似
 7         //dest在src後面且dest<src+count只能從後向前拷貝(當然void*不能進行加減,此處只是註釋而已)
 8     {
 9         while (count--)
10         {
11             *(char*)dest = *(char*)src;
12             ((char*)src)++;
13             ((char*)dest)++;
14         }
15     }
16     else
17     {
18         while (count--)
19         {
20             *(((char*)dest) + count - 1) = *(((char*)src) + count - 1);
21         }
22     }
23     return ret;
24 
25 }
26 int main()
27 {
28     int arr1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
29     my_memmove(arr1 , arr1+2, 16);
30     int i = 0;
31     for (i = 0; i < 9; i++)
32     {
33         printf("%d ", arr1[i]);
34     }
35     return 0;
36 }

 

 

 

strcat、strncat

strcat是字串追加函式,就是將來源字串追加到目的字串的‘\0'之後(目的字串的‘\0'被替換成來源字串首字元),追加這個過程一定程度上類似於拷貝,也就是把來源字串拷貝到了目的字串的後面。同樣的要注意,目的字串必須足夠大,目的字串也必須可變。來源字串要以‘\0'結束。這幾點和剛才的strcpy一樣。

特別地,strcat不能用來自身追加,因為這個函式需要先找到目的字串的‘\0’,然後進行類似於拷貝的操作。如果用於自身追加,‘\0'在拷貝時候被替代,這也就等同於來源字串被改變了,此時來源字串也就不是以'\0'結束,追加便出現問題了。

模擬實現strcat函式

char*my_strcat(char*dest, const char* src)
{
    assert(dest&&src);
    char* ret = dest;
    while (*dest != '\0')
    {
        dest++;
    }//先找到目的字串中的'\0'
    while (*dest++ = *src++)
    {
        ;
    }//追加字串,此操作同strcpy
    return ret;
}

strncat是追加來源字串的前n個字元,變化類似於剛才 的strcpy和strncpy。

strstr

strstr是搜尋子字串的函式。

char*strstr(const char*str1,const char*str2)

函式基本模型如上。函式返回型別是char*也就是一個指標。當str2不是str1的字串時,就返回空指標。當存在子串時,返回的是第一個字串的首字元地址。

模擬實現strstr

 1 char*my_strstr(const char*str1, const char* str2)
 2 {
 3     assert(str1&&str2);
 4     char*cur = (char*) str1;
 5     char*s1 = (char*)str1;
 6     char*s2 = (char*)str2;
 7     //使用cur指標來記錄首字元相同的地址
 8     //建立s1和s2變數是為了和cur指標不發生衝突
 9     while (*cur)
10     {
11         s1 = cur;
12         s2 = (char*)str2;
13         while (*s1&&*s2 && (*s1==*s2))
14         {
15             s1++;
16             s2++;
17         }
18         if (*s2 == '\0')
19             return cur;
20         cur++;
21     }
22     return NULL;
23     //這種寫法保證了出現重複字元時也能正確找到子串
24 
25 
26 }
27 int main()
28 {
29     char arr1[20] = "aabbbccdd";
30     char arr2[] = "bbc";
31     char*ret=my_strstr(arr1, arr2);
32     printf("%s", ret);
33     return 0;
34 }

strtok

strtok是用來提取被分割的字串的。函式模型如下

char*strtok(char*str,const char* sep)

第一個引數是被操作的原字串,第二個引數是分隔符形成的字串。

strtok會找到原字串中的下一個標記,然後用'\0'結尾,然後返回一個指向這個標記的指標。

當函式的第一個引數不是NULL時,strtok會查詢第一個標記,並且儲存這個標記的位置。當函式第一個引數是NULL時,strok從被儲存位置開始查詢下一個標記。當字串不存在更多標記時,會返回NULL。

以上描述比較抽象,不大好理解,可以看以下程式碼。

 

    
int main()
{
    char arr[] = "abc@def.ghi";
    char*p = "@.";
    char buf[1024] = { 0 };
    strcpy(buf, arr);
    char*ret = NULL;
        char *ret = strtok(arr, p);//第一次使用函式,找到@將其變為'\0'然後返回a的地址,列印字串
    printf("%s\n", ret);
    ret = strtok(NULL, p);//第二次使用函式,找到剛才的儲存位置,尋找下一個標記 .將其變成'\0'然後返回d的地址,列印字串
    printf("%s\n", ret);
    ret = strtok(NULL, p);//第三次使用函式,找到剛才的儲存位置,尋找下一個標記,找到‘\0',列印字串
    printf("%s\n", ret);
        return 0;
}

當然實際上不會這麼寫程式碼,因為這樣必須知道分隔符個數,要知道呼叫幾次函式。可以用for迴圈來實現

int main()
{
    char arr[] = "abc@def.ghi";
    char*p = "@.";
    char buf[1024] = { 0 };
    strcpy(buf, arr);
    char*ret = NULL;
    for (ret = strtok(arr, p); ret != NULL; ret = strtok(NULL, p))
    {
        
//巧妙在於第一步初始化ret的值,for迴圈進來只用一次初值,而正好strtok(arr,p)只用一次
//判斷條件是ret不返回空指標,如果返回空指標就說明字串不存在更多標記了,不用繼續往下迴圈了
//每走完一次迴圈ret值都會變化,也就是去查詢下一處標記
            printf("%s\n", ret);
    }
return 0;
}

 strerror

這個函式是用來判斷錯誤的,返回相應的錯誤碼

char* strerror(int num)//引數是錯誤碼

這是函式的基本模型,一般會用到errno來判斷錯誤碼。要引用標頭檔案<errno.h>

strerror(errno)

寫法如上。

 

相關文章