strcpy函数
在C语言中，strcpy()函数用于将一个字符串复制到另一个字符串中。
函数原型如下：
char *strcpy(char *destination, const char *source);
参数解释：
destination：目标字符串，将会被复制到。source：源字符串，将会被复制到目标字符串中。
函数返回值：
- 返回指向目标字符串的指针。
场景一：
#include <stdio.h>
#include <string.h>
int main()
{
char arr[10] = "########";
printf("%s\n", strcpy(arr,"hello"));
return 0;
}输出的结果
hello场景二：
#include <stdio.h>
#include <string.h>
int main()
{
char arr1[10] = "**********";
char arr2[10] = "abcd";
printf("%s\n", strcpy(arr1, arr2));
return 0;
}输出结果
abcd注意点
1.源字符必须以 '\0'结束：
#include <stdio.h>
#include <string.h>
int main()
{
char arr1[10] = "**********";
char arr2[10] = { 'a','b','c','d' };
printf("%s\n", strcpy(arr1,arr2));
return 0;
}
这里的代码会出错，'\0'是停止拷贝的终止条件，arr2字符数组所在的内存空间后面存储的内容并不知道，不遇到 '\0' 拷贝就不会停止，这就会导致越界访问，程序就会出现问题。
2.目标空间必须足够大，以确保能存放得下放源字符串
#include <stdio.h>
#include <string.h>
int main()
{
char arr1[5] = "*****";
char arr2[] = "hello world";
printf("%s\n", strcpy(arr1,arr2));
return 0;
}
这里虽然拷贝成功并将结果输出了，但程序却崩溃了。目标空间太小，不足以放置拷贝的源字符串，会造成溢出的情况
3.目标空间必须可变
#include <stdio.h>
#include <string.h>
int main()
{
char* str1 = "hello world";
char str2[10] = "*********";
printf("%s\n", strcpy(str1,str2));
return 0;
}
这里的程序也出现了错误。str1指向的是常量字符串，是不可以被修改掉的，目标空间必须是可以被修改的，因为要将拷贝的字符串放在目标空间中。而源字符串可以是能够修改的、也可以是不能修改的，因为strcpy函数的第二个参数已经用const关键字修饰了，保证了拷贝过程中不会被修改。
模拟实现
strcpy函数的模拟实现方式可以有多种，这主要取决于你对函数安全性、性能以及内存操作的不同需求。以下是几种常见的实现方式：
1. 基本实现
这是最直接的实现方式，它逐个复制源字符串的字符到目标字符串，直到遇到源字符串的结束符\0。
char *my_strcpy(char *dest, const char *src) {
assert(dest&&str);
char *orig_dest = dest; // 保存dest的原始指针
while (*src != '\0') {
*dest++ = *src++;
}
// 添加结束符'\0'
*dest = '\0';
// 返回原始dest指针
return orig_dest;
} 2. 指针算术实现
这种实现方式使用指针算术来简化复制过程，减少了对dest的多次解引用。
char *my_strcpy_pointer_arithmetic(char *dest, const char *src) {
assert(dest&&str);
char *orig_dest = dest;
while ((*dest++ = *src++) != '\0');
return orig_dest;
} 3. 考虑安全性的实现
为了避免缓冲区溢出，你可以在实现中检查目标字符串dest的缓冲区大小。然而，strcpy函数本身并不检查缓冲区大小，这是其不安全的地方。一个更安全的版本是strncpy，但如果你想要模拟实现一个带缓冲区大小检查的strcpy，可以这样做：
char *my_safe_strcpy(char *dest, const char *src, size_t dest_size) {
assert(dest&&str);
char *orig_dest = dest;
size_t i;
// 确保目标缓冲区至少有1个字节的空间以存储'\0'
if (dest_size == 0) {
return NULL;
}
for (i = 0; i < dest_size - 1 && src[i] != '\0'; ++i) {
dest[i] = src[i];
}
// 添加结束符'\0'并确保不会超出目标缓冲区
dest[i] = '\0';
return orig_dest;
} 在这个实现中，我们传递了一个额外的参数dest_size来表示目标字符串dest的缓冲区大小。我们确保在复制过程中不会超出这个大小，并在最后添加一个结束符\0。
注意事项：
- 基本实现和指针算术实现都没有检查目标缓冲区的大小，因此它们可能导致缓冲区溢出。在实际应用中，应该避免使用这些不安全的实现，除非你能确保目标缓冲区足够大。
- 考虑安全性的实现通过检查目标缓冲区的大小来防止缓冲区溢出，但这也增加了函数的复杂性。在性能要求较高的场景中，可能需要权衡安全性和性能。
- 在实际编程中，通常建议使用标准库提供的strcpy、strncpy等函数，并根据需要选择适当的安全措施，如确保目标缓冲区足够大或使用更安全的字符串处理函数。
strncpy函数
strncpy 是 C 语言标准库中的一个函数，用于将源字符串的前 n 个字符（包括空字符 \0，如果源字符串在 n 个字符之前结束）复制到目标字符串中。
与 strcpy 不同，strncpy 不会自动在目标字符串的末尾添加空字符 \0，除非源字符串的长度小于或等于 n。
因此，在使用 strncpy 时，通常需要手动添加空字符以确保目标字符串是一个有效的 C 字符串。
它的原型如下：
char *strncpy(char *dest, const char *src, size_t n);其中，dest是目标字符串的指针，src是源字符串的指针，n是要复制的字符数。
strncpy函数会将src指向的字符串的前n个字符复制到dest指向的字符串中，并在复制完成后返回dest的指针。
注意点
strncpy不会自动向目标空间追加‘\0’
如果复制的字符数n大于src指向的字符串的长度，那么dest指向的字符串会被'\0'字符填充，直到复制完n个字符为止。
如果n小于src指向的字符串的长度，那么dest指向的字符串不会被终止符'\0'填充，而且可能不是一个有效的C字符串。
示例代码如下：
#include <stdio.h> #include <string.h> int main() { char src[] = "Hello, World!"; char dest[20]; strncpy(dest, src, 5); dest[5] = '\0'; printf("Copied string: %s\n", dest); return 0; }这段代码将src字符串的前5个字符复制到dest字符串中，并手动添加了终止符'\0'。最后输出的结果为"Hello"。
目标空间必须足够大
如果n小于src指向的字符串的长度，那么dest指向的字符串不会被终止符'\0'填充，而且可能不是一个有效的C字符串。
我们上面举了例子，就不多说了
模拟实现
strncpy函数的模拟实现方式可以有多种，但基本的思路都是按照strncpy的定义来进行：复制源字符串的前n个字符到目标字符串，并确保目标字符串至少包含n个字符（如果需要的话，用空字符\0填充剩余部分）。以下是几种可能的模拟实现方式：
1. 基本实现
这是最直接的模拟实现方式，按照strncpy的定义逐字符复制，并在需要时添加空字符\0。
#include <stddef.h> // 包含 size_t 的定义
char *my_strncpy_basic(char *dest, const char *src, size_t n) {
assert(dest&&str);
char *orig_dest = dest;
size_t i;
for (i = 0; i < n && src[i] != '\0'; ++i) {
dest[i] = src[i];
}
// 如果还没有达到 n 个字符，用 '\0' 填充剩余部分
for (; i < n; ++i) {
dest[i] = '\0';
}
return orig_dest;
} 2. 优化版实现
在某些情况下，如果知道源字符串的长度不会超过n，可以稍微优化这个过程，避免不必要的空字符填充。
char *my_strncpy_optimized(char *dest, const char *src, size_t n) {
assert(dest&&str);
char *orig_dest = dest;
size_t i;
for (i = 0; i < n && src[i] != '\0'; ++i) {
dest[i] = src[i];
}
// 如果源字符串自身长度小于 n，确保目标字符串以 '\0' 结尾
if (src[i] == '\0') {
dest[i] = '\0';
}
return orig_dest;
} 3. 指针算术实现
使用指针算术可以简化循环内部的索引操作，使得代码更简洁。
char *my_strncpy_pointer_arithmetic(char *dest, const char *src, size_t n) {
assert(dest&&str);
char *orig_dest = dest;
const char *src_end = src + n; // 计算 src 中要复制的字符的结束位置
// 复制字符直到达到 n 个字符或遇到 src 的结束符 '\0'
while (src < src_end && *src != '\0') {
*dest++ = *src++;
}
// 用 '\0' 填充剩余部分
while (dest < orig_dest + n) {
*dest++ = '\0';
}
return orig_dest;
} 注意事项：
- 无论采用哪种实现方式，都需要确保目标缓冲区dest有足够的空间来存储至少n个字符，包括结尾的空字符\0。如果dest的空间不足，可能会导致缓冲区溢出。
- 在实际应用中，还需要考虑错误处理，比如当dest或src为NULL时应该怎么做。
- 在性能敏感的场合，可以根据实际情况选择最合适的实现方式。例如，如果源字符串通常很长，使用指针算术可能更有效率；如果源字符串通常较短，基本的循环实现可能就足够了。
- 这些模拟实现都是基于标准strncpy函数的行为，并假设调用者已经正确地处理了缓冲区大小和空指针等问题。在真实环境中使用时，还需要添加适当的错误检查和边界条件处理来确保程序的健壮性。
与strcpy的区别
strncpy和strcpy都是C语言中的字符串处理函数，它们的主要功能都是复制字符串，但它们在处理字符串的方式上有一些重要的区别。
复制长度：
strcpy函数会复制源字符串的所有字符，直到遇到空字符\0为止。这意味着如果源字符串的长度超过了目标字符串的缓冲区大小，那么strcpy可能会导致缓冲区溢出，这是一个常见的安全问题。strncpy函数则复制源字符串的前n个字符到目标字符串中，无论是否遇到空字符\0。如果源字符串的长度小于n，那么strncpy会在目标字符串的剩余位置填充\0，直到复制了n个字符。如果源字符串的长度大于或等于n，strncpy不会添加额外的\0，这可能会导致目标字符串不是一个有效的C字符串（即不以\0结尾）。因此，在使用strncpy时，通常需要手动检查并添加\0，以确保字符串的正确性。安全性：
- 由于
strcpy不会检查目标缓冲区的大小，因此它更容易导致缓冲区溢出。这种溢出可以被恶意利用，造成严重的安全问题。strncpy虽然在一定程度上可以避免缓冲区溢出（如果正确使用，并且n不超过目标缓冲区的大小），但它并不总是生成有效的C字符串。因此，在使用strncpy时，需要特别注意确保目标字符串的正确性。总的来说，虽然
strcpy和strncpy都用于复制字符串，但它们在处理字符串的方式和安全性上有显著的不同。在编写涉及字符串操作的代码时，应根据具体情况选择适当的函数，并确保正确使用它们，以避免潜在的安全问题。
