目录
1.长度不受限制的字符串函数
1.1 strcpy
char* strcpy(char * destination, const char * source )1.1.1 功能
功能：将source指向的字符串拷贝给destination指向的字符串，并返回指向拷贝完的字符串的指针destination。
1.1.2 实现条件
1.源字符串（source指向的字符串）必须以 '\0' 结束。
2.会将源字符串中的 '\0' 拷贝到目标空间。
3.目标空间必须足够大，以确保能存放源字符串。
4.目标空间必须可变。
1.1.3 模拟实现
#include <stdio.h>
#include<assert.h>
char* my_strcpy(char* arr2, const char* arr1)
{
assert(arr2 && arr1 != NULL);//断言，防止arr1，arr2为空指针
char* ret = arr2;
while (*arr2++ = *arr1++)
{
;
}
return ret;
}
int main()
{
char arr1[] = { "hello world!" };
char arr2[20] = { 0 };
printf("%s\n", my_strcpy(arr2, arr1));
return 0;
}1.1.4 效果
1.2 strcat
char * strcat ( char * destination, const char * source );1.2.1 功能
功能：将source指向的字符串接在destination指向的字符串后面，并返回指向destination指向的字符串的指针。
1.2.2 实现条件
1.源字符串（source指向的字符串）必须以 '\0' 结束。
2.目标空间必须有足够的大，能容纳下源字符串的内容。
3.目标空间必须可修改。
1.2.3 模拟实现
#include <stdio.h>
#include<assert.h>
char* my_strcat(char* dest, const char* src)
{
assert(dest && src);
char* ret = dest;
while (*dest)
{
dest++;
}
while (*dest++ = *src++)
{
;
}
return ret;
}
int main()
{
char arr1[20] = "hello ";
char arr2[] = "world!";
printf("%s\n", my_strcat(arr1, arr2));
return 0;
}1.2.4 效果
1.3 strcmp
int strcmp ( const char * str1, const char * str2 );1.3.1 功能
功能：比较两个字符串大小
1.3.2 关于返回值
第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字
1.3.3 字符串比较依据
字符串大小的比较是从首字符开始比较，比较的是字符相应ascII 值的大小，如相同则比较下一个字符大小，直到遇到 '\0' 。
1.3.4 模拟实现
#include <stdio.h>
#include<assert.h>
int my_strcmp(const char* string1, const char* string2)
{
assert(string1 && string2);
while (*string1 == *string2)
{
string1++;
string2++;
}
return *string1 - *string2;
}
int main()
{
char arr1[] = "abcdef";
char arr2[] = "abcdm";
printf("%d\n", my_strcmp(arr1, arr2));
return 0;
}1.3.5 效果
2.长度受限制的字符串函数介绍
2.1 strncpy
char * strncpy ( char * destination, const char * source, size_t num );2.1.1 功能
功能与strcpy相似，只是限制了拷贝的字符个数num。
2.1.2 拷贝规则
1.拷贝num个字符从源字符串到目标空间
2.如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。
2.1.3 效果展示
2.2 strncat
char * strncat ( char * destination, const char * source, size_t num );2.2.1 功能
功能：与strcat类似，只是限制了连接字符的个数num。
2.2.2 效果展示
2.3 strncmp
int strncmp ( const char * str1, const char * str2, size_t num )2.3.1 功能
功能：与strcmp类似，只是限制了比较的字符个数num。
2.3.2 效果展示
3.内存操作函数
3.1 memcpy
void * memcpy ( void * destination, const void * source, size_t num );3.1.1 功能
功能：函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
3.1.2 规则
1.这个函数在遇到 '\0' 的时候并不会停下来。
2.如果source和destination有任何的重叠，复制的结果都是未定义的。
对于2 举例说明：
如果有整形数组 arr[10] = { 1,2,3,4,5,6,7,8 }
想要将 1~5 放到 3~7 的位置，实现效果{ 1,2,1,2,3,4,5,8 }
如果 memcpy(arr+2,arr,20) (一个整形占4个字节，5个整形20个字节）
结果可能是 { 1,2,1,2,1,2,1,8 }3.1.3 模拟实现
#include <stdio.h>
#include<assert.h>
void* my_memcpy(void* dst, const void* src, size_t count)
{
assert(dst && src);
void* ret = dst;
while (count--)
{
*(char*)dst = *(char*)src;
dst = (char*)dst + 1;
src = (char*)src + 1;
}
return ret;
}
int main()
{
int arr1[] = {1,2,3,4,5,6,7,8,9,10};
int arr2[] = { 9,8,7,6,5 };
my_memcpy(arr1 , arr2, 20);
int sz = sizeof(arr1) / sizeof(arr1[0]);
for (int i = 0; i < sz; i++)
{
printf("%d ", arr1[i]);
}
return 0;
}3.1.4 效果展示
3.2 memmove
void * memmove ( void * destination, const void * source, size_t num );3.2.1 功能
功能：和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
3.2.2 模拟实现
#include <stdio.h>
#include<assert.h>
void* my_memmove(void* dst, const void* src, size_t count)
{
assert(dst && src);
void* ret = dst;
if (dst < src)
{
while (count--)
{
*(char*)dst = *(char*)src;
dst = (char*)dst + 1;
src = (char*)src + 1;
}
}
else
{
while (count--)
{
*((char*)dst + count) = *((char*)src + count);
}
}
return ret;
}
int main()
{
int arr1[] = {1,2,3,4,5,6,7,8,9,10};
my_memmove(arr1 + 4, arr1, 20);
int sz = sizeof(arr1) / sizeof(arr1[0]);
for (int i = 0; i < sz; i++)
{
printf("%d ", arr1[i]);
}
return 0;
}3.2.3 效果
3.3 memcmp
int memcmp ( const void * ptr1, const void * ptr2, size_t num );3.3.1 功能
功能：与strcpy相似，不过memcmp比的是内存中num个字节的大小。（比较从ptr1和ptr2指针开始的num个字节）
3.3.2 返回值
第一个大于第二个，则返回大于0的数字
第一个等于第二个，则返回0
第一个小于第二个，则返回小于0的数字
3.3.3 效果展示及说明
1000
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
