C语言常用库函数

最新推荐文章于 2024-03-15 14:44:57 发布
最新推荐文章于 2024-03-15 14:44:57 发布
阅读量1.3k 收藏 19
点赞数
分类专栏： C语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34473360/article/details/114813807
版权

目录

sizeof

sizeof准确的来讲不是一个库函数，而是一个单目运算符。它的参数可以是数组、指针、类型、对象、函数等，用来计算一块内存的大小。如果是字符串，则用sizeof的时候计算结果是包含结束符‘\0’的，因为结束符也是占用空间的。
sizeof是在编译的时候就计算好了缓冲区的长度，因此不能拿来计算和返回动态分配的内存大小。
用例如下：

#include "stdio.h"
#include "string.h"

int main(void)
{
    int arr[10] = {0};
    char arr1[] = "language";
    char arr2[15] = "language";
    printf("%d\n", sizeof(arr));   // 输出40
    printf("%d\n", sizeof(arr1));   // 输出8
    printf("%d\n", sizeof(arr2));   // 输出15
}

strlen

计算字符串长度。该函数返回字符串的长度，从第一个字符开始，到结束符截止，但是不包括结束符。
注意返回值是一个无符号整形数据。
函数形式：


size_t strlen ( const char * str );

用例：

#include "stdio.h"
#include "string.h"

int main(void)
{
    char arr[10] = "strings";
    char arr1[] = "strings";
    unsigned int res = strlen(arr);
    unsigned int res1 = strlen(arr1);
    printf("%d\n", res);   // 输出7
    printf("%d\n", res1);   // 输出7
     return 0;
}

注意sizeof和strlen在求字符串长度时的区别。

strcpy

函数原型：

char * strcpy ( char * destination, const char * source );

将指针source 指向的内存块的内容，复制到指针destination指向的内存快，包括结束符。
需要注意的是指针destination指向的内存快的长度，必须大于或等于指针source指向的内存块长度，否则会造成内存泄露。
用例：

#include <sec_api/string_s.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define DIGI_NUM 10
int main(int argc, const char *argv[])
{
    char arrSource[] = "trustworthness test";
    int len = strlen(arrSource);
    char arrDestination[len + 1];
    strcpy(arrDestination, arrSource);
    printf("%s\n", arrDestination); // trustworthness test

    return 0;
}

strcpy_s

函数原型：

errno_t strcpy_s(char* strDest, size_t destMax, const char* strSrc);

description：复制源字符串到目的缓冲区
strDest：目的缓冲区
destMax：目的缓冲区大小
strSrc：源缓冲区
注: 1.目的缓冲区大小参数不能超过目的缓冲区的实际长度、且必须大于等于（源缓冲区的长度 + 1）
2.源缓冲区和目的缓冲区不能为NULL
3.源缓冲区必须含有结束符。
4.相比strcpy增加目的缓冲区长度参数
用例：

int main(void)
{
    char strSrc[] = "hello world";
    char strDest[100];
    strcpy_s(strDest, sizeof(strDest), strSrc);
    printf("%s\n", strDest);
}

strncpy

函数原型：

char * strncpy ( char * destination, const char * source, size_t num );

复制指针source 指向的内存中的前num个字符到指针destination指向的内存块，包括结束符。
如果num个数大于source的字符个数，则依然复制num个字符，多的那部分填充’\0’ 。
如果num个数少于source的字符的个数，则字符串destination不是以结束符结尾，此时如果访问字符串destination可能会导致溢出，应该手动填充结束符。
用例：

#include <sec_api/string_s.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, const char *argv[])
{
    char arrSource[] = "trustworthness test";
    char arrDestination1[40];
    char arrDestination2[40];

    strncpy(arrDestination1, arrSource, sizeof(arrDestination1));  // 将arrSource的字符复制到arrDestination1，不够的部分用'\0'填充
    printf("%s\n", arrDestination1);   //  trustworthness test

    strncpy(arrDestination2, arrSource, 5);
    arrDestination2[5] = '\0';  // 手动填充结束符
    printf("%s\n", arrDestination2);   //  trust

    return 0;
}

strncpy_s

函数原型：

errno_t strncpy_s(char* strDest, size_t destMax, const char* strSrc, size_t count);

description：复制源字符串到目的缓冲区
strDest：目的缓冲区
destMax：目的缓冲区大小
strSrc：源缓冲区
注: 1.目的缓冲区大小参数不能超过目的缓冲区的实际长度、且必须大于等于（源缓冲区的长度 + 1）
2.源缓冲区和目的缓冲区不能为NULL
3.源缓冲区必须含有结束符。
4.相比stncpy增加目的缓冲区长度参数
用例：

int main(void)
{
    char strSrc[] = "hello world";
    char strDest[100];
    strncpy_s(strDest, sizeof(strDest), strSrc, sizeof(strSrc));
    printf("%s\n", strDest);
    strncpy_s(strDest, sizeof(strDest), strSrc, 4);
    printf("%s\n", strDest);
}

输出：
在这里插入图片描述

strcmp

函数原型：

int strcmp ( const char * str1, const char * str2 );

比较两个字符串，从字符串的首位开始比较起，如果他们相等，则依次往后，直到遇到不相同的字符，或直到结束符。如果字符串1和字符串2相等，则返回0，如果str1小于str2，则返回负数，如果str1大于str2，则返回正数。
用例：

#include <sec_api/string_s.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, const char *argv[])
{
    char arr1[] = "trustworthness test";
    char arr2[] = "trustworthness test";
    char arr3[] = "trustworthness";

    int res1 = strcmp(arr1, arr2);
    int res2 = strcmp(arr2, arr3);
    int res3 = strcmp(arr3, arr2);

    printf("%d\n", res1);   // 0
    printf("%d\n", res2);   // 1
    printf("%d\n", res3);   // -1

    return 0;
}

strcat

函数原型：

char * strcat ( char * destination, const char * source );

连接字符串。将指针source 指向的字符串连接在指针destination指向的字符串后面，并且原来字符串的结束符会被source的首字符覆盖掉，surce的结束符也会转移过去，成为形成的新的字符串的结束符。
连接成功则返回dset的首地址，失败则返回空指针。
用例：

#include <sec_api/string_s.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, const char *argv[])
{
    char str[40];
    strcat(str, "this ");
    strcat(str, "strings ");
    strcat(str, "are ");
    strcat(str, "concatenated.");

    printf("%s\n", str);     // this strings are concatenated.

    return 0;
}

strstr

函数原型：

const char * strstr ( const char * str1, const char * str2 );
      char * strstr (       char * str1, const char * str2 );

比较substring在string中的位置。返回str1中首次出现str2时的地址，如果一直没有出现，则返回空指针。整个匹配的过程不包括结束符，但是结束于结束符。（如果一直没匹配到的话）。
用例：

#include <sec_api/string_s.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, const char *argv[])
{
    char str[40] = "This is a sample string";
    char sbuStr[] = "sample";

    char *res = strstr(str, sbuStr);
    if (res != NULL) {
        printf("find");
    } else {
        printf("not find");
    }

    return 0;
}

memset

函数形式：

void * memset ( void * ptr, int value, size_t num );

函数功能：将ptr指向的内存块的前num个字节设置为指定值。指定值可以是数字，字符等。
ptr是要指向的内存块，value是要被设置的值，num是byte个数，该位为无符号整形数。
该函数常用作内存块初始化

#include "stdio.h"
#include "string.h"

int main(void)
{
    // int arrNum[10];
    int *arrNum = (int*)malloc(10 * sizeof(int));
    memset(arrNum, 0, 10 * sizeof(int));    // 初始化

    char arr[10];
    memset(arr, '0', 9 * sizeof(char));      // 字符串初始化
    memset(arr + 9, '\0', 1 * sizeof(char));

    return 0;
}

memcpy

内存块复制
函数形式：

void * memcpy ( void * destination, const void * source, size_t num );

destination：目标内存块 ， source源内存块，num：字节数
将某一块内存的num个字节复制到目标指向的内存块中。
该函数只是单纯的复制内存块，不会因为结束符而终止。用该函数之前，必须保证源内存和目标内存都大于或等于num个字节。

#include "stdio.h"
#include "string.h"

int main(void)
{
    int arrNum[10] = {0};
    int targetArrNum[10];
    for (int i = 0; i < 10; i++) {
        arrNum[i] = i;
    }
    // 将arrNum内存中的内容复制到targetArrNum中，数组targetArrNum[10]中分别是0 1 2 ..9十个元素
    memcpy(targetArrNum, arrNum, 10 * sizeof(int));
    for (int i = 0; i < 10; i++) {
        printf("%d\n", *(targetArrNum + i));
    }    // 打印的结果分别是0 1 2 3 ....9

    char arr[] = "strings";
    char targetArr[10];
    // memcpy(targetArr, arr, sizeof(arr));
    memcpy(targetArr, arr, strlen(arr) + 1);
    printf("%s\n", targetArr);  // 打印strings

    return 0;
}

malloc

函数形式：

void* malloc (size_t size);

分配一块size大小的内存块，返回指向该内存块首地址的指针。
注意该方法分配的内存块没有经过初始化。
用例：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// #include "test_0315.h"

#define DIGI_NUM 10
int main(int argc, const char *argv[])
{
    int *arrNum = (int*)malloc(DIGI_NUM * sizeof(int)); // 分配一块40个个字节的内存块，指针arrNum指向该内存快的收地址
    memset(arrNum, 0, DIGI_NUM * sizeof(int)); // 内存快初始化

    char *arrStr = (char*)malloc((DIGI_NUM + 1) * sizeof(char));     // 分配内存长度为11的内存（结束符占一个字节
    memset(arrStr, '0', DIGI_NUM * sizeof(char));    // 初始化
    arrStr[DIGI_NUM] = '\0';

    int targetNum[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    memcpy(arrNum, targetNum, DIGI_NUM * sizeof(int));   // 赋值

    free(arrNum);

    return 0;
}

calloc

函数形式：

void* calloc (size_t num, size_t size);

为数组的num个元素分配一块内存，每个元素长度为size大小，且初始化为0；因此相当于分配一块已经经过初始化0的num*size大小的内存。
用例：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// #include "test_0315.h"

#define DIGI_NUM 10
int main(int argc, const char *argv[])
{
    int *arrNum = (int*)calloc(DIGI_NUM, sizeof(int));   // 为10个元素分配一块内存，且每个元素均初始化为0
    for (int i = 0; i < DIGI_NUM; i++) {
        printf("%d\n", *(arrNum + i));   // 输出均为0
    }

    free(arrNum);

    return 0;
}

realloc

函数形式：

void* realloc (void* ptr, size_t size);

函数功能：改变指针ptr指向的内存块大小。
先判断当前的指针是否有足够的连续空间，如果有，扩大ptr指向的地址，并将ptr返回。如果空间不够，先按照新分配的内存大小分配空间，将原有的数据从头到尾拷贝到新的空间里，并返回新的内存块的首地址，同时释放原来ptr指向的内存区域，该过程不需要再调用free函数，原来的指针会自动释放。
比如如果新分配的内存大，则新分配的内存会保存原来内存所保存的旧内容，并且新分配的那一部分内存的值是不确定的。如果新分配的内存小，则保留新分配的内存部分。
如果ptr是空指针，则依然会分配一快size大小的内存，并且返回一个指针，指向该内存的首地址。这和malloc差不多。
如果size是0，则相当于释放指针ptr所指向的内存块，这个过程相当于free。
用例：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// #include "test_0315.h"

#define DIGI_NUM 10
int main(int argc, const char *argv[])
{
    int *arrNum = (int*)malloc(DIGI_NUM * sizeof(int));   // 为10个元素分配一块内存，且每个元素均初始化为0
    for (int i = 0; i < DIGI_NUM; i++) {
        *(arrNum + i) = i;
    }
    printf("%p\n", arrNum);   // 0000000000AD13E0

    // int *arrNumNew = (int*)realloc(arrNum, DIGI_NUM + 5);
    // printf("%p\n", arrNumNew);  // 0000000000AD13E0

    // for(int i = 0; i < DIGI_NUM + 5; i++) {
    //     printf("%d\n", *(arrNumNew + i));  // 打印出来依次是0 1 2 3 4 5 6 7 8 9 -1640116441 52993 10223952 0 10253680 后面的内存是新分配的，因此值不确定
    // }

    int *arrNumNew = (int*)realloc(arrNum, DIGI_NUM - 5);
    printf("%p\n", arrNumNew);  

    for(int i = 0; i < DIGI_NUM - 5; i++) {
        printf("%d\n", *(arrNumNew + i));  // 打印出来依次是0 1 2 3 4 
    }

    free(arrNumNew);

    return 0;
}

该函数具体详解可参考博客：
realloc() 用法详解
引用自：小可爱amour 首页

free

函数原型：

void free (void* ptr);

当使用malloc，calloc，realloc函数分配内存时，可用free函数将该内存释放掉。
如果指针ptr指向的不是由上述函数分配的内存的地址时，禁止使用free函数释放内存。
如果ptr是空指针，该函数不进行任何操作。
此外，free函数不改变指针ptr本身，它只是用来释放内存的，释放完内存后，ptr指针依然指向它原来指向的地址。

qsort

排序函数，该函数使用快排，比较使用，具体用法参考之前的一篇博客。
C语言 常用排序算法（附代码）

atoi

函数原型：

int atoi (const char * str);

将字符串转换为整型数字。atoi会自动忽略前面的空格，直到遇到符号或数字或结束符。
如果要转换的数字超过了int的范围，则会出现未定义行为。
用例：

#include <sec_api/string_s.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, const char *argv[])
{
    char str[10] = "   -10";
    char str1[10] = "   10";

    int num = atoi(str);
    int num1 = atoi(str1);
    printf("%d\n", num); // -10
    printf("%d\n", num1); // 10

    return 0;
}

itoa

函数原型：

char *  itoa ( int value, char * str, int base );

将整形数据转换为字符串类型，并以结束符结尾。结果存储在指针str指向的内存中。
value：要转换的值；
str：结果存放处；
base：进位制，2~36
如果base是10的话，value可以为负数，。其他进位制默认都是无符号整型数。
用例：

#include <sec_api/string_s.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, const char *argv[])
{
    char str[33];
    int num = 1750;

    itoa(num, str, 10);
    printf("%s\n", str);    // 1750

    itoa(num, str, 2);
    printf("%s\n", str);    // 11011010110

    itoa(num, str, 16); // 6d6
    printf("%s\n", str);

    itoa(-num, str, 10);
    printf("%s\n", str);    // -1750

    itoa(-num, str, 16);
    printf("%s\n", str);    // fffff92a

    return 0;
}
Chillinglu
关注
  • 0
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C语言标准函数库详解.pdf
07-29
C语言标准函数库详解.pdf C语言标准函数库详解.pdf C语言标准函数库详解.pdf C语言标准函数库详解.pdf
C语言常用库函数总结
shn249510的博客
10-30 7381
C语言常用计算相关库函数、字符串操作库函数；
C语言中的库函数
最新发布
2302_81342533的博客
03-15 967
库函数是编程中用于简化开发过程和提高代码复用性的预编译函数集合，通常由编译器提供，并可在C源程序中直接调用。实际的问题解决中，库函数也能提供便利，它不像自建函数那样，使用都需要程序员后期手动编写。直接调用库将其使用，非常实用。
【C语言进阶】最常用的库函数大全——从入门到精通
睿的博客
01-18 1万+
常见库函数的使用大全！快来看看吧！
C语言常用的库函数 （自用）
SNNU AI 周一卓的博客
03-24 8951
常用的库函数1.前言2.内容1.toupper()2.tolower() 1.前言 在刷题过程中，总能看到dl用一些库函数，简化算法，由此萌生慢慢学习整理常用的库函数的想法，本文目前仅为了自用而整理，欢迎指正。 （整理顺序按学习顺序，后续可能会调整 3.24 ） 2.内容 1.toupper() 头文件：#include <ctype.h> 作用：将小写字母转换为大写字母 声明：int toupper(int c)； 参数：c （要被转换为大写的字母） 返回值：返回值是一个可被隐式转换
C语言常用库函数终稿.pdf
02-21
C语言常用库函数终稿.pdf
C语言常用库函数.docx
04-05
C语言常用库函数.docx
C语言常用的库函数总结
07-25
一、标准定义 ；二、错误信息；三、输入输出函数；四、数学函数；五、字符处理函数；六、字符串函数；七、功能函数。
C语言标准库函数大全（ctype、time 、stdio、stdlib、math、string）
热门推荐
冬瓜的博客
07-29 10万+
文章目录C语言函数库一. C语言函数库 一. <assert.h> 二. <ctype.h> 三. <errno.h> 四. <limits.h> 五. <locale.h> 六. <math.h> 七. <setjmp.h> 八. <signal.h> 九. <stdarg.h> 十. <stddef.h> 十一. <stdio.h&.
C/C++中的标准库函数总结
竭尽全力的专栏
06-30 7897
C 语言中有大量的标准库函数，根据功能不同，声明于不同的头文件中。这些库函数在C++中也能使用。总结了常用的库函数
c语言的库函数
RONG_YAO的博客
06-29 1万+
一、标准C库函数(15个) 二、数学函数 用于 三、字符串处理函数 四、字符处理函数 五、转换和存储管理函数 六、随机函数 七、日期和时间处理函数 八、诊断函数 九、命令行参数 十、其他函数 十一、综合应用 ...
C语言常用库函数（含详细用法））
weixin_45946213的博客
03-03 1万+
一、数学函数 调用数学函数时，要求在源文件中包下以下命令行： #include <math.h> 二、字符函数 调用字符函数时，要求在源文件中包下以下命令行： #include <ctype.h> 三、字符串函数 调用字符函数时，要求在源文件中包下以下命令行： #include <string.h> 四、输入输出函数 调用字符函数时，要求在源文件中包下以下...
C语言中常用的五种库函数
m0_73969434的博客
11-10 2083
C语言中库函数的浅浅了解
C语言标准库函数大全
yang1fei2的博客
06-27 1万+
原文链接 C语言作为影响力最为深远的语言之一，应用范围非常广泛。在一些对性能要求比较高的领域，C语言依然有不可撼动的地位。但是C语言标准库的函数比较多，很多时候我们要实现某个逻辑功能，不知道调用哪些函数。这时就不得不去查询对应的函数文档，这样比较费时。这里把大家能用到的几乎的所有的C语言库函数以表格的形式列出来，供大家参考。根据功能将C语言标准库函数分为:数学运算、文件和目录操作、事件和日期、进程操作、内存分配、字符串处理、系统函数、类型转换、绘图函数九类。下面以表格的形式分别介绍。 数学运算 主
[C语言]常用库函数
lazyxx的博客
03-28 1338
字符函数和字符串函数 求字符串长度 size_t strlen ( const char * str ); 字符串以'\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前面出现的字符个数（不包 含 '\0' )。 参数指向的字符串必须要以 '\0' 结束。 注意函数的返回值为size_t，是无符号的（ 易错 ） 长度不受限制的字符串函数 strcpy： char* strcpy(char * destination, const char * source );..
c语言常用库函数
m0_51418215的博客
11-06 2272
c语言常用库函数 1、数学函数 abs 原型：extern int abs(int x); 功能：求整数x的绝对值 说明：计算|x|, 当x不为负时返回x，否则返回-x fabs 原型：extern float fabs(float x); 功能：求浮点数x的绝对值 说明：计算|x|, 当x不为负时返回x，否则返回-x sin 原型：extern float sin(float x); 功能：计算x（弧度表示）的正弦值。 说明：x的值域为[-1.0，1.0]。 asin 原型：extern float a
C语言常用库函数（含详细用法）
Crazy程序猿
06-06 5563
一、数学函数 调用数学函数时，要求在源文件中包下以下命令行：#include 函数原型说明功能返回值说明int abs( int x)求整数x的绝对值计算结果double fabs(double x)求双精度实数x的绝对值计算结果double acos(double x)计算cos-1(x)的值计算结果x在-1～1范围内double asin(double x)计算sin-1(x)的值计算结果x在-1～1范围内double atan(double x)计算tan-1(x)的值计算结果doub......
c语言的库函数有哪些
10-23
C语言的库函数非常丰富，包括字符串处理、数学计算、文件操作等多个方面。其中一些常用的库函数如下： 1. 字符串处理函数：strlen、...以上仅是常用的一部分库函数，C语言的库函数非常丰富，可以根据需要选择使用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值