前言
1. 函数介绍
长度不受限制的字符串函数
1.1 strlen
函数原型:size_t strlen ( const char * str );
- 字符串已 '\0' 作为结束标志,strlen函数返回的是在字符串中 '\0' 前面出现的字符个数(不包 含 '\0' )。
- 参数指向的字符串必须要以 '\0' 结束。
- 注意函数的返回值为size_t,是无符号的int类型( 易错 )
- 学会strlen函数的模拟实现
实现方法有三种:计数器 递归 指针 三种方法
1.计数器
#include<assert.h>
size_t my_strlen(const char* start)
{
assert(start != NULL); //避免start为空指针
int count = 0;
while (*start++ != 0) //++比*的优先级高
count++;
return count;
}
2.递归
size_t my_strlen(const char* start)
{
assert(start != NULL); //防止接收的指针为空指针导致出错
if (*start != 0) //如果指针指向的内容不为‘\0’则指针向后移动一位调用本身。
return 1+my_strlen(start + 1);
else //如果所指内容为‘\0’则返回0
return 0;
}
3.指针
size_t my_strlen(const char* start)
{
char* end = start;
while (*end++ != 0);
return(size_t)(--end - start);
}
1.2 strcpy
函数原型: char* strcpy ( char * destination , const char * source);
函数注意项:
- 源字符串必须以 '\0' 结束。
- 会将源字符串中的 '\0' 拷贝到目标空间。
- 目标空间必须足够大,以确保能存放源字符串。(不会检查目标空间是否能够撑下)
- 目标空间必须可变。
- 学会模拟实现
函数模拟
char* my_strcpy(char* start, const char* source)
{
char* start1 = start;
while (*start++ = *source++);
return start1;
}
1.3 strcat
函数原型:char * strcat ( char * destination, const char * source );
- 源字符串必须以 '\0' 结束。
- 目标空间必须有足够的大,能容纳下源字符串的内容。
- 目标空间必须可修改。
函数模拟
char* my_strcat(char * arr, const char * arr1)
{
char* start = arr;
while (*arr != 0) ++arr;
while (*arr++ = *arr1++);
return start;
}
![](https://i-blog.csdnimg.cn/blog_migrate/609f14a29943409883a61ac4c7db0222.png)
1.4 strcmp
函数原型:int strcmp ( const char * str1, const char * str2 );
注意事项:
- 标准规定:
- 第一个字符串大于第二个字符串,则返回大于0的数字
- 第一个字符串等于第二个字符串,则返回0
- 第一个字符串小于第二个字符串,则返回小于0的数字
函数模拟
int my_strcmp(const char * one,const char * tow)
{
while (*one != 0 && *tow != 0)
{
if (*one > *tow)
return -1;
else if (*one < *tow)
return 1;
else
{
one++;
tow++;
}
}
if (*one == 0 && *tow!=0)
return -1;
else if (*tow == 0 && *one!=0)
return 1;
else
return 0;
}
那么如何判断两个字符串?
应使用strcmp函数进行字符串中字符单独对比,如果使用字符串直接对比则对应的行为是用常量字符串地址相比较。
长度受限制的字符串
1.5 strncpy
函数原型: char * strncpy ( char * destination , const char * source , size_t num );
- 拷贝num个字符从源字符串到目标空间。
- 如果源字符串的长度小于num,则拷贝完源字符串之后,在目标的后边追加0,直到num个。
- 如果源字符串的长度大于于num,则拷贝完源字符串之后,不会在目标的后边追加0。
函数模拟
char* my_strncpy(char* start, const char* source,size_t num)
{
char* start1 = start;
if (num > strlen(source))
{
while (*start++ = *source++);
for (int i = 0; i < num- strlen(source)-1; i++)
*(start + i) = 0;
return start1;
}
else
{
for (int i = 0; i < num; i++)
*(start + i) = *(source + i);
return start1;
}
}
1.6 strncat
函数原型: char * strncat ( char * destination , const char * source , size_t num );
- 如果源字符串的长度小于num,则链接完源字符串之后,在目标的后边追加一个0。
- 如果源字符串的长度大于于num,则链接完源字符串之后,会在目标的后边追加一个0。
1.7 strncmp
函数原型:int strncmp ( const char * str1, const char * str2, size_t num );
注意事项:
- 返回的值在不同编译器上不同(与strcmp函数一样)但具体规则如上图。
- 与strcmp函数基本类似,不同的地方在于strncmp指定了比较范围。
字符查找函数
1.8 strstr
在str1字符串中寻找子字符串str2,找到了则返回位置。未找到或移到末尾则返回空指针。
函数原型:char * strstr ( const char *str1, const char * str2);
注意事项:
- 如果想在第一次寻找的位置继续向后寻找时,第一个参数只需要传 NULL 。
1.9 strtok
在str字符串中寻找sep字符集中存在的标记替换成'\0'并返回当前地址。
函数原型:char * strtok ( char * str, const char * sep );
注意事项:
- sep参数是个字符串,定义了用作分隔符的字符集合
- 第一个参数指定一个字符串,它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标 记。
- strtok函数找到str中的下一个标记,并将其用 \0 结尾,返回一个指向这个标记的指针。(注: strtok函数会改变被操作的字符串,所以在使用strtok函数切分的字符串一般都是临时拷贝的内容 并且可修改。)
- strtok函数的第一个参数不为 NULL ,函数将找到str中第一个标记,strtok函数将保存它在字符串中的位置。
- strtok函数的第一个参数为 NULL ,函数将在同一个字符串中被保存的位置开始,查找下一个标 记。
- 如果字符串中不存在更多的标记,则返回 NULL 指针。
错误信息报告函数
1.10 strerror
返回错误码,所对应的错误信息。
函数原型: char * strerror ( int errnum );
字符操作函数
这类函数还有很多感兴趣的小伙伴可自行查找学习。
内存操作函数
1.11 memcpy
将source位置处num个字节复制到destination处。
函数原型:void * memcpy ( void * destination, const void * source, size_t num );
注意事项:
- 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
- 这个函数在遇到 '\0' 的时候并不会停下来。
- 如果source和destination有任何的重叠,复制的结果都是未定义的。
函数模拟
void * memcpy ( void * dst, const void * src, size_t count)
{
void * ret = dst;
assert(dst);
assert(src);
/*
* copy from lower addresses to higher addresses
*/
while (count--) {
*(char *)dst = *(char *)src;
dst = (char *)dst + 1;
src = (char *)src + 1;
}
return(ret);
}
1.12 memmove
将指定位置和指定长度拷贝到目标的地址。
函数模型: void * memmove ( void * destination , const void * source , size_t num );
- 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
- 如果源空间和目标空间出现重叠,就得使用memmove函数处理。
函数模拟:
void * memmove ( void * dst, const void * src, size_t count)
{
void * ret = dst;
if (dst <= src || (char *)dst >= ((char *)src + count))
{
/*
* Non-Overlapping Buffers
* copy from lower addresses to higher addresses
*/
while (count--) {
*(char *)dst = *(char *)src;
dst = (char *)dst + 1;
src = (char *)src + 1;
}
}
else {
/*
* Overlapping Buffers
* copy from higher addresses to lower addresses
*/
dst = (char *)dst + count - 1;
src = (char *)src + count - 1;
while (count--) {
*(char *)dst = *(char *)src;
dst = (char *)dst - 1;
src = (char *)src - 1;
}
}
return(ret);
}
1.13 memcmp
int memcmp ( const void * ptr1 , const void * ptr2 , size_t num );