【C進階】鵬哥帶你玩轉 · 字元串和記憶體函數

大家好，我是安然無虞。

目錄

​​一、常見字元串庫函數介紹​​

​​1、strlen()​​

​​自定義函數模拟實作strlen​​

​​2、strcpy()​​

​​自定義函數模拟實作strcpy​​

​​3、strcat()​​

​​自定義函數模拟實作strcat​​

​​4、strcmp()​​

​​自定義函數模拟實作strcmp​​

​​5、strncpy()​​

​​6、strncat()​​

​​7、strncmp()​​

​​8、strstr()​​

​​自定義函數模拟實作strstr​​

​​9、strtok()​​

​​10、strerror()​​

​​二、字元分類函數​​

​​三、常見記憶體操作函數​​

​​1、memcpy()​​

​​自定義函數模拟實作memcpy​​

​​2、memmove()​​

​​自定義函數模拟實作memmove​​

​​3、memcmp()​​

​​4、memset()​​

​​四、遇見安然遇見你，不負代碼不負卿。​​

前言：

前段時間狀态不好，是以已經有24天沒有更新了，打開手機有很多鐵子的消息沒有及時回複，這幾天正在陸陸續續回，實在抱歉，感謝大家的支援與陪伴，現在的話我正開始慢慢追，一起加油。 

一、常見字元串庫函數介紹

C語言中對字元和字元串的操作處理很是頻繁，但是C語言本身是沒有字元串類型的，是以C語言中的字元串通常放在常量字元串中或者字元數組中；

字元串常量适用于那些對它不作任何修改的字元串函數。

本章重點：

求字元串長度

• strlen

長度不受限制的字元串庫函數

• strcpy
• strcat
• strcmp

長度受限制的字元串庫函數

• strncpy
• strncat
• strncmp

字元串查找

• strstr
• strtok

錯誤資訊報告

• strerror

字元操作庫函數

記憶體操作庫函數

• memcpy
• memmove
• memset
• memcmp

注意：

長度不受限制表示的是一直追加到 '\0' ，跟長度無關；

長度受限制表示跟長度有關，可能這樣說不好了解，别擔心，看到後面你就明白了。 

1、strlen()

函數原型：

函數功能：

求字元串的長度 

注意：傳回值類型是 size_t，這 size_t 到底是什麼？

其實 size_t 是為 sizeof 操作符傳回值設計的，可以淺顯的認為 size_t 就是我們熟知的 unsigned int ，因為是求長度，是以肯定不會是負數，故而使用無符号整型，但是由此也容易産生 bug，請看下面代碼：

解讀下面代碼，請問輸出結果是什麼：

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

int main()
{
  if (strlen("abc") - strlen("abcdef") > 0)
    printf(">");
  else
    printf("<=");
  return 0;
}      

沒錯，答案是輸出 ">"，為什麼呢？3 - 6 = -3鴨，這是怎麼回事？

這是因為strlen的傳回值是 size_t ，屬于無符号數，是以兩個無符号數相減，答案一定是無符号數，如果大家還是不明白的話，可以看看這篇文章，說的很清楚哦。

深度剖析資料在記憶體中的存儲

那怎麼修改呢？

方案一：強制類型轉換

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

int main()
{
  if ((int)strlen("abc") - (int)strlen("abcdef") > 0 )
    printf(">");
  else
    printf("<=");
  return 0;
}      

方案二：直接比較

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

int main()
{
  if (strlen("abc") > strlen("abcdef"))
    printf(">");
  else
    printf("<=");
  return 0;
}      

注意：

• 字元串以 '\0' 作為結束标志，strlen 傳回的是在字元串中 '\0' 之前的字元個數（不包括'\0'）;
• 參數中指向的字元串必須以 '\0' 結束；
• 注意strlen函數的傳回值是 size_t 類型，屬于無符号類型（特易錯）

代碼示例：

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

int main()
{
    int len = strlen("abcdef");
    printf("%d\n", len);

    return 0;
}      

自定義函數模拟實作strlen

【手把手帶你刷LeetCode】——18.自定義函數實作strlen()功能（作業）_安然無虞的部落格部落格今天是力扣打卡第18天！這道題并不是力扣上面的題目，而是一道作業，鵬哥說很重要，我便把它整理成一篇小博文了。原題：自定義函數實作strlen()功能先讓我們感受一下strlen()函數：#include<stdio.h>#include<string.h>int main(){char arr[] = "abcdefghij";printf("%d\n", strlen(arr));//輸出10return 0;}strlen().

1. 計數器的方法
2. 遞歸的方法
3. 指針 - 指針

方法一：計數器的方法

int my_strlen(const char* str)
{
  assert(str);//斷言str非空
  int count = 0;
  while (*str != '\0')
  {
    count++;
    str++;
  }
  return count;
}      

方法二：遞歸的方法

int my_strlen(const char* str)
{
  assert(str);//斷言str非空
  //找邊界
  if (*str == '\0')
  {
    return 0;
  }
  int count = my_strlen(str + 1);
  //注意str++和str+1是不同的概念
  count++;
  return count;
}      

這裡需要注意的是，str++ 和 str+1 不是一個概念，str++是先使用後++，本題可以寫成++str的形式，先++再使用。

方法三：指針 - 指針

指針-指針其實表示的是兩個指針中間的元素個數，注意哦，不是中間有幾個位元組。

int my_strlen(const char* str)
{
  assert(str);
  const char* cur = str;
  while (*cur != '\0')
  {
    cur++;
  }
  return cur - str;
}      

2、strcpy()

函數原型：

函數功能： 

 将源字元串拷貝到目标字元串，傳回目标字元串首元素的位址。 

解讀下列代碼：

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

int main()
{
  char arr1[] = "abcdef";
  char arr2[20] = { 0 };
  printf("%s\n", strcpy(arr2, arr1));

  return 0;
}      

本題是将字元串 arr2 拷貝給字元串 arr1 ，傳回的是 arrr2 首元素的位址（目标字元串首元素的位址）。是以上面代碼輸出的是：abcdef，那麼這裡的問題是，會不會将字元串arr1中的 '\0' 拷貝給字元串 arr2 ，是以這裡用以下代碼驗證這個問題：

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

int main()
{
  char arr1[] = "abcdef";
  char arr2[20] = "XXXXXXXXXX";
  printf("%s\n", strcpy(arr2, arr1));

  return 0;
}      

首先，還沒有将字元串 arr1 拷貝給 arr2 時，它們存放的資料是這樣的：

當執行 strcpy(arr2, arr1) 完後，此時 arr2 中存放的資料是這樣的：

可以看到，将字元串 arr1（源字元串） 拷貝給字元串 arr2（目标字元串） 時會自動将源字元串末尾的 '\0' 拷貝過去，傳回的是目标字元串起始位置的位址。

這裡又有一個問題是：如果源字元串末尾沒有加上 '\0' （這裡用字元數組的形式示範，正常的字元串末尾會自動填充 '\0'），請看如下代碼：

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

int main()
{
  char arr1[] = { 'a','b','c','d','e','f' };
  char arr2[20] = "XXXXXXXXXX";
  
  printf("%s\n", strcpy(arr2, arr1));
  return 0;
}      

代碼執行結果：

是以需要注意的是：如果想将源字元串拷貝給目标字元串，那麼就要保證源字元串中是包含 '\0' 的，否則會拷貝失敗。 

是以，使用 strcpy 拷貝字元串是需要注意以下幾點：

• 源字元串必須以 '\0' 結束；
• 拷貝時會将源字元串中的 '\0' 一同拷貝給目标字元串；
• 目标字元串（目标空間）必須足夠大，以確定能存放源字元串 ；
• 還有一點就是，目标字元串必須是可以改變的

請看下面的代碼：

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

int main()
{
  char arr1[] = "abcdef";
  const char* p = "XXXXXXXXXX";
  printf("%s\n", strcpy(p, arr1));
  return 0;
}      

執行程式是錯誤的，因為此時的目标字元串是被 const 修飾的，是不可以修改的。 

自定義函數模拟實作strcpy

【手把手帶你刷好題】——22.面試題：模拟實作strcpy庫函數（非力扣）_安然無虞的部落格-CSDN部落格【前言】今天是刷題打卡第22天！這是一道很好的題目哦，裡面有一些很好的coding技巧，要留心看哦。原題：模拟實作strcpy庫函數OK，廢話不多說，直接上代碼...初級代碼：滿分10分---得5分#include<stdio.h>void my_strcpy(char* dest, char* src){while (*src != '\0'){*dest = *src;dest++;src++;}*dest =代碼執行： 

char* my_strcpy(char* dest, const char* src)
{
  char* ret = dest;
  assert(dest && src);
  while (*dest++ = *src++)//很妙
  {
    ;
  }
  return ret;
}      

3、strcat()

函數原型：

函數功能： 

将源字元串追加到目标字元串的後面，傳回目标字元串首字元的位址 

解讀下列代碼：

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

int main()
{
  char arr1[30] = "hello";
  char arr2[] = "world";

  strcat(arr1, arr2);
  printf("%s\n", arr1);
  return 0;
}      

以上代碼是将 "world" 拼接到 "hello" 的後面，是以列印結果如下：

其實，使用 strcat 庫函數的注意事項與 strcpy 是十分相似的，在這裡的話我就不重複解釋了：

• 源字元串必須以 '\0' 結束；
• 目标空間必須足夠大，能容納下源字元串的内容；
• 目标空間必須可變。

那麼試想：如果讓我們自己實作 strcat 函數，該怎麼做呢？先想一下大緻思路，我們首先要找到目标字元串的結束标志'\0'，然後将源字元串拼接到目标字元串的後面，最後傳回目标字元串的首字元的位址，看起來好像挺簡單的，那我們實作一下：

自定義函數模拟實作strcat

代碼執行：

char* my_strcat(char* dest, const char* src)
{
  char* ret = dest;
  assert(dest && src);
  //1、找到目标字元串的\0
  while (*dest)//注意循環條件寫成*dest++是錯誤的，因為會跳過\0，請細品
  {
    dest++;
  }
  //2、拷貝源字元串
  while (*dest++ = *src++)
  {
    ;
  }
  return ret;
}      

4、strcmp()

函數原型：

函數功能： 

比較對應位置上字元的字典序 

标準規定：

• 第一個字元串 > 第二個字元串，則傳回大于0的數字；
• 第一個字元串 == 第二個字元串，則傳回0；
• 第一個字元串 < 第二個字元串，則傳回小于0的數字。

敲黑闆：

兩個字元串不能直接進行比較，也不能直接進行相加相減運算，因為字元串表示的是首字元的位址。也就是說，如果直接進行比較的話，比的不是字元串的内容，而是位址，是以是錯誤的。 

自定義函數模拟實作strcmp

代碼執行：

int my_strcmp(const char* str1, const char* str2)
{
  assert(str1 && str2);
  while (*str1 == *str2)//注意是在循環體中判斷相等的情況，想想為什麼
  {
    if (*str1 == '\0')
      return 0;
    str1++;
    str2++;
  }
  if (*str1 > *str2)//return *str1 - *str2;
    return 1;
  else
    return -1;
}      

5、strncpy()

函數原型：

看下面一段代碼：

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

int main()
{
  char arr1[] = "xxxxxxxxxxxxxx";
  char arr2[] = "hello world";
  strncpy(arr1, arr2, 5);
  printf("%s\n", arr1);
  return 0;
}      

這樣的函數相對來說更加安全，更加可控靈活一些。 

6、strncat()

函數原型：

看一段代碼：

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

int main()
{
  char arr1[20] = "hello\0xxxxx";
  char arr2[] = "world";
  strncat(arr1, arr2, 3);
  printf("%s\n", arr1);
  return 0;
}      

從上面我們能看出，追加完後會自動填充 '\0' ，而且是追加到目标字元串中第一個 '\0' 的後面。

7、strncmp()

函數原型：

看下面一段代碼：

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

int main()
{
  char arr1[] = "acbdef";
  char arr2[] = "abcdef";
  int ret = strncmp(arr1, arr2, 3);
  printf("%d\n", ret);
  return 0;
}      

注意：以上代碼比較的是字元串的前三個字元，而不是第三個字元。

8、strstr()

函數原型：

傳回值： 

函數功能：

查找字元串

看一下下面的代碼：

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

int main()
{
  char arr1[] = "abcdef";
  char arr2[] = "bcd";

  char* ret = strstr(arr1, arr2);

  if (NULL == ret)
    printf("沒找到\n");
  else
    printf("%s\n", ret);
  return 0;
}      

自定義函數模拟實作strstr

代碼執行：

char* my_strstr(const char* str, const char* substr)
{
  const char* s1 = str;
  const char* s2 = substr;
  const char* cur = str;

  assert(str && substr);
  //特殊情況
  if (*substr == '\0')
    return (char*)str;
  while (*cur)
  {
    s1 = cur;
    s2 = substr;
    while (*s1 && *s2 && *s1 == *s2)//注意*s1!='\0&&*s2!='\0
    {
      s1++;
      s2++;
    }
    if (*s2 == '\0')
      return (char*)cur;
    cur++;
  }
  return NULL;
}      

9、strtok()

函數原型：

使用前注意事項：

• sep參數是個字元串，定義了用作分隔符的字元集合；
• 第一個參數指定一個字元串，它包含了0個或者多個由sep字元串中一個或者多個分隔符分割的标記 ；
• strtok函數找到str中的下一個标記，并将其用 '\0' 結尾，傳回一個指向這個标記的指針。（注：strtok函數會改變被操作的字元串，是以在使用strtok函數切分的字元串一般都是臨時拷貝的内容并且可修改）；
• strtok函數的第一個參數不為NULL時，函數将找到str中的第一個标記，strtok函數将儲存它在字元串中的位置；
• strtok函數的第一個參數為NULL時，函數将在同一個字元串中被儲存的位置開始，查找下一個标記；
• 如果字元串中不存在更多的标記，則傳回NULL指針

也可以這樣說：

• strtok函數找第一個标記的時候，函數的第一個參數不是NULL；
• strtok函數找非第一個标記的時候，函數的第一個參數是NULL

看下面一段代碼：

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

int main()
{
  const char* p = "@.";
  char arr[] = "[email protected]";
  char buf[50] = { 0 };//作為臨時拷貝
  strcpy(buf, arr);
  char* str = strtok(buf, p);
  printf("%s\n", str);//zpengwei
  str = strtok(NULL, p);
  printf("%s\n", str);//yeah
  str = strtok(NULL, p);
  printf("%s\n", str);//net
  return 0;
}      

不過這樣使用看起來太繁瑣了，看看下面的改進代碼：

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

int main()
{
  const char* p = "@.";
  char arr[] = "[email protected]";
  char buf[50] = { 0 };//作為臨時拷貝
  strcpy(buf, arr);
  char* str = NULL;
  for (str = strtok(buf, p); str != NULL; str = strtok(NULL, p))
  {
    printf("%s\n", str);
  }
  //char* str = strtok(buf, p);
  //printf("%s\n", str);//zpengwei
  //str = strtok(NULL, p);
  //printf("%s\n", str);//yeah
  //str = strtok(NULL, p);
  //printf("%s\n", str);//net
  return 0;
}      

10、strerror()

函數原型：

傳回值：

函數功能：

傳回錯誤碼所對應的錯誤資訊

看下面這段代碼：

//C語言可以操作檔案
//打開檔案 - fopen

//當庫函數使用的時候，發生錯誤會把errno這個全局的錯誤變量設定為本次執行庫函數産生的錯誤碼
//errno是C語言提供的一個全局變量，可以直接使用，放在errno.h檔案中的
#include<stdio.h>
#include<errno.h>
#include<string.h>
int main()
{
  //打開檔案
  FILE* pf = fopen("test.txt", "r");
  if (NULL == pf)
  {
    //出錯誤的原因是什麼
    printf("%s\n", strerror(errno));
    return 0;
  }
  //讀檔案
  //...

  //關閉檔案
  fclose(pf);
  pf = NULL;
  return 0;
}      

常見字元串庫函數終于講解完了，換換心情。

二、字元分類函數

使用字元操作函數需要注意的是頭檔案為ctype.h

下面函數比較簡單，就不詳細介紹了。

字元轉換：

• int tolower(int c)
• int toupper(int c)

代碼示例：

#include<stdio.h>
#include<ctype.h>

int main()
{
  char ch = 0;
  ch = getchar();
  if (islower(ch))
    ch = toupper(ch);
  else
    ch = tolower(ch);

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

  return 0;
}      

三、常見記憶體操作函數

1、memcpy()

函數原型：

注意哦，記憶體操作函數中的第三個參數機關是位元組。

想想為什麼是void*類型？

因為設計者在設計這個庫函數的時候不知道會用來拷貝何種類型，是以隻有設計成void*最合适。 

看下面一段代碼：

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

int main()
{
  int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
  int arr2[5] = { 0 };
  memcpy(arr2, arr1 + 5, 5 * sizeof(arr1[0]));

  int i = 0;
  for (i = 0; i < 5; i++)
  {
    printf("%d ", arr2[i]);
   }
  return 0;
}      

自定義函數模拟實作memcpy

代碼執行： 

void* my_memcpy(void* dest, const void* src, size_t num)
{
  void* ret = dest;//注意傳回類型是void*,而不是void，
  assert(dest && src);
  while (num--)//先使用，後--
  {
    *(char*)dest = *(char*)src;//想想為什麼強制類型轉換成char*，因為隻有它最合适
    dest = (char*)dest + 1;//注意直接進行dest++,src++是錯誤的，因為它是空類型
    src = (char*)src + 1;
  }
  return ret;
}      

2、memmove()

函數原型：

其實C語言隻要求：

memcpy能拷貝不重疊的記憶體空間就可以了，memmove去處理那些重疊的記憶體拷貝，也就是說，如果記memcpy的功能是A，那麼memmove的功能就是A+B 

那麼何為重疊的記憶體拷貝呢，請看下面一段代碼：

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

int main()
{
  int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
  
  memmove(arr1 + 2, arr1, 5 * sizeof(arr1[0]));//處理同一塊空間時會發生重疊記憶體拷貝

  int i = 0;
  for (i = 0; i < 10; i++)
  {
    printf("%d ", arr1[i]);
   }
  return 0;
}      

自定義函數模拟實作memmove

代碼執行：

void* my_memmove(void* dest, const void* src, size_t num)
{
  void* ret = dest;
  assert(dest && src);
  if (dest < src)//從前向後拷貝
  {
    while (num--)
    {
      *(char*)dest = *(char*)src;
      dest = (char*)dest + 1;
      src = (char*)src + 1;
    }
  }
  else//從後向前拷貝
  {
    //src = (char*)src + num - 1;//注意一定要-1
    //dest = (char*)dest + num - 1;
    //while (num--)
    //{
    //  *(char*)dest = *(char*)src;
    //  dest = (char*)dest - 1;
    //  src = (char*)src - 1;
    //}
    while (num--)//先使用，後--，在循環體中是--後的num（真的妙）
    {
      *((char*)dest + num) = *((char*)src + num);
    }
  }
  return ret;
}      

3、memcmp()

函數原型：

 傳回值：

 比較簡單，看一下下面的代碼：

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

int main()
{
  int arr1[] = { 1,2,7,4,5 };
  int arr2[] = { 1,2,3,4,5 };
  int ret = memcmp(arr1, arr2, 9);

  printf("%d\n", ret);
  return 0;
}      

4、memset()

函數原型：

函數參數：

 函數功能：

以位元組為機關設定記憶體 

看下面一段代碼：

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

int main()
{
  char arr[20] = { 0 };
  memset(arr, 'x', 10);
  printf("%s\n", arr);
  return 0;
}      

也可以對整型進行操作，不過因為是對記憶體進行操作，是以要考慮到大小端位元組序的問題，如果大家忘記了何為大小端，可以看看這篇文章：

【手把手帶你刷好題】——27.大小端位元組序判斷（非力扣，百度筆試題）_安然無虞的部落格【前言】今天是刷題打卡第27天！感謝的陪伴，你們的認可就是我最大的動力，抱拳了哈！！大小端引入看一下下面這段代碼：#include<stdio.h>int main(){int a = 0x11223344;return 0;}在記憶體中存儲的順序不對呀，這是為什麼？這裡就要介紹大小端了。什麼是大端小端？大端位元組序存儲：當一個資料的低位放到高位址處，資料的高位放到低位址處；小端位元組序存儲：當一個資料的低位放到低位址處，數

四、遇見安然遇見你，不負代碼不負卿。

萬字博文，原創不易。