字符串函数与内存函数讲解
文章目录
- 前言
- 一、字符串函数
-
- 1.求字符串长度
-
- strlen
- 2.长度不受限制的字符串函数
-
- (1)strcpy
- (2)strcat
- (3)strcmp
- 3.长度受限制的字符串函数
-
- (1)strncpy
- (2)strncat
- (3)strncmp
- 4.字符串查找
-
- (1)strstr
- (2)strtok
- 5.错误信息报告
-
- (1)strerror
- (2)perror
- 二、内存函数
-
- 1.memcpy
- 2.memmove
- 3.memset
- 4.memcmp
前言
一、字符串函数
1.求字符串长度
strlen
1、功能：求字符串长度
2、使用：
（1）介绍：
说明：
a.返回类型是size_t，也就是无符号整形（只有正数没有负数）
b.参数是char* 类型；加入const修饰是为了防止对str中存放的内容进行修改
c.字符串已经 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )
（2）头文件：
（3）举例：
a.
int main() {
char arr1[] = "abcdefg";
size_t len1 = strlen(arr1);
return 0;
}
解析：
(1)strlen函数做需要的参数是char* 类型，所以创建了一个char类型的数组
(2在不是sizeof(数组名)与 &数组名 的情况下，数组名代表数组首元素的地址，首元素地址的类型是char*
(3)strlen 函数的返回值是size_t类型，也就是无符号的整形，所以我们设置一个相应类型的值来接收它
b.
int main() {
char* arr2 = "abcdef";
size_t len2 = strlen(arr2);
size_t len3 = strlen("abcdef");
printf("%d %d\n",len2,len3);
return 0;
}
结果：
解析：
这里的len2和len3的最后结果其实是一致的，因为len3中的字符串其实传输的也是首元素的地址，属于char*类型，与len2中的传输的值是一样的
c.
int main() {
char* arr3 = "abc\0def";
char* arr4 = "abcde\0f";
size_t len3 = strlen(arr3);
size_t len4 = strlen(arr4);
printf("%d %d\n", len3, len4);
return 0;
}
结果：
解析：
strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )
（4）注意事项：
a.参数指向的字符串必须要以 ‘\0’ 结束。
b.注意函数的返回值为size_t，是无符号的
3、模拟实现：
方法一：
size_t my_strlen(const char* str) {
//计录字符串长度
size_t count = 0;
//当*str='\0'是停止
while (*str) {
count++;
str++;
}
return count;
}
int main() {
char arr1[] = "abcdefg";
size_t len1 = my_strlen(arr1);
printf("%d\n",len1);
return 0;
}
#emsp;方法二
//递归实现
size_t my_strlen(const char* str) {
if (*str == '\0') {
return 0;
}
//这里不能使用后置++，因为它是先使用后++
return 1 + my_strlen(str+1);
}
int main() {
char arr1[] = "abcdefg";
size_t len1 = my_strlen(arr1);
printf("%d\n", len1);
return 0;
}
方法三：
//指针实现
size_t my_strlen(const char* str) {
//创建一个临时变量来接收str
char* p = str;
//对临时变量进行操作更加安全
while (*p != '\0') {
p++;
}
//字符串中有几个字符，p就会往后移动几位
return p - str;
}
int main() {
char arr1[] = "abcdefg";
size_t len1 = my_strlen(arr1);
printf("%d\n", len1);
return 0;
}
2.长度不受限制的字符串函数
(1)strcpy
1、功能：字符串拷贝
2、使用：
（1）介绍：
说明：
a.参数有两个，都是char* 类型：拷贝源与目的地
b.返回值是char* 类型，返回目的地的地址
c.头文件：
(2)注意：
a.源字符串必须以 ‘\0’ 结束,，因为它是拷贝结束的标志，没有的话会一直拷贝，会越界访问
b.会将源字符串中的 ‘\0’ 拷贝到目标空间。
c.目标空间必须足够大，以确保能存放源字符串。
d.目标空间必须可变。
（3）举例：
a.
int main() {
char arr1[20];
char arr2[] = "abcdef";
printf("%s\n",arr1);
strcpy(arr1,arr2);
printf("%s\n",arr1);
return 0;
}
结果：
解析：
未对arr1进行初始化化，所以刚开始赋予的是随机值；在strcpy函数后，为其拷贝了值
3、模拟实现
char* my_strcpy(char* dest,const char* src) {
//设置一个指针来存储目的地的起始地址
char* ret = dest;
//设置断言，防止对空指针解引用
assert(src && dest);
//对dst赋值，当赋值'\0'后不满足条件，退出循环
while (*dest++ = *src++) {
;
}
return ret;
}
int main() {
char arr1[20];
char arr2[] = "abcdef";
my_strcpy(arr1,arr2);
printf("%s\n",arr1);
return 0;
}
(2)strcat
1、功能：字符串追加
2、使用：
（1）介绍：
说明：
a.参数有两个，char*类型：源和目的地
b.返回的是目的地的起始地址
c.本函数是寻找目的地中的’\0’，从’\0’处开始追加源中的字符，并将原来的’\0’替换，将自己的’\0’拷贝过去
（2）注意：
a.必须保证目标空间要足够大
b.目标空间中必须有\0（保证能找到目标空间的末尾）
c.原字符串也得有\0，在拷贝时将\0也拷过去
d.目标空间必须可以修改
（3）举例：
int main() {
char arr1[20] = "abcd";
char arr2[] = "efgh";
strcat(arr1,arr2);
printf("%s\n",arr1);
return 0;
}
结果：
3、模拟实现
char* my_strcat(char* dest,const char* src) {
char* ret = dest;
assert(dest && src);
while (*dest) {
dest++;
}
while ((*dest++ = *src++)) {
;
}
return ret;
}
int main() {
char arr1[20] = "abcd";
char arr2[] = "efgh";
my_strcat(arr1,arr2);
printf("%s\n",arr1);
return 0;
}
(3)strcmp
1、功能：字符串比较
2、使用：
（1）介绍：
说明：
a.参数有两个，是比较的两个数组
b.当字符串1>字符串2时，返回一个>0的数
当字符串1=字符串2，返回一个<0的数
当字符串1<字符串2时，返回一个<0的数
c.两字符串比较的其实是每个字符的ASCII码值
(2)注意：
第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字
（3）举例：
int main() {
char arr1[] = "abbc";
char arr2[] = "abcd";
int ret = strcmp(arr1,arr2);
printf("%d\n",ret);
return 0;
}
3、模拟实现
int my_strcmp(const char* arr1,const char* arr2) {
assert(arr1 && arr2);
while (*arr1 == *arr2) {
arr1++;
arr2++;
if (*arr1 == '\0') {
return 0;
}
}
if (*arr1 > *arr2)
return 1;
if (*arr1 < *arr2)
return -1;
}
int main() {
char arr1[] = "abbc";
char arr2[] = "abcd";
int ret = my_strcmp(arr1,arr2);
printf("%d\n",ret);
return 0;
}
3.长度受限制的字符串函数
(1)strncpy
1、功能：限制数量的字符串拷贝
2、使用：
（1）介绍：
说明：多了一个数量限制，其余的与函数strcpy一致
（2）注意：
a.当源字符串中的字符数没有达到参数的数量时，会在目的地中自动补’\0’，直到达到限定数量
b.目的地的大小应该比限定数量大，否则就会非法访问
（3）举例：
a.
int main() {
char arr1[10];
char arr2[] = "abcdefg";
strncpy(arr1,arr2,10);
printf("%s\n",arr1);
return 0;
}
结果：
(2)strncat
1、功能：限制数量的字符串追加
2、使用：
（1）介绍：
说明：多了一个数量限制，其余与函数strcat一致
（2）注意：
与函数strcat一致
（3）举例：
a.
int main() {
char arr1[20] = "bcc";
char arr2[] = "abcdefg";
strncat(arr1, arr2, 10);
printf("%s\n", arr1);
return 0;
}
结果：
(3)strncmp
1、功能：限制数量的字符串比较
2、使用：
（1）介绍：
（3）举例：
a.
int main() {
char arr1[] = "abc";
char arr2[] = "abcdefg";
int ret = strncmp(arr1, arr2, 4);
printf("%d\n", ret);
return 0;
}
结果：
4.字符串查找
(1)strstr
1、功能：字符串查找
2、使用：
（1）介绍：
说明：
a.有两个参数都是char类型，在str1中查找是否有str2中的字符串
b.返回值是char 类型，返回的是str1中查找的字符串的首地址
（2）注意：
a.如果字符串中有两个查找的字符串，会默认返回第一个找到的字符串的首地址
b.查找不到时会返回Null值
c.查找过程中碰到’\0’就会停止
（3）举例：
a.
int main() {
char arr1[] = "abccbcccf";
char arr2[] = "bccc";
char * ret = strstr(arr1, arr2);
printf("%s\n", ret);
return 0;
}
结果：
b.
int main() {
char arr1[] = "abccbcccf";
char arr2[] = "g";
char * ret = strstr(arr1, arr2);
printf("%s\n", ret);
return 0;
}
结果：
c.
int main() {
char arr1[] = "abc\0bcccf";
char arr2[] = "bccc";
char * ret = strstr(arr1, arr2);
printf("%s\n", ret);
return 0;
}
结果：
3、模拟实现
const char* my_strstr(const char* str1,const char* str2) {
//创建一个临时变量作为查找元素时的定位符
const char* p = str1;
const char* s1;
const char* s2;
assert(str1 && str2);
while (*p) {
//每次都从p处开始比较
s1 = p;
//如果没有完全找到，就要重头开始找
s2 = str2;
//不相等或者任意一方为'\0'时停止
while ((*s1 && *s2 && *s1 == *s2)) {
s1++;
s2++;
}
//判断是否全部找到
if (*s2 == '\0') {
return p;
}
p++;
}
return NULL;
}
int main() {
char arr1[] = "abccbcccf";
char arr2[] = "bc";
char * ret = my_strstr(arr1, arr2);
printf("%s\n", ret);
return 0;
}
(2)strtok
1、功能：字符串分隔
2、使用：
（1）介绍：
说明：
a.有两个参数，都是char类型，第一个是等待分割的字符串，第二个是分隔符
b.返回值是charl类型，返回分隔后的字符串的首地址
（2）注意：
a.每次调用只会对字符串进行一次分隔
b.函数strtok会记住上一次分隔的结束位置，从那个位置开始进行下一次分割，但此次不能为它传输新的字符串指针，只能传输分隔符
（3）举例：
a.
int main() {
char arr1[] = "[email protected]@h";
char* d = "@.";
char* ret = strtok(arr1, d);
printf("%s\n", ret);
return 0;
}
结果：
b.
int main() {
char arr1[] = "[email protected]@h";
char* d = "@.";
for (char* ret = strtok(arr1, d); ret != NULL; ret = strtok(NULL, d)) {
printf("%s\n",ret);
}
return 0;
}
结果:
5.错误信息报告
(1)strerror
1、功能：错误信息反馈
2、使用：
（1）介绍：
a.头文件
b.参数是int类型，是错误所对应的错误码
c.返回值是char* 类型，返回错误码，所对应的错误信息
（2）注意：
a.当程序产生错误时，会自动将错误码放入错误信息errno中
（3）例子：
a.
int main() {
for (int i = 0; i <= 10; i++) {
printf("%d %s\n",i,strerror(i));
}
return 0;
}
结果：
b.
//打开文件
int main() {
//打开成功返回一个FILE* 类型的指针，打开失败返回一个NULL指针
FILE* pfile = fopen("add.txt","r");
//产生错误的时候，会自动的将错误码放入错误信息errno中
if (pfile == NULL) {
printf("打开失败的原因是:%s\n",strerror(errno));
}
return 0;
}
结果：
(2)perror
1、功能：错误信息打印
2、使用：
（1）介绍：
说明：此处参数可传可不传，属于你的自定义信息，类似与printf中你输入的文字，它会默认将程序中的错误信息打印出来，你可以自由加一些自定义信息
(2)注意：
a.打印规则，先打印自定义信息，然后 “ ：空格”，再打印错误信息
（3）实例：
int main() {
FILE* pfile = fopen("add.txt", "r");
if (pfile == NULL) {
perror("打开失败的原因是");
}
return 0;
}
结果：
二、内存函数
内存函数与字符串函数最重要的区别是：内存函数适用于所有类型
1.memcpy
1、功能：内存拷贝
2、使用：
（1）介绍：
说明：
a.头文件：
b.参数有三个，前两个是void* 类型的，是拷贝源于目的地；最后一个是拷贝的字节数
（2）注意：
a.传输的数字是字节数，而不是元素个数
b.函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
c.这个函数在遇到 ‘\0’ 的时候并不会停下来。
d.如果source和destination有任何的重叠，复制的结果都是未定义的。
（3）示例：
a.
int main() {
int arr1[10] = {0};
int arr2[] = { 1,2,3,4,5 };
memcpy(arr1,arr2,20);
return 0;
}
结果：
3、模拟实现
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[10] = { 0 };
int arr2[] = { 1,2,3,4,5 };
my_memcpy(arr1,arr2,20);
return 0;
}
2.memmove
1、功能：内存移动
2、使用：
（1）介绍：
说明：
和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
如果源空间和目标空间出现重叠，就得使用memmove函数处理。
（2）注意：
a.在模拟实现中，起码要有两种情况
（3）示例：
a.
int main() {
char arr1[] = "abcdefgh";
memmove(arr1+2,arr1+3,4);
printf("%s\n",arr1);
return 0;
}
结果：
3、模拟实现：
void* my_memmove(void* dest,const void* src,size_t num) {
void* ret = dest;
assert(dest && src);
//小于时，从后往前拷贝
if (src < dest) {
while (num--) {
*((char*)dest+ num) = *((char*)src+num);
}
}
//其他情况，从前往后拷贝
else{
while (num--) {
*(char*)dest = *(char*)src;
src = (char*)src + 1;
dest = (char*)dest + 1;
}
}
return ret;
}
3.memset
1、功能：内存设置
2、使用：
（1）介绍：
说明：以字节为单位设置值
（2）注意：
a.因为单位是字节，所以最适用于字符类型的数组
（3）示例：
a.
int main() {
char arr1[] = “hello world”;
memset(arr1+6, ‘a’, 5);
printf(“%s\n”,arr1);
}
结果：
4.memcmp
1、功能：内存比较
2、使用：
（1）介绍：
说明：比较两内存空间的前num个字节的内容
（2）注意：
第一个内存块大于第二个内存块，则返回大于0的数字
第一个内存块等于第二个内存块，则返回0
第一个内存块小于第二个内存块，则返回小于0的数字
（3）示例：
a.
int main() {
int arr1[] = { 1,2,3,4,5 };
int arr2[] = { 1,3,3,4,5 };
int ret1 = memcmp(arr1,arr2,4);
//小端存储
int ret2 = memcmp(arr1,arr2,5);
printf("%d %d\n",ret1,ret2);
}
结果：
