C语言string.h函数详解及部分模拟实现

string.h函数大全

string.h是一个C标准库头文件，包含了字符串处理函数、字符分类函数、数值转换函数、内存管理函数等操作字符串的函数。
查询：string.h头文件

一、字符串函数

1.1 strlen

size_t strlen ( const char * str );

• 功能： strlen函数用于求字符串长度
• strlen函数 以’\0’ 作为结束标志，返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )

例如：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
int main()
{
	char arr1[] = { "abcdef" };
	//正确，自动添加'\0'
	printf("%d\n", strlen(arr1));
	char arr2[] = { 'a','b','c','d' };
	//错误，需要手动添加'\0'，否则输出随机值
	printf("%d\n", strlen(arr2));
	char arr3[] = { 'a','b','c','d','\0' };
	//正确
	printf("%d\n", strlen(arr3));
	return 0;
}

输出结果：

• 注意函数的返回值为size_t，是无符号的
  例如：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
int main()
{
	if (strlen("abc") - strlen("abcdef") > 0)
	{
		printf(">=\n");
	}
	else
	{
		printf("<\n");
	}
	return 0;
}

很多人第一次做这一题认为输出的是“<”，但实际上:

原因：strlen返回的类型是size_t，也就是无符号整型，无符号整型-无符号整型得到的还是无符号整型，也就是说，它们相减得到的值并不是-3，而应该是：

ps：
1.%zu打印size_t类型；
2.不要将strlen与sizeof混淆，strlen返回字符串长度，sizeof返回数组元素个数。

strlen模拟

#define _CRT_SECURE_NO_WARNINGS 
#include <stdio.h>
#include <assert.h>
//第一种：创建变量
size_t my_strlen1(const char* b)
{
    assert(b);//断言函数，提高代码安全性（空指针报错）
    size_t count = 0;
    while (*b++ != '\0')
    {
        count++;
    }
    return count;
}
//第二种，不创建变量
size_t my_strlen2(const char* b)
{
    assert(b);
    if (*b == '\0')
        return 0;
    else
        return 1 + my_strlen2(b + 1);
}
int main()
{
    char a[] = "bit is yyds.";
    printf("%zu\n", my_strlen1(a));
    printf("%zu\n", my_strlen2(a));
    return 0;
}

1.2 strcpy

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

• 功能：复制字符串
• 参数：
  destination-指向要复制内容的目标数组的指针
  source-要复制的源字符串

注意事项：

1. 源字符串必须以 ‘\0’ 结束（必须要有‘\0’）;

2. 会将源字符串中的 ‘\0’ 拷贝到目标空间；
   eg.
   
   调试看看：
   
   的确复制到了‘\0’

3. 目标空间必须足够大，以确保能存放源字符串(目标空间要比源字符串空间大);

4. 目标空间必须可变(不能是常量字符串)；

eg.char* p="abcdef"; char arr[]="zxy"; strcpy(p,arr);
会报错

strcpy模拟

了解了strcpy如何使用，我们再来试试模拟实现；
前面已经说过，strcpy函数会将‘\0’也复制到目标空间，那么我们就可以认为，strcpy将源函数从起始位置复制到’\0’结束，而复制本身就是覆盖的过程，上代码

#define _CRT_SECURE_NO_WARNINGS 
#include <stdio.h>
#include <assert.h>
char* my_strcpy(char* a, const char* b)
{
    char* m = a;//保存起始地址
    assert(a && b);
    while (*a++ = *b++)//当b把‘\0’赋给a时，循环结束
    {
        ;
    }
    return m;
}
int main()
{
    char arr1[] = "bit is yyds!";
    char arr2[20];
    printf("%s", my_strcpy(arr2, arr1));
    return 0;
}

1.3 strcat

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

• 功能：字符串追加，将源字符串追加到目标字符串之后

注意事项：

1. 源字符串必须以 ‘\0’ 结束（同strcpy）；
2. 目标空间必须有足够的大，能容纳下源字符串的内容(同strcpy)；
3. 目标空间必须可修改(同strcpy);
4. 自己给自己追加字符串：在不同编译器上源码不同，在VS上可以成功，但在其他编译器不一定，因此不推荐使用strcat,推荐使用memmove(下面有讲）。

strcat模拟

strcat怎样模拟？既然是追加，自然要从目标字符串的‘\0’位置开始。代码如下：

#define _CRT_SECURE_NO_WARNINGS 
#include <stdio.h>
#include <assert.h>
char* my_strcat(char* str1, const char* str2)
{
    char* m = str1;
    assert(str1 && str2);
     //str1指向目标字符串的'\0'
    while (*str1)
    {
        str1++;
    }
    //追加
    while (*str1++ = *str2++)
    {
        ;
    }
    return m;
}
int main()
{
    char arr1[20] = { "bit " };
    char arr2[] = { "is yyds!" };
    printf("%s", my_strcat(arr1, arr2));
    return 0;
}

1.4 strcmp

int strcmp ( const char * str1, const char * str2 );

• 功能：比较字符串

• 标准规定：
  str1大于第str2，则返回大于0的数字
  str1等于str2，则返回0
  str1小于str2，则返回小于0的数字
  总结：返回值大于0则前面大，小于0则前面小

• 一个误区：
  一些初学者认为，哪一个字符串长哪一个就大（大错特错！）

• 字符串大小并不是由长度来判断，而是根据字符的ASCII值判断，从两个字符串的第一个字符开始，前面的大就返回大于0的数字，前面的小就返回小于0的数字，相等就比较下一个字符。

• 如果两个字符串相等，则比较到’\0’停止。

例：

#define _CRT_SECURE_NO_WARNINGS 1
#include <string.h>
#include <stdio.h>
int main()
{
	char str1[] = "abcde";
	char str2[] = "abcdE";
	if (strcmp(str1, str2) > 0)
		printf("str1>str2\n");
	else if (strcmp(str1, str2) > 0)
		printf("str1<str2\n");
	else
		printf("str1=str2\n");
}

输出：

strcmp模拟

一个一个比较即可

#define _CRT_SECURE_NO_WARNINGS 
#include <stdio.h>
#include <assert.h>
int my_strcmp(char* a, const char* b)
{
    assert(a && b);
    //如果相等，是'\0'就返回0，不是就接着往后比
    //如果不相等就结束循环
    while (*a == *b)
    {
        if (*a == '\0')
            return 0;
        a++;
        b++;
    }
    return *a - *b;//不相等时的返回值
}
int main()
{
    char arr1[20] = { "bit is yyds." };
    char arr2[] = { "bit is yyds!" };
    printf("%d\n", my_strcmp(arr1, arr2));
    return 0;
}

1.5 strncpy

刚刚讲的strcpy、strcat、strcmp都是长度不受限制的字符串函数，现在来讲讲长度受限制的字符串函数。
顾名思义，与之前讲的函数相比，接下来讲的几个函数的功能与前面的完全相同，只不过多了一个参数来限制，这大大提高了代码的安全性，避免了越界问题。

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

注意点：

• 拷贝num个字符从源字符串到目标空间。
• 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。

其他方面与strcpy完全相同，在此就不一一赘述。

strncpy模拟

#define _CRT_SECURE_NO_WARNINGS 
#include <stdio.h>
#include <assert.h>
char* my_strncpy(char* a, const char* b, size_t num)
{
	char* m = a;
	assert(a && b);
	int i = 0;
	while ((*a++ = *b++) && ++i < num)//遇到\0或达到num个停止
	{
		;
	}
	//如果上面的循环是‘\0'结束的，i就没有加一,所以下面的循环用++i把上面循环里的第'\0'的个数补上
	//所以下面的循环理解上是先赋值再i+1，不是i先加1再赋值
	while (++i < num)//如果未达到num个,补0
	{
		*a++ = '\0';
	}
	return m;
}
int main()
{
	char arr1[] = "bit is yyds!";
	char arr2[20];
	printf("%s", my_strncpy(arr2, arr1, 20));
	return 0;
}

1.6 strncat

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

注意点：

• 追加num个字符从源字符串到目标空间。
• 如果源字符串的长度小于num，则追加完源字符串之后，在目标的后边追加0，直到num个。
• 其他同strcat。
  例：
  

strncat模拟

大致思路同strncpy

#define _CRT_SECURE_NO_WARNINGS 
#include <stdio.h>
#include <assert.h>
char* my_strncat(char* str1, const char* str2, size_t num)
{
	char* m = str1;
	assert(str1 && str2);
	while (*str1)
	{
		str1++;
	}
	int i = 0;
	while ((*str1++ = *str2++) && ++i < num)
	{
		;
	}
	while (++i < num)
	{
		*str1++ = '\0';
	}
	return m;
}
int main()
{
	char arr1[20] = { "bit " };
	char arr2[] = { "is yyds!" };
	printf("%s", my_strncat(arr1, arr2,12));
	return 0;
}

1.7 strncmp

int strncmp ( const char * str1, const char * str2, size_t num );

• 比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完；
• 其余同strcmp。
  例：

#include <stdio.h>
#include <string.h>
int main ()
{
char str[][5] = { "R2D2" , "C3PO" , "R2A6" };
int n;
puts ("Looking for R2 astromech droids...");
for (n=0 ; n<3 ; n++)
if (strncmp (str[n],"R2xx",2) == 0)
{
printf ("found %s\n",str[n]);
}
return 0;
}

1.8 strstr

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

• 功能：字符串查找（在目标字符串中找源字符串）；
• 返回str1中第一次出现str2的起始位置的地址，如果str1中找不到str2则返回空指针NULL；
  例:

/* strstr example */
#include <stdio.h>
#include <string.h>
int main()
{
	char str[] = "This is a simple string";
	char* pch;
	pch = strstr(str, "simple");//“simple”中字符‘s’的地址
	if (pch != NULL)
	{
		strncpy(pch, "sample", 6);
	}
	puts(str);
	return 0;
}

运行结果：

返回的地址应该是：

验证一下：

strstr模拟

s1和s2判断字符串是否相等，cp保存目标字符串中的每个元素的地址

#define _CRT_SECURE_NO_WARNINGS 
#include <assert.h>
#include <stdio.h>
char* my_strstr(const char* str1, const char* str2)
{
    char* s1 = NULL;//
    char* s2 = NULL;
    char* cp = (char*)str1;//把一个相对安全的指针（const修饰）交给不安全的指针，权限放大了，所以强制类型转换
    while (*cp)//每一次循环都是重新判断str1中是否存在str2
    {
        s1 = cp;
        s2 = (char*)str2;//同上
        while (*s1 && *s2&& *s1 == *s2)*s1或*s2指向‘\0’结束或者字符不相等结束
        {
            s1++;
            s2++;//自增比下一个字符
        }
        if (*s2 == '\0')//到了‘\0’代表找到了
        {
            return cp;//返回第一次找到str2的地址
        }
        cp++;
    }
    return NULL;//找不到
}
int main()
{
    char arr1[] = "gaoshu is very very difficult.";
    char arr2[] = "very";
    char* p = my_strstr(arr1, arr2);
    if (p == NULL)
        printf("找不到\n");
    else
        printf("%s", p);
    return 0;
}

1.9 strchr/strrchr

之所以将这两个函数放在一块，是因为它们的功能都是查找字符。

1.9.1 strchr

const char * strchr ( const char * str, int character );

• 功能：查找一个字符
• 返回第一次出现‘character’字符的地址，如果str中找不到则返回空指针NULL；
• 第二个参数为int型，但在使用时可以写为字符型（转换为ASCII 值）。至于为什么是int，纯粹是由于历史原因。

例：

/* strchr example */
#include <stdio.h>
#include <string.h>

int main ()
{
  char str[] = "This is a sample string";
  char * pch;
  printf ("Looking for the 's' character in \"%s\"...\n",str);
  pch=strchr(str,'s');//‘s’第一次出现
  while (pch!=NULL)
  {
    printf ("found at %d\n",pch-str+1);
    pch=strchr(pch+1,'s');//往后找‘s’所有出现的位置
  }
  return 0;
}

1.9.2 strrchr

const char * strrchr ( const char * str, int character );

• 功能：查找一个字符
• 唯一与strchr的不同点在于，其返回最后<一次出现‘character’字符的地址，如果str中找不到则返回空指针NULL
• 也就是说，strchr是从前往后（从左向右）查找，而strrchr是从后往前（从右向左）查找。

/* strrchr example */
#include <stdio.h>
#include <string.h>

int main ()
{
  char str[] = "This is a sample string";
  char * pch;
  pch=strrchr(str,'s');//最后一次
  printf ("Last occurence of 's' found at %d \n",pch-str+1);
  return 0;
}

模拟较为简单，不做演示。

2.1strspn

size_t strspn ( const char * str1, const char * str2 );

• 功能：strspn()从参数str1 字符串的开头计算连续的字符，而这些字符都完全是str2 所指字符串中的字符。简单的说，若strspn()返回的数值为n，则代表字符串str1 开头连续有n 个字符都是属于字符串str2内的字符;
• 返回字符串中第一个不在指定字符串中出现的字符下标,也是字符串str1开头连续包含字符串str2内的字符数目。
  代码理解：

/* strspn example */
#include <stdio.h>
#include <string.h>

int main ()
{
  int i;
  char strtext[] = "129th";
  char cset[] = "1234567890";

  i = strspn (strtext,cset);
  printf ("The initial number has %d digits.\n",i);
  return 0;
}

输出：

The initial number has 3 digits.
strtext中，连续3个字符“129”能在cset中找到，故返回3，也是‘t’的下标。

2.2 strcspn

size_t strcspn ( const char * str1, const char * str2 );

• 功能：与strspn完全相反，strcspn()从参数str1字符串的开头计算连续的字符，而这些字符都完全不在参数str2所指的字符串中。简单地说， 若strcspn()返回的数值为n，则代表字符串str1开头连续有n 个字符都不含字符串str2内的字符。
  返回值：返回字符串str1开头连续不含字符串str2内的字符数目，或字符串中第一个在指定字符串中出现的字符下标。

用一段代码来解释：

#define _CRT_SECURE_NO_WARNINGS 1
#include <string.h>
#include <stdio.h>
int main()
{
	char s[] = "12345Hello, World!";
	char letters[] = "abcdefghijklmnopqrstuvwxyz";
	size_t num = strcspn(s, letters);
	printf("%zu\n", num); 
	return 0;
}

上述代码中，输出结果为6，因为从s开头到第一个在字母表（letters）中的字符‘e’为止，“12345H”共6个字符不在letters中，故返回值为6，也是‘e’的下标。既然如此，那么，num+1就可以得到s中第一个在字母表中的字符‘e’的位置。

2.3 strpbrk

const char * strpbrk ( const char * str1, const char * str2 );

• 功能：strpbrk函数返回一个指针，它指向字符串str2中的任意字符第一次出现在字符串str1中的位置，如果str1没有与str2中相同的字符，则返回NULL
• 总结：str1从前往后，如果某个字符在str2中出现了，就返回这个字符的地址，直到’\0’就返回NULL。
  代码解释：

/* strpbrk example */
#include <stdio.h>
#include <string.h>

int main ()
{
  char str[] = "This is a sample string";
  char key[] = "aeiou";
  char * pch;
  printf ("Vowels in '%s': ",str);
  pch = strpbrk (str, key);//str中找key中的字符
  while (pch != NULL)
  {
    printf ("%c " , *pch);
    pch = strpbrk (pch+1,key);
  }
  printf ("\n");
  return 0;
}

输出：
Vowels in ‘This is a sample string’: i i a a e i

2.4 strtok

char * strtok ( char * str, const char * delimiters );

• 功能：字符分割函数，分解字符串为一组字符串。str为要分解的字符串，delim为分隔符字符（如果传入字符串，则传入的字符串中每个字符均为分割符）。
• 首次调用时，str指向要分解的字符串，之后再次调用要把str设成NULL。
• 返回值：从str开头开始的一个个被分割的串的地址。当str中的字符查找到末尾时，返回NULL。
  如果查找不到delim中的字符时，返回当前strtok的字符串的指针。
  所有delim中包含的字符都会被滤掉，并将被滤掉的地方设为一处分割的节点。
• strtok函数会破坏被分解字符串的完整，调用前和调用后的s已经不一样了。如果要保持原字符串的完整，可以使用strchr和sscanf的组合等。
  例：

/* strtok example */
#include <stdio.h>
#include <string.h>

int main ()
{
  char str[] ="- This, a sample string.";
  char * pch;
  printf ("Splitting string \"%s\" into tokens:\n",str);
  pch = strtok (str," ,.-");//',''.'-'均为分割符
  while (pch != NULL)
  {
    printf ("%s\n",pch);
    pch = strtok (NULL, " ,.-");//重新调用，str设为NULL
  }
  return 0;
}

输出：

Splitting string “- This, a sample string.” into tokens:
This
a
sample
string

2.5 strerror

char * strerror ( int errnum );

• 功能：获取指向错误消息字符串的指针
  通过标准错误的标号，获得错误的描述字符串 ，将单纯的错误标号转为字符串描述，方便用户查找错误。
• 参数：
  errnum：错误标号，通常用errno(标准错误号，定义在errno.h中//自行查阅)
• 头文件:
  #include <errno.h>
  #include <string.h>
  例子：

/* strerror example : error list */
#include <stdio.h>
#include <string.h>
#include <errno.h>

int main ()
{
  FILE * pFile;
  pFile = fopen ("unexist.ent","r");
  if (pFile == NULL)
    printf ("Error opening file unexist.ent: %s\n",strerror(errno));
  return 0;
}

二、内存操作函数

3.1 memset

void * memset ( void * ptr, int value, size_t num );

• 功能：memset是计算机中C/C++语言初始化函数。作用是将某一块内存中的内容全部设置为指定的值， 这个函数通常为新申请的内存做初始化工作。
• 函数解释：将 ptr 中当前位置后面的num个字节（typedef unsigned int size_t ）用 value 替换并返回 ptr 。
• 常用于对较大的结构体或数组进行清零操作。
• 常见错误：
  1.memset函数按字节对内存块进行初始化，所以不能用它将int数组初始化为0和-1之外的其他值（除非该值高字节和低字节相同）
  2.value实际范围应该在0~~255，因为该函数只能取value的后八位赋值给你所输入的范围的每个字节

/* memset example */
#include <stdio.h>
#include <string.h>

int main ()
{
  char str[] = "almost every programmer should know memset!";
  memset (str,'-',6);
  puts (str);
  return 0;
}

输出：
------ every programmer should know memset!

3.2 memcpy

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

• 功能：同strncpy,不过不局限于字符串。函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
• 这个函数在遇到 ‘\0’ 的时候并不会停下来。
• 如果source和destination有任何的重叠，复制的结果都是未定义的。

memcpy模拟

#include <stdio.h>
#include <assert.h>
void* my_memcpy(void* dest, const void* src, size_t num)
{
    void* ret = dest;//保存起始地址
    assert(dest && src);
    while(num--)
    {
        *(char*)dest = *(char*)src;//按字节复制，为了保证所有类型都可以，强制转换为最少字节类型char*
        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[20] = { 0 };
    my_memcpy(arr2, arr1, 20);
    return 0;
}

3.3 memmove

void * memmove ( void * destination, const void * source, size_t num );

• 功能：同memcpy
• 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
• 如果源空间和目标空间出现重叠，就得使用memmove函数处理(原理见模拟)

memmove模拟

为什么源空间和目标空间出现重叠用memmove,这是因为在其他函数中，前面已经被覆盖的位置会再次拿来被使用，如下面的代码：

#define _CRT_SECURE_NO_WARNINGS 1
#include <string.h>
#include <stdio.h>
int main()
{
	char s[] = "123456789";
	memcpy(s + 2, s, 5);
	printf("%s", s);
	return 0;
}

这里的理想结果应该是“121234589”，但实际上却是“121212189”（当然VS上函数优化过可行，但其他编译器不能保证），因为复制到第三个字符时，已经将第3,4个字符修改为‘1’，‘2’，所以会循环往复。
那改怎么修改呢？

先复制要被改的内容
如果目标位置在起始位置后，就从后往前复制
如果目标位置在起始位置前，就从前往后复制

#define _CRT_SECURE_NO_WARNINGS 
#include <assert.h>
#include <stdio.h>
void* my_memmove(void* dest, 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 arr1[] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
    my_memmove(arr1 + 3, arr1, 20);
    for (int i = 0; i < 12; i++)
    {
        printf("%d ", arr1[i]);
    }
    return 0;
}

3.4 memcmp

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

• 功能：同strncmp,比较从ptr1和ptr2指针开始的num个字节（不局限于字符串）
• 返回值如下：
  
  例：

/* memcmp example */
#include <stdio.h>
#include <string.h>
int main ()
{
char buffer1[] = "DWgaOtP12df0";
char buffer2[] = "DWGAOTP12DF0";
int n;
n=memcmp ( buffer1, buffer2, sizeof(buffer1) );
if (n>0) printf ("'%s' is greater than '%s'.\n",buffer1,buffer2);
else if (n<0) printf ("'%s' is less than '%s'.\n",buffer1,buffer2);
else printf ("'%s' is the same as '%s'.\n",buffer1,buffer2);
return 0;
}

memcmp模拟根据strncmp仿照memcpy即可。

补充（不常用）

2.6 strcoll

int strcoll ( const char * str1, const char * str2 );

• 说明：
  默认情况下(LC_COLLATE为"POSIX"或"C")和strcmp一样根据ASCII比较字符串大小。
  对于设置了LC_COLLATE语言环境的情况下，则根据LC_COLLATE设置的语言排序方式进行比较。例如：汉字，根据拼音进行比较。
• 用法：同strcmp。

2.7 strxfrm

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

• 功能：strxfrm()函数把字符串 src 转换成另外 一种形式，用 strcmp() 来比较两个转换后的字符串 与用 strcoll() 来比较它们转换前的字符串 的返回值是一样的。转换后的字符串的前n个字符会存放于 dest 中。 它是根据程序 当前的区域选项中的LC_COLLATE来转换的。
• 返回值：返回值转换后的字符串的长度，不包括终止的null字符。
• 注意:如果区域选项是 “POSIX” 或者 “C”, 那么 strxfrm() 同用 strncpy() 来 拷贝字符串是等价的。

ps:可能有人发现后面没有前面详细了，那是因为实在肝不动了…
感谢支持，欢迎指正文章来源地址https://www.toymoban.com/news/detail-773260.html

到了这里，关于C语言string.h函数详解及部分模拟实现的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！