目录

​​1.strlen​​

​​2.strcpy​​

​​3.strcat​​

​​4.strcmp​​

​​5.strstr​​

​​6.memcpy​​

​​7.memmove​​

前言

C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在常量字符串 中或者 字符数组中。字符串常量适用于那些对它不做修改的字符串函数。

1.strlen

头文件： #include <string.h>

作用：字符串已经 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前面出现的字符个数（不包含 '\0' )。
 

注意要点：

1、参数指向的字符串必须要以 '\0' 结束。

2、注意函数的返回值为size_t，是无符号的（ 易错 ）。

练习：

#include <string.h>
//int main()
//{
//  int len = strlen("abcdef");
//  printf("%d\n", len);
//  return 0;
//}

运行结果：6

1.1 strlen模拟实现

#include <assert.h>
int my_strlen(const char* str)
{
  assert(str);
  int count = 0;
  while (*str != '\0')
  {
    count++;
    str++;
  }
  return count;
}

int main()
{
  int len = my_strlen("abcdef");
  printf("%d\n", len);
  return 0;
}

运行结果： 6

注：模拟实现strlen有多种方法，这里的方法是最简单的计数器方法。

1.计数器的方法

2.递归的方法

3.指针-指针

4.调试

2.strcpy

头文件：#include <stdio.h>

作用：将源字符串拷贝到目标空间中。

注意要点：

1、源字符串必须以 '\0' 结束。

2、会将源字符串中的 '\0' 拷贝到目标空间。

3、目标空间必须足够大，以确保能存放源字符串。

4、目标空间必须可变。

练习:

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

结果：abcdef

2.2 strcpy模拟实现

char* my_strcpy(char* dest,const char* src)
{
  char* ret = dest;
  assert(dest && src);
  while (*dest++ = *src++)
  {
    ;
  }
  return ret;
}
int main()
{
  char arr1[] = "abcdef";
  char arr2[20] = "XXXXXXXXXX";
  my_strcpy(arr2, arr1);
  printf("%s\n", arr2);
  return 0;
}

运行结果：abcdef

3.strcat

头文件：#include <stdio.h>

作用：将源字符串追加到目标字符串后

注意要点：

1、源字符串必须以 '\0' 结束。

2、目标空间必须有足够的大，能容纳下源字符串的内容。

3、目标空间必须可修改

练习：

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

运行结果：helloworld

3.2 strcat模拟实现

char* my_strcat(char* dest,const char* src)
{
  char ret = dest;
  assert(dest && src);
  //目标空间的\0
  while (*dest != '\0')
  {
    dest++;
  }
  //追加内容到目标空间
  while (*dest++ = *src++)
  {
    ;
  }
  return ret;
}

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

运行结果：helloworld

4.strcmp

头文件：#include <string.h>

作用：比较两个字符串的大小(注意：这个大小不是长短，是指的是对应字符的ASCII码值的大小)

标准规定：

第一个字符串大于第二个字符串，则返回大于0的数字

第一个字符串等于第二个字符串，则返回0

第一个字符串小于第二个字符串，则返回小于0的数字

 练习：

int main()
{
  //比较的是对应位置上的字符大小
  char arr1[]= "abcdef";
  char arr2[] = "abq";
  //a和a相比 相等 往后走
  //返回 >1 相等0  <-1
  int ret = strcmp(arr1, arr2);
  printf("%d\n", ret);
  return 0;
}

运行结果：-1 

比较过程：arr1 和 arr2的前两个字符相同，比较第三个字符，arr1中的字符c对应的ASCII码值小于arr2中的字符q对应的ASCII码值，因此返回负数。之所以返回-1，这是库函数的规定。

附：ASCII码值表

 4.2 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 1;
  else
    return -1;
}
int main()
{
  //比较的是对应位置上的字符大小
  char arr1[] = "abcdef";
  char arr2[] = "abq";
  int ret =my_strcmp(arr1, arr2);
  printf("%d\n", ret);
  return 0;
}

运行结果：-1

5.strstr

头文件：#include <string.h>

作用：在目标字符串中查找源字符串，如果找到，则返回目标字符串中第一次包含源字符串之后的所以字符串，若未找到，则返回NULL

练习：

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;
}

运行结果：bcdef

5.2strstr模拟实现

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

  assert(str && substr);
  if (*substr == '\0')
  {
    return str;
  }
  while (*cur)
  {
    s1 = cur;
    s2 = substr;
    while (*s1 && *s2 &&*s1 == *s2)
    {
      s1++;
      s2++;
    }
    if (*s2 == '\0')
    {
      return cur;
    }
    cur++;
  }
  return NULL;

}
int main()
{
  char arr1[] = "abbbcdef";
  char arr2[] = "bbc";
  char* ret = my_strstr(arr1, arr2);
  if (NULL == ret)
  {
    printf("没找到\n");
  }
  else
  {
    printf("%s\n", ret);
  }
  return 0;
}

运行结果：bbcdef

注意：

char arr1[] = "abbbcdef";

 char arr2[] = "bbc";

arr2在arr1存在，但是要比较多次，并且需要改变位置，因此引入cur来记录实时arr1的位置，s1,s2分别表示arr1和arr2挪动到的字符。

6.memcpy

头文件：#include <string.h>

作用：函数memcpy从开始的位置开始向后复制num个字节的数据到目标的内存位置。

注意要点：

1、这个函数在遇到 '\0' 的时候并不会停下来。

2、如果source和destination有任何的重叠，复制的结果都是未定义的。

练习：

int main()
{
  int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
  int arr2[5] = { 0 };
  memcpy(arr2, arr1, 20);
  int i = 0;
  for (i = 0; i < 5; i++)
  {
    printf("%d ", arr2[i]);
  }
  return 0;
}

运行结果：1 2 3 4 5

6.1memcpy模拟实现：

void* my_memcpy(void* dest,const void* src, size_t num)
{
  void* ret = dest;
  assert(dest && src);
  while (num--)
  {
    *(char*)dest = *(char*)src;
    dest =(char*)dest + 1;
    src = (char*)src + 1;
  }
  return ret;
}
int main()
{
  int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
  int arr2[5] = { 0 };
  my_memcpy(arr2, arr1, 20);
  int i = 0;
  for (i = 0; i < 5; i++)
  {
    printf("%d ", arr2[i]);
  }
  return 0;
}

运行结果：1 2 3 4 5

7.memmove

头文件：#include <string.h>

作用：与memcpy相似。和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。如果源空间和目标空间出现重叠，就得使用memmove函数处理。
 

7.1memmove模拟实现

//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
//  {
//    //后->前
//    while (num--)
//    {
//      *((char*)dest + num) = *((char*)src + num);
//    }
//  }
//  return ret;
//}
//int main()
//{
//  int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
//  my_memmove(arr+2, arr, 20);
//  int i = 0;
//  for (i = 0; i < 10; i++)
//  {
//    printf("%d\n", arr[i]);
//  }
//  return 0;
//}

memmove可以操作可重叠空间，因此之后编程过程中，如果不重叠拷贝内存，就是用memcpy,否则使用memmove。

 (本篇完)