C语言——字符串及字符函数的介绍
C语言——字符串及字符函数的介绍
- 一、字符函数
-
- 1.strlen
-
- 1.1strlen的使用
- 1.2strlen的三种模拟实现
-
- 1.2.1计数器实现strlen函数
- 1.2.2递归方法实现strlen函数
- 1.2.3指针方法实现strlen函数
- 1.3 注意事项
- 2.strcpy
-
- 2.1strcpy使用
- 2.2strcpy的模拟实现
- 2.3strcpy的注意事项
- 3.strcat
-
- 3.1strcat的使用
- 3.2strcat的模拟实现
- 3.3strcat注意事项：
- 4.strcmp
-
- 4.1strcmp的使用
- 4.2strcmp的模拟实现
- 4.3strcmp注意事项
- 5.strstr
-
- 5.1strstr的使用
- 5.2strstr的模拟实现
- 6.strtok
-
- 6.1strtok的使用
- 6.2strtok的使用注意事项
- 7.memcpy
-
- 7.1memcpy的使用
- 7.2memcpy的模拟实现
- 7.3memcpy的注意事项
- 8.memmove
-
- 8.1memmove的使用
- 8.2memmove的模拟实现
- 8.3memmove的注意事项：
一、字符函数
1.strlen
1.1strlen的使用
int main()
{
char arr1[] = "hello world!";
int ret = strlen(arr1);
printf("%d", ret);
return 0;
}
运行结果：
1.2strlen的三种模拟实现
1.2.1计数器实现strlen函数
int my_strlen(const char* arr1)
{
assert(*arr1);
int count = 0;
while (*arr1 != '\0')
{
*arr1++;
count++;
}
return count;
}
int main()
{
char arr1[] = "hello world!";
int ret = my_strlen(arr1);
printf("%d", ret);
return 0;
}
1.2.2递归方法实现strlen函数
//递归
//不创建临时变量求字符串长度
int my_strlen(const char* str)
{
if (*str != '\0')
return 1 + my_strlen(str + 1);
else
return 0;
}
1.2.3指针方法实现strlen函数
int my_strlen(const char* str)
{
char* p = str;
while (*p != '\0')
{
*p++;
}
return p - str;
}
int main()
{
char arr1[] = "hello world!";
int ret = my_strlen(arr1);
printf("%d", ret);
return 0;
}
1.3 注意事项
①、字符串已经 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )。
②、参数指向的字符串必须要以 ‘\0’ 结束。
③、注意函数的返回值为size_t，是无符号的（ 易错 ）
eg1:
#include 因为strlen函数的返回值为size_t，是无符号的，所以输出值为 printf(“str2>str1\n”);
运行结果：
2.strcpy
2.1strcpy使用
int main()
{
char arr1[] = "hello world!";
char arr2[20];
strcpy(arr2, arr1);
printf("%s", arr2);
return 0;
}
运行结果：
2.2strcpy的模拟实现
char* my_strcpy(char* dest, const char* src)
{
char* ret = dest;
assert(dest && src);
while (*dest ++= *src++)
{
;
}
return ret;
}
int main()
{
char arr1[] = "hello world!";
char arr2[20];
my_strcpy(arr2, arr1);
printf("%s", arr2);
return 0;
}
2.3strcpy的注意事项
①、源字符串必须以 ‘\0’ 结束。
②、会将源字符串中的 ‘\0’ 拷贝到目标空间。
③、目标空间必须足够大，以确保能存放源字符串。
④、目标空间必须可变。
3.strcat
3.1strcat的使用
#include运行结果：
调试过程：
3.2strcat的模拟实现
#include运行结果：
接下来，让我们试试其是否可以追加自己
int main()
{
char arr1[20] = "hello";
char arr2[20] = "world!";
strcat(arr1, arr1);
printf("%s", arr1);
return 0;
}
运行结果：
3.3strcat注意事项：
①、源字符串必须以 ‘\0’ 结束。
②、目标空间必须有足够的大，能容纳下源字符串的内容。
③、目标空间必须可修改
④、strcat()函数并不检查第一个数组是否能够容纳第二个字符串。如果没有为第一个数组分配足够大的空间，多出来的字符溢出到相邻存储单元时就会出现问题。
4.strcmp
4.1strcmp的使用
int main()
{
char arr1[10] = "abcd";
char arr2[10] = "bcde";
int ret = strcmp(arr1, arr2);
printf("%d", ret);
return 0;
}
运行结果：
4.2strcmp的模拟实现
int my_strcmp(const char* arr1, const char* arr2)
{
assert(arr1 && arr2);
while (*arr1 == *arr2)
{
if (*arr1 == '\0')
return 0;
arr1++;
arr2++;
}
return *arr2 - *arr1;
}
int main()
{
char arr1[10] = "abcd";
char arr2[10] = "bcde";
int ret = my_strcmp(arr1, arr2);
printf("%d", ret);
return 0;
}
运行结果：
4.3strcmp注意事项
1.初学者常常会编写下面的表达式
if(strcmp(a,b))
他认为如果两个字符串相等，它的结果将是真。但是，这个结果将正好相反，因为在两个字符串相等的情况下返回值是零（假）。然而，把这个返回值当作布尔值进行测试是一致坏的风格，因为它具有三个截然不同的结果：小于、等于和大于。所以更好的方法是把这个返回值与零进行比较。
2.标准并没有规定用于提示不相等的具体值。它只是说如果第1个字符串大于第2个字符串，就返回一个大于零的值；如果第1个字符串小于第2个字符串，就返回一个小于零的值。一个常见的错误是以为返回值是1和-1，分别代表大于和小于，但这并不总是正确的。
3.由于strcmp并不修改它的任何一个参数，因此不存在溢出数组的危险。但是，和其他不受限制的字符串函数一样，strcmp函数的字符串函数也必须以一个NUL字节结尾。如果并非如此，strcmp就可能对参数后面的字节进行比较。这个比较将不会有什么呢意义。
5.strstr
5.1strstr的使用
#include运行结果：
5.2strstr的模拟实现
char *my_strstr(const char* str1, const char* str2)
{
char* s1 = NULL;
char* s2 = NULL;
char* cp =(char*) str1;
while (*cp)
{
s1 = cp;
s2 = (char*)str2;
while (*s1 && *s2 && *s1 == *s2)
{
s1++;
s2++;
}
if (*s2 == '\0')
{
return cp;
}
cp++;
}
}
int main()
{
char arr1[10] = "abcde";
char arr2[10] = "bcdef";
char* ret = my_strstr(arr1, arr2);
if (ret == NULL)
{
printf("找不到\n");
}
else
printf("%s", ret);
return 0;
}
6.strtok
6.1strtok的使用
第一种方法：
int main()
{
char arr1[20] = "[email protected]";
const char *arr2 = "@.";
char* str = strtok(arr1, arr2);
printf("%s\n", str);
str = strtok(NULL, arr2);
printf("%s\n", str);
str = strtok(NULL, arr2);
printf("%s\n", str);
return 0;
}
第二种方法：
int main()
{
char arr1[20] = "[email protected]";
char arr2[30] = { 0 };
strcpy(arr2, arr1);
const char *p = "@.";
char* str = NULL;
for (str = strtok(arr2, p); str!= NULL; str = strtok(NULL, p))
{
printf("%s\n",str);
}
return 0;
}
运行结果：
6.2strtok的使用注意事项
①、第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
②、strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
③、strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标
记。如果字符串中不存在更多的标记，则返回 NULL 指针。
7.memcpy
7.1memcpy的使用
int main()
{
int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
int arr2[10] = { 0 };
memcpy(arr2, arr1,20);
int i = 0;
for (i = 0; i < 5; i++)
{
printf("%d", arr2[i]);
}
return 0;
}
运行结果：
7.2memcpy的模拟实现
void* my_strcpy(void* dest, const void* src, size_t nums)
{
assert(dest && src);
void* ret = dest;
while (nums--)
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
return ret;
}
int main()
{
float arr1[10] = { 1.0f,2.0f,3.0f,4.0f,5.0f,6.0f,7.0f,8.0f,9.0f,10.0f };
float arr2[5] = { 0 };
my_strcpy(arr2, arr1, 20);
int i = 0;
for (i = 0; i < 7; i++)
{
printf("%f ", arr2[i]);
}
return 0;
}
7.3memcpy的注意事项
①、函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
②、这个函数在遇到 ‘\0’ 的时候并不会停下来。
③、如果source和destination有任何的重叠，复制的结果都是未定义
8.memmove
8.1memmove的使用
memmove
int main()
{
int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
memmove(arr1 + 2, arr1, 20);
for (int i = 0; i < 10; i++)
{
printf("%d ", arr1[i]);
}
return 0;
}
运行结果：
8.2memmove的模拟实现
void* my_memmove(void* dest, void* src, size_t num)
{
assert(dest && src);
void* ret = dest;
//前-》后
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[10] = { 1,2,3,4,5,6,7,8,9,10 };
my_memmove(arr1 + 2, arr1, 20);
for (int i = 0; i < 10; i++)
{
printf("%d ", arr1[i]);
}
return 0;
}
运行结果：
8.3memmove的注意事项：
①.和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
②.如果源空间和目标空间出现重叠，就得使用memmove函数处理。