字符串函数（部分）

一，字符串函数

1.1, strcpy与strncpy

1.1.1strcpy

strcpy是C语言中的一个标准库函数包含在 <string.h> 头文件中，用于复制字符串。
函数原型为：

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

第一个参数dest：表示目标字符串的指针，用于存储复制过来的字符串。指向目标位置的首元素地址。
第二个参数src：表示源字符串的指针，用于提供要复制的字符串。指向要复制字符串的首元素地址。
该函数的返回值为一个指针，指向目标字符串的首元素。
strcpy会将 参数2：src 指向的字符串（包括空字符 ‘\0’）复制到参数1： dest 指向的内存位置，直到遇到 src 中的空字符 ‘\0’ 为止。并且返回一个指针
strcpy演示：

#include <stdio.h>
#include <string.h>
int main()
{
    char arr2[] = "Hello World!";
    char arr1[20];
    char*s=strcpy(arr1, arr2);
    printf("%s\n",arr1);
    return 0;
}

可以看到strcpy将字符串arr2全部拷贝到了arr1，并且返回的指针指向了数组arr1首元素的地址。
在使用strcpy的时候，有几个注意事项：
确保目标字符串 dest 的内存区域足够大，能够容纳源字符串 src 以及空字符 ‘\0’。否则，可能会导致缓冲区溢出，引发安全问题。

考虑到各方面原因，我们拷贝字符串的时候有时可以选择另一个函数“strncpy”

1.1.2strncpy

strncpy函数与strcpy函数类似，都是C语言中用于拷贝字符串的函数，它的原型定义在 <string.h> 头文件中
strncpy函数的原型为：

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

与strcpy相比，strncpy函数的参数多了一个参数num，意味从 src 指向的字符串中复制最多 n 个字符到 dest 指向的字符数组中。
函数演示：

#include <stdio.h>
#include <string.h>
int main() {
    char dest[20];
    const char* src = "Hello, World!";
    strncpy(dest, src, 6);
    dest[6] = '\0';  
    printf("%s\n", dest); 
    return 0;
}

这存在两种情况：
一：如果 src指向的字符串的长度小于 n，那么 dest 中未被 src 字符填充的位置将被填充为 \0
二：如果 src 的长度大于或等于 n，那么 dest 将不会以 \0 结尾，这意味着 dest 不是一个合法的 C 字符串，因为它没有以空字符终止。
在实际编程中，如果你需要复制整个字符串并保证它是以 \0 结尾的，那么 strcpy 可能是一个更好的选择，但是你需要确保目标缓冲区有足够的空间来容纳源字符串（包括终止符）。如果源字符串可能比目标缓冲区大，那么你应该使用 strncpy 并手动添加终止符。

1.1.3strcpy和strncpy模拟实现

strcpy模拟实现
首先，strcpy函数的操作对象是字符串，参数为指向字符串的两个指针，返回值为指向目标空间的指针，

#include<stdio.h>
#include<assert.h>
char* my_strcpy(char*dest,const char*str)//使用const来修饰原字符串，避免其被修改
{
	assert(dest && str);//使用assert来判断两个指针是否为空指针
	char*st = dest;//记录目标空间首元素地址
	while (*dest++=*str++)
		;
	return st;
}
int main()
{
	char arr1[20] = "xxxxxxxxxxxxxx ";
	char arr2[] = "hello bit!";
	char* s = my_strcpy(arr1,arr2);//数组名表示数组首元素的地址
	printf("%s", s);
	return 0;
}

结果：

strncpy模拟实现
strncpy的模拟实现与strcpy类似，只不过多了一个参数用于判断所需复制的字符数量，同时要考虑两种不同的情况。也就是源字符串大于和小于num的情况

#include<stdio.h>
#include<assert.h>
#include<string.h>
char* my_strncpy(char* dest,const char* str, size_t num)
{
	int sz = strlen(str);//计算源字符串的长度
	assert(dest && str);//判断是否为空指针
	char* st = dest;//记录目标字符串的首元素地址
	int n = num;
	for (int i = 1;i <= n;i++)
	{
		if (i > sz)//判断复制的字符数是否已经超过源字符串长度
		{
			*dest = '\0';//如果长于源字符串，不足的补‘\0’
			dest++;
			continue;
		}
		*dest = *str;//按字符复制
		dest++;
		str++;
	}
	return st;
}
int main()
{
	char arr1[20] = "xxxxxxxx";
	char arr2[] = "abc";
	int num = 0;
	scanf("%d", &num);
	my_strncpy(arr1, arr2,num);
	printf("%s\n", arr1);
	return 0;
}

情况一（src指向的字符串的长度小于 n）结果为：

情况二（src 的长度大于或等于 n）

2.2strcat与strnact

2.2.1strcat

strcat函数是一个用于连接两个字符串的函数。使用该函数需包含的头文件为<string.h>。
函数原型为：

char *strcat(char *dest, const char *src);

参数一为指向连接目标的指针，参数二为指向连接内容的指针，返回值为指向连接目标首元素地址的一个指针。
该函数会将src指针指向的字符串连接到dest指针指向的字符串的末尾。dest指针指向的字符串必须是一个足够大的字符数组，以便包含dest原始内容和追加的src的内容。src字符串的内容在连接后不会被修改。连接完成后，函数返回指向连接后字符串的指针。
函数演示：

#include <stdio.h>
#include <string.h>
int main() 
{
    char arr1[20] = "Hello ";
    const char* arr2 = "World!";
    strcat(arr1, arr2);
    printf("%s\n", arr1); 
    return 0;
}

可以看到，strcat函数将arr2字符串拼接到了arr1字符串的最后，
同样在使用strcat拼接字符串时，要注意目标字符串数组有足够的空间，如果空间不足，可能会导致缓冲区溢出。

综合各方面考虑，我们拼接字符串的时候有时可以选择另一个函数“strncat”

2.2.2strncat

strncat函数与strcat函数类似，都是C语言中用于拼接字符串的函数，它的原型定义在 <string.h> 头文件中
strncat函数的原型为：

char *strncat(char *dest, const char *src, size_t n);

与strcat函数相比，这个函数将多了一个参数n，表示将src字符串的前n个字符连接到dest字符串的末尾处（\0之后）。
函数演示：

#include <stdio.h>
#include <string.h>
int main() 
{
    char arr1[20] = "Helloxxx\0xxxxxxxx";
    const char* arr2 = "World!";
    strncat(arr1, arr2, 5);
    printf("%s\n", arr1); 
    return 0;
}

结果为：

可以看到，strncat在连接完n个字符后，会自动在连接一个新的\0表示结尾。
同样的，由于多了个参数n，strncat函数在拼接字符串时也存在两种情况：
一：如果 src指向的字符串的长度小于 n，那么 strncat函数只会将src指向的字符串所具有的字符连接完，在连接一个新的\0后返回指针。

二：如果 src 的长度大于或等于 n，strncat函数会将src指向的字符串所具有的字符连接n个字符到dest指向的字符串后，在连接一个新的\0后返回指针。
在使用strncat函数时存在几个注意事项：
strncat不会检查dest字符串是否有足够的空间来存储整个连接后的字符串（包括null终止符）。因此，在使用strncat时，你需要确保dest数组的大小至少为strlen(dest) + n + 1，以容纳原始dest字符串、要添加的n个字符以及一个null终止符。为了避免缓冲区溢出，应该始终确保有足够的空间来存储连接后的字符串。这通常意味着需要预先计算dest和src字符串的长度，并分配足够的内存。

2.2.3strcat和strncat模拟实现

strcat模拟实现
首先，strcat函数的操作对象是字符串，参数为指向字符串的两个指针，返回值为指向目标空间的指针，

#include<stdio.h>
#include<assert.h>
char*my_strcat(char*dest,const char*str)//使用const来修饰原字符串，避免其被修改
{
	assert(dest && str);//判断两个指针都不为空指针
	char* s = dest;//记录目标空间的首元素地址
	while (*dest != '\0')//先找到目标字符串的末尾
	{
		dest++;
	}
	while (*dest++=*str++)//从目标字符串的末尾开始追加字符
		;
	return s;//返回目标空间首元素的地址
}
int main()
{
	char arr1[100] = "hello ";
	char arr2[] = "bit!";
	char*s=my_strcat(arr1,arr2);//数组名表示数组首元素的地址
	printf("%s\n", s);
	return 0;
}

结果为

strncat模拟实现
strnczt的模拟实现与strcat类似，只不过多了一个参数用于判断所需复制的字符数量，同时要考虑两种不同的情况。也就是源字符串大于和小于num的情况

#include<stdio.h>
#include<assert.h>
#include<string.h>
char* my_strncat(char* dest, const char* str, size_t num)
{
	char* st = dest;//记录目标空间的首元素地址
	int sz = strlen(str);//计算源字符串的长度
	assert(&dest&&str);//判断是否为空指针
	while (*dest != '\0')//找到目标字符串的结尾
		dest++;
	while ((*dest++ = *str++)&&num>1)//按字符逐个连接
		num--;
	if (num <= sz)//判断参数所要求的连接数是否大于源字符串长度
		*dest++ ='\0';
	return st;
}
int main()
{
	char arr1[20] = "abcd\0xxxxxxxxxxxxx";
	char arr2[] = "efghij";
	int num = 0;
	scanf("%d", &num);
	my_strncat(arr1, arr2, num);
	printf("%s\n", arr1);
	return 0;
}

情况一（src指向的字符串的长度小于 n）结果为：

情况二（src 的长度大于或等于 n）