常见库函数小结
库函数说明
库函数（Library
function）是将函数封装入库，供用户使用的一种方式。方法是把一些常用到的函数编完放到一个文件里，供不同的人进行调用。调用的时候把它所在的头文件名用#include<>加到里面就可以了。库函数集合
库函数分类
1.I/O 函数
包括各种控制台I/O、缓冲型文件I/O和UNIX式非缓冲型文件I/O操作。
需要的包含文件：stdio.h
例如:
getchar，putchar，printf，scanf，fopen，fclose，fgetc，fgets，fprintf，fsacnf，fputc，fputs，fseek，fread，fwrite等。
I/O函数汇总
2.字符串、内存和字符函数
包括对字符串进行各种操作和对字符进行操作的函数。
需要的包含头文件：string.h、mem.h、ctype.h
例如：
用于检查字符的函数：isalnum，isalpha，isdigit，islower，isspace等。用于字符串操作函数：strcat，strchr，strcmp，strcpy，strlen，strstr等。
３.数学函数
包括各种常用的三角函数、双曲线函数、指数和对数函数等。 需要的包含文件：math.h
例如：sin，cos，exp（e的x次方），log，sqrt（开平方），pow（x的y次方）等。math函数汇总
４.时间、日期和与系统有关的函数
对时间、日期的操作和设置计算机系统状态等。
需要的包含文件：time.h
例如：
time返回系统的时间；
asctime返回以字符串形式表示的日期和时间。时间,日期和系统相关函数汇总
５.动态存储分配
包括"申请分配"和"释放"内存空间的函数。
需要的包含文件：alloc.h或stdlib.h
例如：calloc，free，malloc，realloc等。
６.目录管理
包括磁盘目录建立、查询、改变等操作的函数。
７.过程控制
包括最基本的过程控制函数。
８.字符屏幕和图形功能
包括各种绘制点、线、圆、方和填色等的函数。
９.其它函数
1.字符串、内存和字符函数
1.1字符函数
1.1.1字符分类函数
| 函数 | 如果其参数符合下列条件就返回真 |
|---|---|
| iscntrl | 任何控制字符 |
| isspace | 空白字符：空格‘ ’，换页‘\f’，换行’\n’，回车‘\r’，制表符’\t’或者垂直制表符’\v’ |
| isdigit | 十进制数字 0~9 |
| isxdigit | 十六进制数字，包括所有十进制数字，小写字母a ~ f，大写字母A~F |
| islower | 小写字母a~z |
| isupper | 大写字母A~Z |
| isalpha | 字母a~ z或A~Z |
| isalnum | 字母或者数字，a~ z,A~ Z,0~9 |
| ispunct | 标点符号，任何不属于数字或者字母的图形字符（可打印） |
| isgraph | 任何图形字符 |
| isprint | 任何可打印字符，包括图形字符和空白字符 |
注：控制字符是ASCII代码0x00（NUL）和0x1f（US）之间的字符，加上0x7f（DEL）；
以上字符函数头文件都是 <ctype.h>，详情见ctype.h
#include <ctype.h>//头文件
int main()
{
int i = 0;
char str[] = "first line \n second line \n";
while (!iscntrl(str[i]))
{
putchar(str[i]);//不是控制字符输出
i++;
}
printf("\n**********\n");
int a = isalnum('9');//是字母或者数字返回一个非0的数
printf("%d\n", a);
printf("**********\n");
int b = isspace(' ');//是空格‘ ’，换页‘\f’，换行'\n'，回车‘\r’，制表符'\t'或者垂直制表符'\v'返回一个非0的数
printf("%d\n", b);
return 0;
}
1.1.2字符转换函数
int tolower ( int c );//将大写字母转换成小写
int toupper ( int c );//将小写字母转换成大写
c为整型是因为字母按照ASCII值（整型）存储。
#include <ctype.h>
int main()
{
int i = 0;
char str[] = "Test String.\n";
char c;
while (str[i])
{
c = str[i];
if (isupper(c))//判断是不是大写字母，是则转换成小写
c = tolower(c);
putchar(c);//输出：test String.
i++;
}
return 0;
}
1.2字符串函数
1.2.1求字符串长度
size_t strlen ( const char * str );
size_t :返回值为无符号整型
const char * str:参数为一地址(指向一字符串)strlen函数详解
- 字符串已经 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包 含 ‘\0’ )。
- 参数指向的字符串必须要以 ‘\0’ 结束。
- 注意函数的返回值为size_t，是无符号的.
1.２.１.１strlen函数的模拟实现－计数器/指针运算/递归实现形式
- 计数器实现形式
int my_strlen(const char* p)
{
int count = 0;
while (*p != '\0')
{
count++;
p++;
}
return count;
}
int main()
{
char arr[] = "abcdef";
int ret = my_strlen(arr);
printf("%d\n", ret);//6
return 0;
}
- 指针-指针实现形式
int my_strlen(char* str)
{
char *start=str;
while(*str!='\0')
{
str++;
}
return str - start;
}
int main()
{
char arr[] = "abcdef";
int ret = my_strlen(arr);
printf("%d\n", ret);//6
return 0;
}
- 递归实现形式
int my_strlen(char* str)
{
if (*str != '\0')
{
return 1 + my_strlen(str + 1);
}
else
return 0;
}
int main()
{
char arr[] = "abcdef";
int ret = my_strlen(arr);
printf("%d\n", ret);//6
return 0;
}
1.2.2长度不受限制的字符串函数介绍
1.2.2.1strcpy
char* strcpy(char * destination, const char * source ); strcpy详解
源字符串必须以 ‘\0’结束(源字符串中间含有’\0’是时,只拷贝到’\0’之前的字符串)。
会将源字符串中的 ‘\0’ 拷贝到目标空间。
目标空间必须足够大，以确保能存放源字符串。
目标空间必须可变(可被拷贝)。即不可为常量字符串.
1.2.2.1.1模拟实现
#include<assert.h>
char* my_strcpy(char* des, const char* sou)
{
assert(des&&sou);
char* ret = des;
while (*des++ = *sou++)
{
;
}
return ret;
}
int main()
{
char arr1[] = "abcdef";
char arr2[20] = { 0 };
my_strcpy(arr2,arr1);
printf("%s\n",arr2);
return 0;
}
1.2.2.2strcat
char * strcat ( char * destination, const char * source ); strcat详解
源字符串必须以’\0’ 结束。
目标空间必须有足够的大，能容纳下源字符串的内容。
目标空间必须可修改。
字符串不可以自己给自己追加，会死循环.
1.2.2.2.1模拟实现
char* my_strcat(char* des, const char* sou)
{
char* ret = des;
assert(des && sou);
while (*des != '\0')
{
des++;
}
while(*des++ = *sou++)
{
;
}
return ret;
}
int main()
{
char arr[20] = "hello ";
my_strcat(arr, "world!");
printf("%s\n", arr);
return 0;
}
1.2.2.3strcmp
int strcmp ( const char * str1, const char * str2 ); strcmp详解
标准规定：
第一个字符串大于第二个字符串，则返回大于0的数字;
第一个字符串等于第二个字符串，则返回0 ;
第一个字符串小于第二个字符串，则返回小于0的数字.
1.2.2.3.1模拟实现
int my_strcmp(const char* str1, const char* str2)
{
while (*str1 == *str2)
{
if(*str1=='\0')
return 0;
str1++;
str2++;
}
return (*str1 - *str2);
}
int main()
{
char arr1[] = "abcdef";
char arr2[] = "abcdf";
int ret = my_strcmp(arr1, arr2);
if (ret < 0)
printf("<\n");
else if (ret > 0)
printf(">\n");
else
printf("==\n");
return 0;
}
1.2.3长度受限制的字符串函数介绍
1.2.3.1strncpy
char * strncpy ( char * destination, const char * source, size_t num); strncpy详解
- 拷贝num个字符从源字符串到目标空间。
- 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个.
int main()
{
char arr1[20] = "abcde";
char arr2[10] = { 0 };
strncpy(arr2, arr1, 10);//不足补0
printf("%s\n", arr2);
return 0;
}
1.2.3.2strncat
char * strncat ( char * destination, const char * source, size_t num );strncat详解
int main()
{
char arr1[20] = "abc";
char arr2[10] = "*****\0*****";
strncat(arr2, arr1,4);//从'\0'开始延长,末尾补'\0'
printf("%s\n", arr2);
return 0;
}
1.2.3.3strncmp
int strncmp ( const char * str1, const char * str2, size_t num );strncmp详解
比较到出现另个字符不一样或者一个字符串结束或者num个字符全部比较完。
返回值同strcmp
int main()
{
char arr1[20] = "abcg";
char arr2[10] = "abcd";
int ret=strncmp(arr2, arr1,3);
if (ret < 0)
printf("<\n");
else if (ret > 0)
printf(">\n");
else
printf("==\n");
return 0;
}
1.2.4字符串查找
1.2.4.1strstr
char * strstr ( const char *str1, const char * str2);strstr详解
在字符串str1中查找字串str2;
返回值为str1中指向str2内容的地址,如果未查找到返回空指针null.
int main()
{
char str[] = "This is a simple string";
char* pch;
pch = strstr(str, "simple");//在str中查找"simple"
strncpy(pch, "sample", 6);//从str中simple的s处拷贝6的字节的"sample"
puts(str);
return 0;
}
1.2.4.1.1模拟实现
char* my_strstr(const char* str1, const char* str2)
{
const char* s1 = str1;
const char* s2 = str2;
const char* p = str1;
while (*p)
{
s1 = p;
s2 = str2;
while (*s1!='\0'&&*s2!='\0'&& *s1 == *s2)
{
s2++;
s1++;
}
if (*s2 == '\0')
return (char*)p;
p++;
}
return NULL;
}
int main()
{
char arr1[] = "You love me,I love you,honey Snow Ice City,sweet honey ";
char arr2[] = "I love you";
char* ret = my_strstr(arr1, arr2);
if (ret == NULL)
{
printf("子字符串不存在！\n");
}
else
printf("%s\n", ret);
return 0;
}
1.2.4.1.2KMP算法
这个算法也是用来实现在一个字符串中查找子字符串的;
效率高，但是实现难度大;
还未学会,待定.
1.2.4.2strtok
char * strtok ( char * str, const char * sep );strtok详解
- sep参数是个字符串，定义了用作分隔符的字符集合;
- 第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记 (包含的分隔符标记数>=0);
- strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记(标记之前的字符串)的指针。
（注:strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）- strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
- strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
- 如果字符串中不存在更多的标记，则返回 NULL 指针。
int main()
{
char* p = "zhongguo*huanyingnin.com";
const char* sep = "*.";
char arr[30];
char* str = NULL;
strcpy(arr, p);//将数据拷贝一份，处理arr数组的内容
str = strtok(arr, sep);//第一次查找第一个参数不可为空,str指向"zhongguo",并将'*'改为'\0'
printf("%s\n", str);
str = strtok(NULL, sep);//从"huanyingnin"(首地址)开始查找,str指向"huanyingnin",并将'.'改为'\0'
printf("%s\n", str);
str = strtok(NULL, sep);//从"com"(首地址)开始查找,str指向"com",末尾有'\0'
printf("%s\n", str);
str = strtok(NULL, sep);//无处查找
printf("%s\n", str);
}
改进代码,防止切割null:
int main()
{
char* p = "zhongguo*huanyingnin.com";
const char* sep = "*.";//选'*','.'作为分隔符
char arr[30];
char* str = NULL;
strcpy(arr, p);//将数据拷贝一份，处理arr数组的内容,不改变原字符串
for (str = strtok(arr, sep); str != NULL; str = strtok(NULL, sep))//原理同上,但加了限制条件:str!=NULL
{
printf("%s\n", str);
}
}
1.2.5错误信息报告
1.2.5.1strerror
char * strerror ( int errnum );
返回错误码，所对应的错误信息。
int main ()
{
FILE * pFile;
pFile = fopen ("test.c","r");
//以只读形式打开文件test.c，打开文件成功将文件地址返回，否则返回空指针，并将错误码存入errno
//errno：c语言设置的一个全局的错误码存放的变量
if (pFile == NULL)
printf ("Error opening filetest.c: %s\n",strerror(errno));//打印错误信息
return 0;
}
1.3内存函数
1.3.1memcpy
void * memcpy ( void * destination, const void * source, size_t num );
- 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
- 这个函数在遇到 ‘\0’ 的时候并不会停下来。
- 如果source和destination有任何的重叠，复制的结果都是未定义的。memcpy详解
int main()
{
int arr1[10] = { 1,2,3,4,5,6,7,8,9 };
int arr2[20] = { 0 };
memcpy(arr2, arr1, 20);//打印20个字节，即1，2，3，4，5
//或者memcpy(arr2, arr1, 5*sizeof(arr1[0]));
int i = 0;
for (i = 0; i < 5; i++)
printf("%d ", arr2[i]);
return 0;
}
注：关键把握好字节大小，不同类型字节不同；
memcpy负责拷贝两块独立空间中的数据,对于重叠内存的拷贝，需要用到memmove函数（在VS2022中memcpy可以实现重叠内存拷贝）
1.3.1.1模拟实现memcpy
void* my_memcpy(void* dest, const void* sour, size_t num)
{
assert(dest && sour);//防止dest和sour为空指针
void* ret = dest;//作为返回值
while (num--)//一个字节一个字节进行拷贝
{
*(char*)dest = *(char*)sour;
dest=(char*)dest+1;
sour = (char*)sour + 1;
}
return ret;
}
1.3.2memmove
void * memmove ( void * destination, const void * source, size_t num);
- 和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
- 如果源空间和目标空间出现重叠，就得使用memmove函数处理memmove详解
int main()
{
int arr1[10] = { 1,2,3,4,5,6,7,8,9 };
memmove(arr1, arr1+5, 20);//将6，7，8，9，0拷贝给1，2，3，4，5
int i = 0;
for (i = 0; i < 10; i++)
printf("%d ", arr1[i]);
printf("\n");
char arr[] = "abc vs fgh";
memmove(arr + 7, arr, 3);//把abc拷贝给fgh
puts(arr);
return 0;
}
1.3.2.1模拟实现memmove
void* my_memmove(void* dest, const void* sour, size_t num)
{
assert(dest && sour);
void* ret = dest;
if (dest <= sour)//从源地址前往后拷贝
{
while (num--)
{
*(char*)dest = *(char*)sour;
dest = (char*)dest + 1;
sour = (char*)sour + 1;
}
}
else//从源地址后往前拷贝
{
while (num--)
{
*((char*)dest+num) = *((char*)sour+num);
}
}
return ret;
}
1.3.3memcmp
int memcmp ( const void * ptr1, const void * ptr2, size_t num );
比较从ptr1和ptr2指针开始的num个字节 memcmp详解
int main()
{
int arr1[10] = { 1,2,3,4,5,6,7,8,9 };
int arr2[10] = { 1,2,3,6,7,8,9,4,5 };
int ret=memcmp(arr1, arr2,sizeof (arr1));//从首元素开始，比较arr1长度的内容
if (ret>0)
printf("arr1 > arr2\n ");
else if (ret < 0)
printf("arr1 < arr2\n ");
else
printf("arr1 = arr2\n ");
ret = memcmp(arr1+4, arr2+8, 4);//arr1的第5个元素（5）与arr2的第9个元素（5）开始，比较4个字节的内容
if (ret > 0)
printf("arr1 > arr2\n ");
else if (ret < 0)
printf("arr1 < arr2\n ");
else
printf("arr1 = arr2\n ");
return 0;
}
1.3.4memset
void * memset ( void * ptr, int value, size_t num );
int main()
{
char arr[] = "abcdefgh";
memset(arr + 3, '*', 2);
puts(arr);
return 0;
}
注意：
对于如图所示的代码，结果为何不是所想呢？
进行调试我们可以看到memset赋值是将每一个字节都设置为1。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
