C语言字符函数与字符串函数及内存函数
今天我们来学习C语言中一些常见的字符函数和字符串函数以及内存函数。
一.字符函数
为了⽅便操作字符和字符串，C语⾔标准库中提供了⼀系列库函数。
C语⾔中有⼀系列的函数是专⻔做字符分类的，也就是⼀个字符是属于什么类型的字符的。
这些函数的使⽤都需要包含⼀个头⽂件是 ctype.h
- iscntrl 任何控制字符
- isspace 空格字符，例如’\0’,‘\n’
- isdigit 十进制数字0~9
- islower 小写字母
- isupper 大写字母
- isalpha 字母（大小写）
- ispunch 标点符号，任何不属于数字或字母的图形字符（可打印）
- isgraph 任何图形字符
- isprint 任何可打印字符
这些字符函数的使用方法非常相似，只要函数的参数符合要求就会返回真，下面以isupper举例
#include<stdio.h>
#include<ctype.h>
int main()
{
char a = 'B';
printf("%d\n", isupper(a));
return 0;
}
二.字符转换函数
C语言中提供了两个字符转换函数，方便将字符转换大小写。它们同样也包含在ctype.h头文件中。
1.toupper 小写转大写
2.tolower 大写转小写
示例：
#include<stdio.h>
#include<ctype.h>
int main()
{
char arr[] = "DIan NAo Fei Cai";
char c;
int i = 0;
while (arr[i])
{
c = arr[i];
if (islower(arr[i]))
{
c=toupper(c);
}
i++;
putchar(c);
}
return 0;
}
这里使用的就是toupper函数，将小写字母全部转为大写字母
三.字符串函数
这些字符串函数都包含在string.h头文件中
1.strcpy
strcpy函数的使用和模拟实现：
strcpy中str是字符串的意思，cpy是copy的简称，所以strcpy就是字符串拷贝函数，是将source中的字符串拷贝到destination中，下面通过代码来演示strcpy
#include<stdio.h>
int main()
{
char arr1[30] = { 0 };
char arr2[] = "dian nao fei cai";
strcpy(arr1, arr2);
printf("%s\n", arr1);
return 0;
}
可以看到，原来arr1数组中的元素都是0，strcpy拷贝后arr1数组中的元素就和arr2数组中的元素一模一样了
使用strcpy函数时一定要注意以下几点：
1.源字符串必须以 ‘\0’ 结束。
2.会将源字符串中的 ‘\0’ 拷⻉到⽬标空间。
3. ⽬标空间必须⾜够⼤，以确保能存放源字符串。
4. ⽬标空间必须可修改。
我们来对strcpy函数进行模拟实现：
char* my_strcpy(char* dest, const char* src)
{
assert(src != NULL);
assert(dest != NULL);
char* ret = dest;
while (*dest++ = *src++)//++优先级虽高于*，但++效果是后置的，也就是先*，再加加
{ //先赋值再判断表达式，由于\0的ASCII值为0，所以dest=\0时表达式为假
;
}
return ret;
}
int main()
{
char arr1[20];
char arr2[] = "*a*b*c*d*";
//模拟函数实现strcpy函数
my_strcpy(arr1,arr2);
printf("%s\n", arr1);
return 0;
}
2.strcmp
cmp是compare的简称，所以strcmp就是字符串的比较
那么该如何比较两个字符串呢，有以下几个标准规定：
第⼀个字符串⼤于第⼆个字符串，则返回⼤于0的数字
第⼀个字符串等于第⼆个字符串，则返回0
第⼀个字符串⼩于第⼆个字符串，则返回⼩于0的数字
那么如何判断两个字符串？ ⽐较两个字符串中对应位置上字符ASCII码值的⼤⼩。
#include<stdio.h>
int main()
{
char arr1[] = "abcd";
char arr2[] = "abcq";
int ret =strcmp(arr1, arr2);
printf("%d\n", ret);
return 0;
}
很显然arr1数组中前三位元素和arr2数组中的前三位相同，但是arr2数组中的第四位元素q的ASCII码值大于arr1数组中的第四位元素d的ASCII码值大，故返回一个小于零的数。
下面进行strcmp函数的模拟实现
int my_strcmp(const char* p1, const char* p2)
{
assert(p1 && p2);
while (*p1 == *p2)
{
if (*p1 == '\0')
{
return 0;
}
p1++;
p2++;
}
return *p1 - *p2;
}
int main()
{
char arr1[] = "abcdqef";
char arr2[] = "abcdgh";
//模拟实现strcmp
int ret = my_strcmp(arr1, arr2);
printf("%d\n", ret);
return 0;
}
3.strcat
cat是catenate的简称，是连接的意思就是将两个字符串连接起来。
使用strcat函数需要注意以下几点：
源字符串必须以 ‘\0’ 结束。
⽬标字符串中也得有 \0 ，否则没办法知道追加从哪⾥开始。
⽬标空间必须有⾜够的⼤，能容纳下源字符串的内容。
⽬标空间必须可修改。
#include<stdio.h>
#include<string.h>
int main()
{
char arr1[] = "dian nao";
char arr2[] = " fei cai";
strcat(arr1, arr2);
printf("%s\n", arr1);
return 0;
}
下面对strcat的模拟实现：
char* my_strcat(char* dest, const char* src)
{
assert(src != NULL);
assert(dest != NULL);
char* ret = dest;
while (*dest != '\0')
{
dest++;
}
while (*dest++ = *src++)
{
;
}
return ret;
}
int main()
{
char arr1[30] = "guan ";
char arr2[] = "chuan long";
char* ret = my_strcat(arr1, arr2);
//模拟实现strcat
printf("%s\n", ret);
return 0;
}
4.strstr
函数返回字符串str2在字符串str1中第⼀次出现的位置
#include<stdio.h>
#include<string.h>
int main()
{
char arr1[] = "dian nao fei cai";
char arr2[] = "fei";
char *p=strstr(arr1, arr2);
printf("%s\n",p );
return 0;
}
下面进行strstr的模拟实现
char* my_strstr(const char* str1, const char* str2)
{
const char* s1 = NULL;
const char* s2 = NULL;
const char* cur = str1;
if (*str2 == '\0')
{
return (char*)str1;//特殊情况，如果arr2为空
}
while (*cur)
{
s1 = cur;
s2 = str2;
while (*s1!='\0'&&*s2!='\0'&&*s1 == *s2)
{
s1++;
s2++;
}
if (*s2 == '\0')
{
return (char*)cur;
}
cur++;
}
return NULL;
}
int main()
{
char arr1[]="this is an banana";
char arr2[] = "is";
//模拟实现strstr
char* ret = my_strstr(arr1, arr2);
if (ret != NULL)
{
printf("%s\n", ret);
}
else
{
printf("找不到\n");
}
return 0;
}
5.strtok
str指向一个包含一个或多个分隔符分割的字符串，delimiters指向的是定义了⽤作分隔符的字符串。
strtok函数找到str中的下⼀个标记，并将其⽤ \0 结尾，返回⼀个指向这个标记的指针。（注：
strtok函数会改变被操作的字符串，所以在使⽤strtok函数切分的字符串⼀般都是临时拷⻉的内容
并且可修改。）
strtok函数的第⼀个参数不为NULL ，函数将找到str中第⼀个标记，strtok函数将保存它在字符串
中的位置。
strtok函数的第⼀个参数为 NULL ，函数将在同⼀个字符串中被保存的位置开始，查找下⼀个标
记。
如果字符串中不存在更多的标记，则返回 NULL 指针。
int main()
{
char arr[] = "li@gou?dan.ya,ya";
char arr2[100] = { 0 };
const char* cp = "@.,?";//分隔符数组
char* ret = NULL;
strcpy(arr2, arr);
for (ret = strtok(arr2, cp); ret != NULL; ret = strtok(NULL, cp))
{
//将分隔符改变成\0,并记录此时的地址，返回字符串开始时的地址
//第一次使用时strtok(arr2,cp)
//再次分割时，由于已经记下分隔符的地址，不再使用数组名(起始位置），而是使用空指针NULL
printf("%s\n",ret);
}
return 0;
}
6.strerror
strerror函数可以把参数部分错误码对应的错误信息的字符串地址返回来。
在不同的系统和C语⾔标准库的实现中都规定了⼀些错误码，⼀般是放在 errno.h 这个头⽂件中说明
的，C语⾔程序启动的时候就会使⽤⼀个全⾯的变量errno来记录程序的当前错误码，只不过程序启动
的时候errno是0，表⽰没有错误，当我们在使⽤标准库中的函数的时候发⽣了某种错误，就会讲对应
的错误码，存放在errno中，⽽⼀个错误码的数字是整数很难理解是什么意思，所以每⼀个错误码都是
有对应的错误信息的。strerror函数就可以将错误对应的错误信息字符串的地址返回。
#include <errno.h>
#include <string.h>
#include <stdio.h>
int main()
{
int i = 0;
for (i = 0; i <= 10; i++) {
printf("%s\n", strerror(i));
}
return 0;
}
四.内存函数
内存函数同样定义在string.h头文件中
1.memcpy
mem在C语言中是内存的意思，前面我们学习的strcpy拷贝数据的类型受到限制，但是memcpy就不会收到那么多限制，因为memcpy是针对内存的，不管什么类型的数据都能拷贝
#include<stdio.h>
#include<string.h>
int main()
{
int arr1[100] = { 0 };
int arr2[10] = { 1,2,3,4,5,6,7,8,9,10 };
memcpy(arr1, arr2, 20);
int i = 0;
for (i; i < 5; i++)
{
printf("%d ", arr1[i]);
}
return 0;
}
需要注意的是memcpy的第三个参数是以字节为单位的，上述代码是20个字节，由于复制的是int类型的数据，所以拷贝的就是前五个数
memcpy拷贝完成后返回目标空间的起始地址
这个函数在遇到 ‘\0’ 的时候并不会停下来。
如果source和destination有任何的重叠，复制的结果都是未定义的。
memcpy的模拟实现：
void* my_memcpy(void* dest, void* src, size_t num)
{
assert(src && dest);
void* ret = dest;
int i = 0;
for (i; i < num; i++)
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
return ret;
}
int main()
{
int arr1[20] = {0};
int arr2[10] = { 0,1,2,3,4,5,6,7,8,9 };
//memcpy(arr1, arr2, 20);//针对内存块拷贝，mem在C语言中是内存的意思
// 源内存块与目标内存块是不能重叠的，重叠的拷贝是无效的
//模拟实现memcpy
my_memcpy(arr1, arr2, 20);//第三个参数单位为字节
int i = 0;
for (i; i < 20; i++)
{
printf("%d ", arr1[i]);
}
return 0;
}
2.memmove
如果拷贝的数据内容有重叠的部分，那么就用到了memmove函数
#include<stdio.h>
#include<string.h>
#include<assert.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
memmove(arr + 2, arr, 20);
int i = 0;
for (i; i < 10; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
memmove的模拟实现：
//memmove拷贝完成后返回目标空间的起始地址
void* my_memmove(void* dest, const void* src, size_t num)
{
void* ret = dest;
assert(src && dest);
if (dest < src)
{
//前->后
int i = 0;
for (i; i < num; i++)
{
*(char*)dest = *(char*)src;
dest = (char*)dest + 1;
src = (char*)src + 1;
}
}
else
{
//后->前
int i = 0;
for (i; i < num; i++)
{
*((char*)dest+num-1-i) = *((char*)src+num-1-i);
}
}
return ret;
}
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
// 1 2 1 2 3 4 5 8 9 10
// 3 4 5 6 7 6 7 8 9 10
my_memmove(arr , arr+2, 20);//可以拷贝重叠的内存块
int i = 0;
for (i; i < 10; i++)
{
printf("%d ", arr[i]);
}
return 0;
}
3.memset
memset是⽤来设置内存的函数，可以将内存中的值以字节为单位设置成想要的内容
int main()
{
int arr[5] = { 0 };
memset(arr, 1, 20);
int i = 0;
for (i; i < 5; i++)
{
printf("%d ", arr[i]);
}//输出结果为16843009 16843009 16843009 16843009 16843009
//因为memset函数是按照字节设置的，上述代码一个整形就会被设置成0x010101
return 0;
}
4.memcmp
⽐较从ptr1和ptr2指针指向的位置开始，向后的num个字节
如果str1指向的内容大于str2指向的内容则返回一个大于0的数，如果str1指向的内容小于str2指向的内容则返回一个小于0的数，如果相同则返回0.
int main()
{
int arr1[] = { 0,1,2,3,4,5,6 };
int arr2[] = { 1,1,2,3,4,5,7 };
int ret = memcmp(arr1, arr2, 20);
printf("%d\n", ret);
return 0;
}
7598
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
