字符以及字符串函数
这篇文章注意讲述了库函数中常见字符函数以及字符串函数的使用，以及注意事项，同时模拟实现部分函数.本文主要使用网站链接: cplusplus
求字符串长度
strlen
- strlen介绍
size_t strlen(const char* str);
获取字符串长度：C 字符串的长度由终止 null 字符决定：C 字符串的长度与字符串开头和终止 null 字符之间的字符数（不包括终止 null 字符本身）一样长。
- 头文件：#include<string.h>
- 参数：字符串
- 返回值：字符串的长度
注意事项 ：
1.strlen 是求字符串长度的，求出的长度不可以为负，所以返回类型为size_t，是无符号的（size_t可以看作是umsigned int 类型，但俩者不同之处在于俩个size_t的返回值相减得到的值任然是size_t）
2.字符串已经将'\0'作为结束标志，strlen函数返回的是在字符串中'\0'前面出现的字符个数（不包含'\0'）
3.参数指向的字符串必须要以'\0'为结束标准
- 实际使用：
c
//strlen的实际使用
#include<stdio.h>
#include<string.h>
int main(void)
{
char arr[] = "hello!";
int ret1 = (int)strlen(arr);
printf("%d\n", ret1);
printf("%d\n", (int)strlen("future"));
return 0;
}- 运行截图 ：
- 模拟实现 ：
方法1：使用计数器模拟实现strlen
c
#include<stdio.h>
#include<assert.h>
//使用计数器模拟实现strlen
size_t my_strlen(const char* str)
{
//断言：字符串不能为空
assert(str);
int count = 0;
while (*str)
{
count++;
str++;
}
return count;
}
int main(void)
{
char arr[] = "Hello China!";
//接收字符串长度
int ret = (int)my_strlen(arr);
//打印
printf("%d ",ret);
return 0;
}方法2：使用递归模拟实现strlen
c
//使用递归模拟实现strlen
#include<stdio.h>
#include<assert.h>
size_t my_strlen(const char* str)
{
//断言：字符串不能为空
assert(str);
if (*str=='\0')
{
return 0;
}
else
{
return 1 + my_strlen(str+1);
}
}
int main(void)
{
char arr[] = "Hello beijing!";
//接收字符串长度
int ret = (int)my_strlen(arr);
//打印
printf("%d", ret);
return 0;
}方法3：使用指针与指针之间的运算模拟实现strlen
c
#define _CRT_SECURE_NO_WARNINGS 1
//使用指针与指针之间的运算模拟实现strlen
#include<stdio.h>
size_t my_strlen(const char* str)
{
char* s = str;
while (*s !='\0')
{
s++;
}
return s - str;
}
int main(void)
{
char arr[] = "Hello shandong！";
//接收返回值
int ret = (int)my_strlen(arr);
//打印
printf("%d", ret);
return 0;
}长度不受限制的字符串函数
strcpy
- strcpy介绍
char* strcpy(char* destination , const char* source)
拷贝字符串：将源指向的 C 字符串复制到目标指向的数组中，包括终止 null 字符（并在该点停止）
- 头文件：#include<string.h>
- 参数destination：指向要复制内容的目标数组的指针
- 参数source：要复制的 C 字符串
- 返回值：返回目标数组起始的指针
注意事项 ：
1.源字符串必须以'\0'结束
2.会将源字符串中的'\0'拷贝到目标空间
3.目标空间必须足够大，以确保能存放源字符串
4.目标空间可变
- 实际使用：
c
//strcpy的实际使用
#include<stdio.h>
#include<string.h>
int main(void)
{
char destination[20] = { 0 };
char source[] = "Hello shanxi!";
//拷贝字符串
strcpy(destination,source);
//打印destination
printf("%s\n",destination);
return 0;
}- 运行截图：
- 模拟实现
c
//模拟实现strcpy
#include<stdio.h>
#include<assert.h>
char* my_strcpy(char* dest, const char* src)
{
//断言
assert(dest && src);
//定义一个返回值
char* ret = dest;
while (*src != '\0')
{
*dest++ = *src++;
}
return ret;
}
int main(void)
{
//destination数组
char dest[30] = { 0 };
//source数组
char src[] = "Hello neimenggu!";
//模拟实现strcpy
my_strcpy(dest, src);
//打印
printf("%s",dest);
return 0;
}strcat
- strcat介绍
char* strcat(char* destinaion,char* source)
追加字符串：将源字符串的副本追加到目标字符串。目标中终止的 null 字符被源的第一个字符覆盖，并且在目标中两者串联形成的新字符串的末尾包含一个 null 字符
- 头文件：#include<stdio.h>
- 参数desitination：指向目标数组的指针，该数组应包含 C 字符串，并且足够大以包含连接的结果字符串
- 参数source：要附加的 C 字符串。这不应与目标重叠
- 返回值：目标数组的地址
注意事项 ：
1.源字符串必须以'\0'结束
2.目标空间必须足够大，能容纳下源字符串的内容
3.目标空间必须可以被修改
4.源字符串和目标空间相同时，可能会出现问题，不建议使用strcat
- 实际使用：
c
//实际使用strcat
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{
char dest[20] = "Hello ";
char src[] = "gansu！";
//使用strcat
strcat(dest, src);
//打印
printf("%s", dest);
return 0;
}- 运行截图 ：
- 模拟实现：
c
//strcat模拟实现
#include<stdio.h>
#include<assert.h>
char* my_strcat(char* dest, const char* src)
{
assert(dest && src);
//将dest的起始位置保存
char ret = dest;
//将dest循环至\0
while (*dest != '\0')
{
dest++;
}
//将src字符串连接在dest后面
while (*src != '\0')
{
*dest = *src;
dest++;
src++;
}
return ret;
}
int main(void)
{
char dest[30] = "Hello ";
char src[] = "heilongjiang!";
//模拟实现strcat
my_strcat(dest, src);
//打印
printf("%s", dest);
return 0;
}strcmp
- strcmp介绍：
int strcmp(const char* str1,const char* str2);
比较俩个字符串:此函数开始比较每个字符串的第一个字符。如果它们彼此相等，则继续执行以下对，直到字符不同或达到终止 null 字符.此函数执行字符的二进制比较。
- 头文件:#include<string.h>
- 参数:被比较的字符串
- 返回值:返回一个整数值，该值指示字符串之间的关系:
| 返回值 | 表明 |
|---|---|
| <0 | 第一个字符串小于第二字符串 |
| 0 | 第一个字符串等于第二个字符串 |
| >0 | 第一个字符串大于第二个字符串 |
注意事项 :
1.比较俩个字符串时比较俩个字符串对应位置的ASCII码值(将其转换为2进制比较)
2.在vs环境下返回>0,=0,<0的值
- 实际使用:
c
//strcmp的实际使用
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{
//俩个不相等的字符串
char str1[] = "Hello!";
char str2[] = "hello!";
//俩个相等的字符串
char str3[] = "liaoning";
char str4[] = "liaoning";
//比较1和2
int ret1 = strcmp(str1, str2);
//打印
printf("%d\n",ret1);
//比较3和4
int ret2 = strcmp(str3, str4);
//打印
printf("%d\n", ret2);
return 0;
}-
运行结果 :
-
模拟实现:
c
#define _CRT_SECURE_NO_WARNINGS 1
//strcmp的模式实现
#include<stdio.h>
#include<assert.h>
int my_strcmp(const char* str1, const char* str2)
{
//断言
assert(str1 && str2);
int cmp = 0;
//循环相同的字符
while (*str1 ==*str2)
{
if (*str1 == '\0')
{
return 0;
}
str1++;
str2--;
}
//比较不同的字符
if (*str1 > *str2)
{
return 1;
}
else
{
return -1;
}
}
int main(void)
{
char str1[] = "Hello Tianjin！";
char str2[] = "Hello tianjin！";
//模拟实现strcmp
int ret = my_strcmp(str1, str2);
//打印
printf("%d", ret);
return 0;
}长度受限制的字符串函数
strncpy
- strncpy介绍:
char * strncpy(char* destination,const char* source,size_t num);
从字符串中复制字符:将源的前 num 个字符复制到目标。如果在复制 num 个字符之前找到源 C 字符串的末尾（由 null 字符表示），则 destination 将用零填充，直到将 num 个字符写入该字符串。
- 头文件:#include<string.h>
- 参数destination:指向要复制内容的目标数组的指针
- 参数source:要复制的 C 字符串
- 参数num:要从源复制的最大字符数(size_t 是无符号整数类型)
- 返回值:返回目标数组起始的指针
注意事项 :
1.如果 source 的长度大于 num，则不会在目标末尾隐式附加 null 字符。因此，在这种情况下，destination 不应被视为以 null 结尾的 C 字符串(这样读取它会溢出)
2.目的地和源不得重叠
3.如果源字符串的长度小于num,则拷贝完字符串之后,在目标的后面追加0,直到num个
- 实际使用:
c
#define _CRT_SECURE_NO_WARNINGS 1
//实际使用strncpy
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{
char destination[20] = "***************";
char source[] = "Hello hebei!";
//从字符串中复制字符
strncpy(destination, source, 12);
//打印
printf("%s", destination);
return 0;
}-
运行结果 :
-
模拟实现:
c
//模拟实现strncpy
#include<stdio.h>
#include<assert.h>
char* my_strncpy(char* destination, const char* source, int num)
{
assert(destination && source);
char* ret = destination;
int i = 0;
while(num--)
{
*destination = *source;
destination++;
source++;
}
return ret;
}
int main(void)
{
char dest[] = "***************";
char src[] = "Hello jilin!";
//模拟实现strncpy
my_strncpy(dest, src, 12);
//打印
printf("%s", dest);
return 0;
}strncat
- strncat介绍:
char* strncat (char* destination,const char* source,num)
从字符串中附加字符:将源的前 num 字符追加到 destination 后，加上一个终止的 null 字符。
- 头文件:#include<string.h>
- 参数destination:指向目标数组的指针
- 参数source:要附加的 C 字符串
- 参数num:要追加的最大字符数(size_t 是无符号整数类型)
注意事项 :
1.如果源代码中 C 字符串的长度小于 num，则仅复制终止 null 字符之前的内容
2.目标数组应包含 C 字符串，并且足够大以包含连接的结果字符串，包括其他 null 字符
- 实际使用:
c
//实际使用strncat
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{
char dest[30] = "Hello ";
char src[] = "xinjiang!";
//使用strncat
strncat(dest,src,3);
//打印
printf("%s",dest);
return 0;
}- 运行截图:
- 模拟实现:
c
//模拟实现strncap
#include<stdio.h>
#include<assert.h>
char* my_strncat(char* dest, const char* src, int num)
{
assert(dest && src);
char* ret = dest;
//循环dest至结束
while (*dest)
{
dest++;
}
//连接字符串
while (num--)
{
*dest = *src;
dest++;
src++;
}
return ret;
}
int main(void)
{
char dest[30] = "Hello ";
char src[] = "xizang!";
//模拟实现strncap
my_strncat(dest, src, 2);;
//打印
printf("%s",dest);
return 0;
}strncmp
- 介绍strncmp:
int strncmp (const char* str1,const char* str2);
比较两个字符串的字符:将 C 字符串 str1 的字符数与 C 字符串 str2 的字符数进行比较。
- 头文件:#include<string.h>
- 参数str1:要比较的 C 字符串
- 参数str2:要比较的 C 字符串
- 参数num:要从源复制的最大字符数(size_t 是无符号整数类型)
- 返回值:返回一个整数值，该值指示字符串之间的关系:
| 返回值 | 表明 |
|---|---|
| <0 | 第一个字符串小于第二字符串 |
| 0 | 第一个字符串等于第二个字符串 |
| >0 | 第一个字符串大于第二个字符串 |
注意事项 :
1.此函数开始比较每个字符串的第一个字符。
2.如果它们彼此相等，则继续执行以下对，直到字符不同，直到达到终止的 null 字符，或者直到两个字符串中的 num 个字符匹配，以先发生者为准
- 实际使用:
c
//实际使用strncmp
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{
char str1[] = "Hello Qinghai!";
char str2[] = "Hello qinghai!";
//比较字符串
int ret = strncmp(str1,str2,10);
//打印
printf("%d",ret);
return 0;
}- 运行结果:
- 模拟实现:
c
//模拟实现strncmp
#include<stdio.h>
#include<assert.h>
int my_strncmp(const char* str1, const char* str2, int num)
{
assert(str1 && str2);
while (*str1 == *str2 && num)
{
if (*str1 == '\0'||num==0)
{
return 0;
}
str1++;
str2++;
num--;
}
if (*str1 > *str2)
{
return 1;
}
else
return -1;
}
int main(void)
{
char str1[] = "Hello Sichuan!";
char str2[] = "Hello sichuan!";
//模拟实现比较字符串
int ret = my_strncmp(str1, str2, 10);
//打印
printf("%d",ret);
return 0;
}字符串查找
strstr
- strstr介绍：
const char* strstr(const char* str1,const char* str2);
char* strstr(char* str1,const char* str2);
查找子字符串：返回指向 str1 中首次出现的 str2 的指针，如果 str2 不是 str1 的一部分，则返回空指针
- 头文件：#include<string.h>
- 参数str1：要扫描的 C 字符串
- 参数str2：包含要匹配的字符序列的 C 字符串
- 返回值：指向 str1 中指定的整个字符序列在 str1 中首次出现的指针，如果序列在 str1 中不存在，则为空指针
注意事项 ：
1.匹配过程不包括终止 null 字符
- 实际使用：
c
//实际使用strstr
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{
char str1[] = "Hello yunnan!";
char str2[] = "yunnan";
//查找子字符串
char* ret = strstr(str1, str2);
//打印
printf("%s",ret);
return 0;
}- 运行结果：
- 模拟实现：
c
//strstr模拟实现
#include<stdio.h>
#include<assert.h>
const char* my_strstr(const char* str1, const char* str2)
{
assert(str1 && str2);
while (*str1!='\0')
{
//引用俩个指针代替str1,str2
char* S1 = str1;
char* S2 = str2;
//代替指针进入比较循环
while (*S1 == *S2&&*S1!='\0' && *S2 != '\0')
{
S1++;
S2++;
}
if (*S2 == '\0')
{
return str1;
}
str1++;
}
return NULL;
}
int main(void)
{
char str1[] = "Hello hainan!";
char str2[] = "hainan";
//模拟实现strstr
char* ret = my_strstr(str1, str2);
//打印
printf("%s",ret);
return 0;
}strtok
- 介绍strtok：
char* strtok(char* str,const char* delimiters)
将字符串拆分：对此函数的一系列调用将 str 拆分为标记，这些标记是由分隔符中的任何字符分隔的连续字符序列。
- 头文件：#include<stdio,h>
- 参数str：要截断的 C 字符串
- 参数delimiters：包含分隔符的 C 字符串
- 返回值：如果找到分隔符，则指向分隔符开头的指针，否则为空指针
注意事项 ：
1.参数delimiters是个字符串，定义了作用分隔符的字符集合
2.第一个参数指定一个字符串，它包含了0个或者多个由delimiters字符串中一个或者多个分隔符的标记
3.strtok函数找到str中下一个标记，并将其用'\0'结尾，返回一个指向这个标记的指针（注：strtok函数会改变被操作的字符串，返回在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改）
4.strtok函数的第一个参数不为NULL,函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置
5.strtok函数的第一个参数为NULL,函数将在同一个字符串中被保存的位置开始，查找下一个标记
6.如果字符串中不存在更多的标记，则返回NULL指针
- 实际使用：
c
//实际使用strtok
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{
const char str1[] = "Hello!China*I love you+lalalala";
const char del[] = "!*+";
char* ret = NULL;
char s[50];
//拷贝字符串
strcpy(s, str1);
//分割打印
for (ret = strtok(s, del); ret != NULL; ret = strtok(NULL, del))
{
printf("%s\n",ret);
}
return 0;
}- 运行结果：
错误信息报告
strerror
- 介绍strerror：
char* strerror(int errnum)
获得一个指向错误信息的地址：解释 errnum 的值，生成一个字符串，其中包含一条消息，该消息描述错误条件，就像库的函数设置为 errno 一样。返回的指针指向静态分配的字符串，程序不得修改该字符串。对此函数的进一步调用可能会覆盖其内容（不需要特定的库实现来避免数据争用）。strerror 生成的错误字符串可能特定于每个系统和库实现。
- 头文件：#include<stdio.h>
- 参数errnum：错误码
- 返回值：错误信息的地址
注意事项 ：
1.c语言的库函数在运行的时候，如果发生错误，就会将错误存在一个变量中，这个变量是：errno
2.错误码是一些数字：1，2，3，4，5
3.我们需要将错误码翻译成错误信息
- 实际使用：
c
//实际使用strerror
#include<stdio.h>
#include<errno.h>
#include<string.h>
int main(void)
{
//打开文件
FILE* pf = fopen("my.txt","r");
if (pf == NULL)
{
printf("%s",strerror(errno));
}
return 0;
}- 运行结果：
字符分类函数
| 函数 | 参数符合条件则返回真 |
|---|---|
| iscntrl | 任何控制字符 |
| isspace | 空白字符:空格' ',换页'\f',换行'\n',回车'\r',制表符'\t'或者垂直制表符'\v' |
| isdigit | 十进制数字0~9 |
| iscdigit | 十六进制数字,包括十进制数字,小写字母a-f,大写字母A-F |
| islower | 小写字母a-f |
| isupper | 大写字母A-F |
| isalpha | 字母a-z或A-Z |
| isalnum | 字母或者数字0-9,a-z,A-Z |
| ispunct | 标点符号,任何不属于数字或者字母的图形字符(可打印) |
| isgraph | 任何图形字符 |
| isprint | 任何可打印字符,包括图形字符和空白字符 |
字符转换函数
tolower
int tolower(int c)
将大写字母转换为小写
toupper
int toupper(int c)
将小写字母转换为大写
内存操作函数
memcpy
- 介绍memcpy
void* memcpy(void* destination,const void* source,size_t um)
复制内存块:将 num 字节的值从源指向的位置直接复制到目标指向的内存块
- 头文件：#include<string.h>
- 参数destination：指向要拷贝内容的目标数组的指针，类型转换为 void* 类型的指针
- 参数source：指向要拷贝的数据源的指针，类型转换为类型为 const void* 的指针。
- 参数num：要拷贝的字节数（size_t 是无符号整数类型）
- 返回值：返回destination的指针
注意事项：
1.strcpy只能拷贝字符串，而memcpy可以拷贝内存块
2.函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置
3.这个函数在遇到'\0'的时候并不会停下来
4.如果source和的destination有任何的重叠，复制的内容都是未定义的
- 实际使用：
c
//实际使用memcpy
#include<stdio.h>
//头文件
#include<string.h>
int main(void)
{
int src[] = {1,2,3,4,5};
int dest[10];
//使用memcpy
memcpy(dest,src,sizeof(src));
//打印
int i = 0;
for (i = 0; i < (sizeof(src) / sizeof(src[0])); i++)
{
printf("%d ",dest[i]);
}
return 0;
}- 运行结果：
- 模拟实现：
c
//模拟实现memcpy
#include<stdio.h>
#include<assert.h>
void* my_memcpy(void* dest, const void* src, size_t num)
{
assert(dest && src);
void* ret = dest;
while (num--)
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
return ret;
}
int main(void)
{
int src[] = { 1,2,3,4,5,6,7,8,9 };
int dest[10] = { 0 };
//实现memcpy
my_memcpy(dest, src+3, 17);
//打印
int i = 0;
for (i = 0; i < (17 / sizeof(int)); i++)
{
printf("%d ",dest[i]);
}
return 0;
}memmove
- 介绍memmove:
void* memcpy(void* destination,const void* source,size_t um)
移动内存块:将 num 字节的值从源指向的位置复制到目标指向的内存块。复制就像使用了中间缓冲区一样进行，允许目标和源重叠
- 头文件：#include<string.h>
- 参数destination：指向要复制内容的目标数组的指针，类型转换为 void* 类型的指针
- 参数source：指向要复制的数据源的指针，类型转换为类型为 const void* 的指针。
- 参数num：要复制的字节数（size_t 是无符号整数类型）
- 返回值：返回destination的指针
注意事项：
1.与memcpy的差别就是memmove函数处理的源内存和目标内存块是可以重叠的
2.如果源空间和目标空间出现重叠，就可以使用memmove
- 实际使用：
c
//实际使用memmove
#include<stdio.h>
#include<string.h>
int main(void)
{
int str[] = { 1,2,3,4,5,6,7,8 };
//使用memmove
//模拟实现memmove
memmove(str + 2, str, 20);
//打印
int i = 0;
for (i = 0; i < (sizeof(str) / sizeof(str[0])); i++)
{
printf("%d ", str[i]);
}
return 0;
}- 运行结果：
- 模拟实现：
c
//模拟实现memmove
#include<stdio.h>
#include<assert.h>
void* my_memmove(void* dest, const void* src, size_t num)
{
void* ret = dest;
assert(dest && src);
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(void)
{
int str[] = { 1,2,3,4,5,6,7,8,9,10 };
//模拟实现memmove
my_memmove(str + 2, str, 20);
//打印
int i = 0;
for (i = 0; i < (sizeof(str) / sizeof(str[0])); i++)
{
printf("%d ",str[i]);
}
return 0;
}memcmp
比较俩个内存块：将 ptr1 指向的内存块的第一个 num 字节与 ptr2 指向的第一个 num 字节进行比较，如果它们都匹配，则返回零，或者如果它们不匹配，则返回与零不同的值，表示哪个值更大
int memcmp ( const void * ptr1, const void * ptr2, size_t num );
- 头文件：#include<string.h>
- 参数ptr1：指向内存块的指针
- 参数ptr2：指向内存块的指针
- 参数num：要比较的字节数
- 返回值：返回一个整数值，该值指示字符串之间的关系
| 返回值 | 表明 |
|---|---|
| <0 | 在两个内存块中不匹配的第一个字节在 PTR1 中的值低于 PTR2 中的值（如果计算为无符号字符值） |
| 0 | 两个内存块的内容相等 |
| >0 | 在两个内存块中不匹配的第一个字节在 PTR1 中的值高于 PTR2 中的值（如果计算为无符号字符值） |
- 实际使用：
c
//实际使用memcmp
#include<stdio.h>
#include<string.h>
int main(void)
{
int str1[] = { 1,2,3,4,5 };
int str2[] = { 1,2,5,4,5 };
//实际使用memcmp
int ret = memcmp(str1, str2,4);
//打印
printf("%d\n",ret);
ret = memcmp(str1, str2, 12);
//打印
printf("%d\n", ret);
return 0;
}- 运行结果：
memset
- 介绍memset:
void * memset ( void * ptr, int value, size_t num );
填充内存块:将 ptr 指向的内存块的第一个 num 字节设置为指定值（解释为无符号字符）
-
头文件：#include<stdio.h>
-
参数ptr：指向要填充的内存块的指针
-
参数value:要设置的值，该值作为 int 传递，但该函数使用此值的无符号字符转换填充内存块
-
参数num:要填充的字节数（size_t 是无符号整数类型）
-
返回值：返回 ptr的指针
-
实际使用：
c
//实际使用memset
#include<stdio.h>
#include<string.h>
int main(void)
{
char str[] = "************";
//实际使用memset
memset(str, 'a', 5);
//打印
printf("%s",str);
return 0;
}- 运行结果：
