【C语言】——字符串函数的使用与模拟实现（上）

【C语言】——字符串函数

• • 前言
  • 一、 s t r l e n strlen strlen 函数
  • • 1.1、函数功能
    • 1.2、函数的使用
    • 1.3、函数的模拟实现
    • • （1）计数法
      • （2）递归法
      • （3）指针 - 指针
      • 二、 s t r c p y strcpy strcpy 函数
      • • 2.1、函数功能
        • 2.2、函数的使用
        • 2.3、函数的模拟实现
        • 三、 s t r c n t strcnt strcnt 函数
        • • 3.1、函数功能
          • 3.2、函数的使用
          • 3.3、函数的模拟实现
          • 四、 s t r c m p strcmp strcmp 函数
          • • 4.1、函数功能
            • 4.2、函数的使用
            • 4.3、函数的模拟实现

              前言

                在我们学习 C语言 的过程中，对库函数的使用是必不可少的。其中，相信大家最熟悉的就是 中的 p r i n t print print 和 s c a n f scanf scanf 函数了吧。

                但是今天，我们不讲他们（太难了,呜呜呜），今天我们来讲与字符串相关的函数，也就是 中的系列函数。

                要知道，除了输入输出，我们对字符串的操作也是必不可少的，那么了解字符串相关的函数的重要性就不言而喻了，让我们开启接下来的学习吧。

              一、 s t r l e n strlen strlen 函数

              1.1、函数功能

              • 函数声明：size_t strlen(const char* str);
              • s t r l e n strlen strlen 函数用于求字符串的长度，使用时必须包含头文件
              • 基本原理是：从传递的指针变量开始，从前往后计算字符的个数，直到遇到 ‘

                1.2、函数的使用

                ’ 停止（ ‘

                #include#includeint main(){char* a = "abcdef";int sz = strlen(a);printf("%d\n", sz);return 0;}

                ’ 本身不计算），因此参数指向的字符串必须要以 ‘

                1.3、函数的模拟实现

                ’ 结束。
              • 返回值为字符串的长度，注意：返回值是 size_t 类型（易错）

                  

                （1）计数法

                  

                   s t r l e n strlen strlen 函数的使用非常简单，这里就不过多介绍了，大家直接看代码

                #includesize_t my_strlen(const char* str){//assert断言，防止传入空指针assert(str);int count = 0;//判断条件：指针指向的字符是否为0（'
                （2）递归法
                '）while (*str){count++;str++;}return count;}

                 

                运行结果：

                 

                #includesize_t my_strlen(const char* str){assert(str);if (!*str)//逻辑取反，当*str为0时为假，逻辑取反为真return 0;elsereturn 1 + my_strlen(str + 1);}

                （3）指针 - 指针

                  首先，我们要知道指针存储的是字符串首字符的地址。该方法的思路是将传入的字符指针不断往后移，每移一次计数器加一，当指针指向 ‘\0’ 时，结束计数，并返回计数的值。

                  

                代码实现：

                #includesize_t my_strlen(const char* str){assert(str);char* p = str;while (*p++){;}return p - str - 1;}

                 

              • *arr++：这里有两个操作符： ∗ * ∗ 和 后置++。 虽然后置++ 的优先级比 ∗ * ∗ 高，但是他是后置的，所以先进行解引用

                

                有没有办法在求出字符串长度的同时不创建临时变量呢？我们可以试试递归的思想

                那用递归的思想来计算字符串的长度，解题思路是什么呢？

                我们不妨想：比如要计算 “ a b c abc abc” 的长度，是不是可以将他看成 1 + 1+ 1+“ b c bc bc” 的长度，而 “ b c bc bc” 的长度，又可以将他看成是 1+“ c c c” 的长度。

                

                怎么样，你想到了吗？

                

              代码实现：

              • 解引用完成后，结果为真则进入循环，为假退出循环

                

              • 无论 * a r r arr arr 结果为真为假，接下来 a r r arr arr 进行自增操作。注：++ 操作数是 a r r arr arr，而非 * a r r arr arr，如果想让 * a r r arr arr 自增，应写为：*(arr)++

                

                还有一个方法就是指针 - 指针，首先我们知道，指针 - 指针，代表的是两指针之间的元素个数（详情请看：【C语言】—— 指针一 ： 初识指针（上））

                

                我们可以利用这个思想，创建一个指针变量，让他不断移动，直至指向 '\0' ，再通过两个指针相减，得到字符串的长度。

                

              代码实现：

              • 因为循环不需要再执行任何操作，因此放置空语句

              代码解析：

                

                while (*arr++);可能这句代码有些小伙伴不太了解，没关系，我们一起来看看

              二、 s t r c p y strcpy strcpy 函数

              2.1、函数功能

              • 源字符串必须以 ‘
              • 该函数会将 ‘
              • 目标空间必须足够大，以确保能存放源字符串，否则会出现越界访问的情况
              ’ 拷贝到目标空间’ 结束
              • 目标空间必须是可修改的
              • return arr - str - 1;因为前面循环的判断条件不论真假， a r r arr arr 都会自增，即指针指向 ‘\0’ 后依然会往后移动一位，此时如果直接arr - str，则把 ‘\0’ 也计算在内，而 s t r l e n strlen strlen 是不计算

                ‘\0’ 的，因此最终要 - 1

                  

                int main(){char arr1[] = "abcdef";char arr2[20] = { 0 };arr2 = arr1;return 0;}

                2.2、函数的使用

                功能： s t r c p y strcpy strcpy 函数实现的是字符串的拷贝，将 s o u r c e source source 指针指向的字符串(源字符串) 拷贝到 d e s t i n a t i o n destination destination 指针指向的字符串(目标字符串) 中。

                #include#includeint main(){char src[20] = "good good study";char dest[40] = { 0 };char* s = strcpy(dest, src);printf("%s\n", s);return 0;}

                2.3、函数的模拟实现

                char* my_strcpy(char* dest, const char* src){    //要返回目标空间的地址char* ret = dest;//不能传入空指针assert(dest != NULL);assert(src != NULL);//拷贝'
                char* my_strcpy(char* dest, const char* src){char* ret = dest;assert(dest && src);while (*dest++ = *src++){;}return ret;}
                '之前的内容while (*src != '
                虽然两个 后置++ 的优先级最高，但是因为是后置：先使用，后++
                '){*dest = *src;dest++;src++;}//拷贝'
                首先执行的是两个解引用操作
                '*dest = *src;return ret;}

                • 解引用完成后，将 * s r c src src 的值赋给 * d e s t dest dest
                • 函数的返回值为指向目标空间的指针

                    

                    可能会有小伙伴说，字符串的拷贝哪有那么麻烦，还要用函数，不就是直接赋值吗？

                • 赋值完成后进行循环的条件判断，* d e s t dest dest == ‘

                  三、 s t r c n t strcnt strcnt 函数

                  ’ 则退出循环，否则执行循环

                  这样可以吗？当然是不可以的。为什么呢？

                  

                  别忘了 a r r 1 arr1 arr1 和 a r r 2 arr2 arr2 是两个数组首元素的地址，地址是一个常量值并不是变量，就像：5 = 3;，可以把 3 赋值给 5 吗？肯定是不行的。因此字符串的赋值并没有那么简单哦。

                  

                3.1、函数功能

                  

                • 源字符串必须以 ‘
                • 追加会将目标空间原来的 ‘
                • 目标字符串结尾也要有 ‘
                • 目标空间必须足够大，能容下追加源字符串之后的内容
                ’，否则不知从哪开始追加’ 覆盖’ 结束

                  

                运行结果：

                  

                • 目标空间必须可修改

                  要模拟实现 s t r c p y strcpy strcpy 函数，其实思路很简单，只需将字符串的中的每个字符依次拷贝过去即可，当拷贝完源字符串的 '\0' ，拷贝结束。

                  

                  我们来尝试写下代码：

                • 返回的是目标空间的起始地址

                  

                  上述代码基本上是没问题的，但大家发现没有，该代码有点繁琐：*dest = *src;就出现了两次，有什么改进方法呢？我们来看下面的代码：

                  

                3.2、函数的使用

                  

                这里，我们重点来讲解一下while (*dest++ = *src++);语句

                #include#includeint main(){char src[20] = "day day up!";char dest[40] = "good good study! ";char* s = strcat(dest, src);printf("%s\n", s);return 0;}

                3.3、函数的模拟实现

                char* mu_strcat(char* dest, const char* src){char* ret = dest;assert(dest && src);        //找到目标空间的末尾while (*dest){dest++;}    //进行追加（拷贝）while (*dest++ = *src++){;}return ret;}

                四、 s t r c m p strcmp strcmp 函数

                • 最后 d s e t dset dset 和 s r c src src 两个指针执行++，即自增

                    

                  怎么样，这段代码是不是很巧妙呢

                    

                    

                  4.1、函数功能

                  功能： s t r c a t strcat strcat 函数的功能是实现字符创的追加，将源字符串的内容追加到目标字符串的结尾。

                  • 目标空间与源字符串不能重叠，即不能自己给自己追加

                      

                      

                      

                    运行结果：

                      

                      

                       s t r c a t strcat strcat 函数怎么模拟实现呢？大家不妨想一想，追加不也是一种拷贝吗，它的实现方法与 s t r c p y strcpy strcpy 函数的实现很像，只是 s t r c p y strcpy strcpy 是从头开始拷贝，而 s t r c a t strcat strcat 是从目标字符串的末尾开始拷贝。

                      

                    参考代码：

                      

                      

                    功能：比较两个字符串的大小

                        s t r 1 str1 str1 > s t r 2 str2 str2 ，返回 > 0 >0 >0 的数字

                        s t r 1 str1 str1 = s t r 2 str2 str2 ，返回 0 0 0

                        s t r 1 str1 str1 char str1[] = "abcd";char str2[] = "Abcd";char str3[] = "abcd";char str4[] = "bbcd";int ret1 = strcmp(str1, str2);//比较str1与str2int ret2 = strcmp(str1, str3);//比较str1与str3int ret3 = strcmp(str1, str4);//比较str1与str4printf("%d %d %d\n", ret1, ret2, ret3);return 0;} //接下来要对指针进行解引用，因此不能传入空指针assert(str1 && str2); //相同位上两个字符相等，进入循环while (*str1 == *str2){ //当两个字符都为'\0'时，也进入了循环，遇到'\0'表示字符串结束 //因为相等才能进入循环，判断语句因此只用写一个if (*str1 == '\0'){return 0;}str1++; str2++;} //不相等，返回两个字符的ASCII码的差值return *str1 - *str2;}