C语言中的库函数

于 2024-03-15 14:44:57 发布
阅读量1.1k 收藏 27
点赞数 20
分类专栏： 库函数 数据结构 文章标签： c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_81342533/article/details/136703153
版权

前言

        在C语言中，包含了许多的库函数。这些库函数都是会经常用到的，对于程序员来说，熟系库函数的使用方法，也是入门的重要一环。实际的问题解决中，库函数也能提供便利，它不像自建函数那样，使用都需要程序员后期手动编写。直接调用库将其使用，非常实用。

一.  str系列的库函数

        str系列包括strlen（）、strcpy（）、strcat（）、strcmp（）等等。这一个系列的库函数都有一个特性，那就是需要针对于字符串使用。下面开始具体的介绍它们。

        这类函数需要使用的话需要包含头文件<string.h>。

1. strlen

（1） 函数的说明

        strlen函数用于查看字符串长度。函数结构如下：

        size_t strlen ( const char * str );

        求出地址“str”处字符串到‘\0’为止的长度，返回值是无符号型整数。

（2） 使用方法举例

        将字符串得到起始地址传入函数就能求出字符串长度

#include <stdio.h>
#include <string.h>

int main()
{
    char arr[] = "hello world";
    size_t num = strlen(arr);
    printf("%u\n", num);
    return 0;
}

        运行结果如下：

        “hello world”到‘\0’为止确实是11个字符，结果无误。

（3） 自建函数模拟

        1）const修饰“str”，因为“str”中的内容不需要被修改。

        2）需要判断“str”是不是空指针，用到assert函数判断。

        3）字符串没到"\0"就向后走一步，用“tmp”计数，最后返回“tmp”。

size_t my_strlen(const char* str)
{
    assert(str);

    size_t tmp = 0;
    while(*str++ != '\0')
    {
        tmp++;
    }
    return tmp;
}

2. strcpy

（1） 函数的说明

        strcpy函数用于拷贝字符串。函数结构如下：

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

        传给strcpy两个地址，将‘source’拷贝给‘destination’。最后返回“destination”的起始地址。

（2） 使用方法举例

        使用如下代码可以将str1拷贝至str2，"copy successful"拷贝到str3。使用前需注意“destination”需要有足够空间。

#include <stdio.h>
#include <string.h>

int main()
{
    char str1[] = "Sample string";
    char str2[40];
    char str3[40];
    strcpy(str2, str1);
    strcpy(str3, "copy successful");
    printf("str1: %s\nstr2: %s\nstr3: %s\n", str1, str2, str3);
    return 0;
}

        运行结果如下：

        拷贝很成功，对于strcpy（）函数来说会一直将“source”向“destination”拷贝，直到遇到‘\0’结束。所以最好不要有拷贝空间重叠的部分，那样就会一直拷贝。比如在上述代码之后增加一行：

strcpy(str2 + 2, str2);

        这样的写法会出错，请读者注意。

（3） 自建函数模拟

        1）const修饰“str”，因为“str”中的内容不需要被修改。

        2）需要判断“dest”，“str”是不是空指针，用到assert函数判断。

        3）tmp记录dest的初始位置，最后返回它。

        4）将“str”中的数据拷贝到“dest”中再++，简直就是点睛之笔。

char* my_strcpy(char* dest, const char* str)
{
    assert(dest && str);

    char* tmp = dest;
    while(*dest++ = *str++)
    {
        ;
    }
    return tmp;
}

3. strcat

（1） 函数的说明

        strcat函数用于尾接字符串，函数结构如下：

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

        在“desitnation”结束之后，接上字符串“source”。也就是将字符串“source”拷贝到“destination”的后面。最后返回“desitnation”的起始地址。

（2） 使用方法举例

#include <stdio.h>
#include <string.h>

int main ()
{
    char str[80];
    strcpy(str, "these ");
    strcat(str, "strings ");
    strcat(str, "are ");
    strcat(str, "concatenated.");
    puts(str);
    return 0;
}

        运行结果如下：

        首先在“str”里拷贝了“these ”，然后三次尾接分别连接上“strings ”、“are ”、“concatenated”然后输出str。这个函数在拷贝的时候也需要遇到“\0”才能结束，所以不要自己接到自己后面，“\0”被覆盖后会一直循环。比如在最后增加一句：

strcat(str, str);

        这样就拿不到结果，程序还会崩掉。

（3） 自建函数模拟

        1）const修饰“str”，因为“str”中的内容不需要被修改。

        2）需要判断“dest”，“str”是不是空指针，用到assert函数判断。

        3）tmp记录dest的初始位置，最后返回它。

        4）把“dest”走到"\0"，然后再开始拷贝，拷贝直接用strcpy的模拟方法就可以。

        5）“dest--”是因为这个“dest”在走到“\0”后++了一次，现在减回去，也可以把++放到while循环内部。

 char* my_strcat(char* dest, const char* str)
 {
     assert(dest && str);

     char* tmp = dest;
     while(*dest++)
     {
         ;
     }
     dest--;
     while(*dest++ = *str++)
     {
         ;
     }
     return tmp;
 }

4. strcmp

（1） 函数的说明

        strcmp函数用于比较字符串，函数结构如下：

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

        从头开始比较“str1”和“str2”中的字符，其实是比较它的ASCLL码的大小，如果相同，则比较下一位，如果“str1”的大则返回一个正整数，如果“str2”大则返回一个负整数。如果都到"\0"还没比出来就返回0。

（2） 使用方法举例

#include <stdio.h>
#include <string.h>

int main()
{
    char arr1[] = "abbbcdef";
    char arr2[] = "abb";
    char arr3[] = "abbbcdef";
    int tmp = strcmp(arr1, arr2);
    if(tmp == 0)
    {
        printf("arr1 == arr2\n");
    }
    else
    {
        printf("arr1 != arr2\n");
    }
    tmp = strcmp(arr1, arr3);
    if(tmp == 0)
    {
        printf("arr1 == arr3\n");
    }
    else
    {
        printf("arr1 != arr3\n");
    }
    return 0;
}

        结果如下：

        判断为零则输出二者相等，非零则表示二者不等。

（3） 自建函数模拟

        1）const修饰“str1”、“str2”，因为“str1”、“str2”中的内容不需要被修改。

        2）需要判断“str1”、“str2”是不是空指针，用到assert函数判断。

        3）循环条件字符内容相等且不为‘\0’，满足条件就向后挪动一位。

        4）返回两者相减的值，这个时候出了循环，也就是说要么有一个字符串结束了，要么两者内容不相同。其实循环里面只需要放一个“str1 ！= ‘\0’”就足够了，不需要放“str2 ！= ‘\0’”。这里放进去是因为表达的逻辑更清晰。

 int my_strcmp(const char* str1, const char* str2)
 {
     assert(str1 && str2);

     while(*str1 != '\0' && *str2 != '\0' && *str1 == *str2)
     {
         str1++;
         str2++;
     }
     return *str1 - *str2;
 }

5. strstr

（1） 函数的说明

        strstrr函数用于在一个字符串中查找是否存在另一个字符串，函数结构如下：

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

        查找“str1”中是否存在“str2”，最后返回找到地点的起始地址，没找到返回NULL。

（2） 使用方法举例

        分别从“str1”中查找“str2”、“str3”。

#include <stdio.h>
#include <string.h>

int main()
{
    char arr1[] = "abbbcdef";
    char arr2[] = "bbc";
    char arr3[] = "abbbq";
    char* tmp = strstr(arr1, arr2);
    if(tmp == NULL)
    {
        printf("没找到\n");
    }
    else
    {
        printf("%s\n", tmp);
    }
    tmp = strstr(arr1, arr3);
    if(tmp == NULL)
    {
        printf("没找到\n");
    }
    else
    {
        printf("%s\n", tmp);
    }
    return 0;
}

        结果如下：

（3） 自建函数模拟

        1）const修饰“str1”、“str2”，因为“str1”、“str2”中的内容不需要被修改。

        2）需要判断“str1”、“str2”是不是空指针，用到assert函数判断。

        3）“cur”用来记录“str1”中比较到了的位置。

        4）比较后续字符串和strcmp函数的自模拟方法相同。

char* my_strstr(const char* str1, const char* str2)
{
    assert(str1 && str2);

    const char* s1 = str1;
    const char* s2 = str2;
    const char* cur = str1;
    while(*s1 != '\0' && *s2 != '\0')
    {
        s1 = cur;
        s2 = str2;
        while(*s1 != '\0' && *s2 != '\0' && *s1 == *s2)
        {
            s1++;
            s2++;
        }
        cur++;
    }
    cur--;
    if(*s2 == '\0')
    {
        return (char*)cur;
    }
    return NULL;
}

6. strtok

（1） 函数的说明

        strtok函数用于在一个字符串中查找是否存在另一个字符串中的元素，如果有就改成‘\0'，函数结构如下：

        char * strtok ( char * str, const char * delimiters );

        从“str”中找“deliniters”中的元素，如果找到了就改成'\0'，然后返回开始找的时候的起始地址。没找到就返回NULL。如果第二次使用该函数“str”传的值为空指针，则会从上一个“str”中找到了之后的位置开始找起，如果找到了就改成'\0'，然后返回开始找的时候的起始地址。没找到就返回NULL。

        该函数可以用于把句子中的单词分装出来。

（2） 使用方法举例

        将“str”中的“ ，。-”找出来，改成“\0", 接收返回的地址，然后打印。

#include <stdio.h>
#include <string.h>

int main ()
{
    char str[] = "- This, a sample string.";
    char * pch;
    printf("Splitting string \"%s\" into tokens:\n", str);
    pch = strtok(str, " ,.-");
    while (pch != NULL)
    {
        printf("%s\n", pch);
        pch = strtok(NULL, " ,.-");
    }
    return 0;
}

        结果为：

7. strerror

（1） 函数的说明

        strerror用来打印错误号码对应的错误信息。结构如下：

        char * strerror ( int errnum );

        输入一个错误数“errnum”，该函数会找到系统中对应错误码的错误信息，并返回对应地址。

        使用的时候可以包含头文件<srrno.h>, 传errno进入该函数，就能够打印刚出错的错误信息。不过这种用法可以被函数perror平替掉。

（2） 使用方法举例

        分别打印0~9的错误码对应的错误信息。

#include <stdio.h>
#include <string.h>

int main()
{
    int i = 0;
    for(i = 0; i < 10; i++)
    {
        printf("%d:%s\n", i, strerror(i));
    }
    return 0;
}

        结果如下：

8. 其他的str函数

        还有一些str函数，比如strncmp、strncat、strncpy。这些函数的功能就是限制了strcmp、strcat、strcpy中字符的个数，其他功能都是一样的。所以不在详细介绍，有兴趣的小伙伴可以自行研究一下。

二. mem系列函数

        这个系列的函数有memcpy、memmove、memset等函数，它们都是针对内存的函数，不在局限于字符串的操作，可以用在更多的领域内。使用的时候需要包含头文件<string.h>。

1.  memcpy

（1） 函数的说明

        memcpy函数是用来拷贝数据用的，相比较与strcpy有过之无不及，它的结构如下：

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

        使用方法为，从“source”位于的地址中拷贝“num”个字节的数据到“destination”所指向的地址去，最后返回“destination”的起始地址。

        使用void*指针可以用来接收各种各样的地址，就不需要像strcpy函数那样只接收char*指针了。

        需要注意的是，拷贝的时候“source”的空间不能和“destination”的空间重叠，不然会发生错误。如果有重叠部分，可以使用memmove函数。

（2） 使用方法举例

        从arr1中拷贝20个字节的数据到arr2中，然后打印arr2中的所有数据。

#include <stdio.h>
#include <string.h>

int main()
{
    int arr1[] = {1,2,3,4,5,6,7,8,9,10};
    int arr2[10] = {0};
    memcpy(arr2, arr1, sizeof(int) * 5);
    for(int i = 0; i < 10; i++)
    {
        printf("%d ", arr2[i]);
    }
    printf("\n");
    return 0;
}

        结果如下：

        成功的拷贝了5个int类型大小的数据，如果推广一下，也可以用于拷贝其他类型的数据或者结构体也行。

        会出错的使用方法也给大家看看，比如说把arr1拷贝20个字节的数据到arr1+2中，然后打印arr1中的所有数据，结构如下：

int main()
{
    int arr1[] = {1,2,3,4,5,6,7,8,9,10};
    memcpy(arr1 + 2, arr1, sizeof(int) * 5);
    for(int i = 0; i < 10; i++)
    {
        printf("%d ", arr1[i]);
    }
    printf("\n");
    return 0;
}

        在一些编译器上得出来的结果是1,2,1,2,1,2,1,8,9,10。但是在vscode上结果并没有出错。结果如下：

        看来，memcpy在vscode上被更新过。

（3） 自建函数模拟

        1）const修饰sour是因为sour处的数据不需要被修改，提前保护起来。

        2）使用assert判断传进来的dest、sour是不是空指针，空指针无法拷贝内容。

        3）使用test记录dest的初始位置，并在最后返回。

        4）使用循环拷贝num个字节的数据，将指针强制转变为char*类型，这样的话才能控制字节数，如果强转为其他类型，比如int*类型，那么+1将会跳过4个字节，那么就拷贝不了5个字节这样的要求了。

void* my_memcpy(void* dest, const void* sour, size_t num)
{
    assert(dest && sour);

    void* tmp = dest;
    size_t i = 0;
    for(i = 0; i < num; i++)
    {
        *(char*)dest = *(char*)sour;
        dest = (char*)dest + 1;
        sour = (char*)sour + 1;
    }
    return tmp;
}

        5）代码中可能会出现的错误

        (char*)dest++;
        (char*)sour++;

        不能这样修改指针的位置，如果想要使用++修改位置，那么就需要再增加一对括号，当然在不同编译器里也是存在不同之处的，请注意。

2.  memmove

（1） 函数的说明

        memmove比起memcpy解决了地址重复时拷贝的问题。结构如下：

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

        将“num”个字节数的数据从“source”指向的位置拷贝到“destination”所指向的位置去，拷贝的时候会复制数据的内容拷贝，最后返回“destinaton”的起始位置。允许“source”和“destination”位置重叠。

        函数不会检查“source”是否为空指针，所以不要传空指针进去。

        为避免溢出，目标参数和源参数所指向的数组的大小应至少为num字节。

（2） 使用方法举例

        把arr1拷贝20个字节的数据到arr1+2中，然后打印arr1中的所有数据，结构如下：

#include <stdio.h>
#include <string.h>

int main()
{
    int arr1[] = {1,2,3,4,5,6,7,8,9,10};
    memmove(arr1 + 2, arr1, sizeof(int) * 5);
    for(int i = 0; i < 10; i++)
    {
        printf("%d ", arr1[i]);
    }
    printf("\n");
    return 0;
}

        结果为：

（3） 自建函数模拟

        有两种方案：

        将“sour”中的数据复制num个字节，先存起来，然后在统一拷贝到“dest”中。

        另一种是判断两个地址的前后顺序如果sour>dest则，从前向后拷贝，反之则从后往前拷贝。

        因为第一种方法会消耗额外的空间时间，所以这里用的是第二种。

        1）const修饰sour是因为sour处的数据不需要被修改，提前保护起来。

        2）使用assert判断传进来的dest、sour是不是空指针，空指针无法拷贝内容。

        3）使用test记录dest的初始位置，并在最后返回。

        4）判断两个地址的前后顺序如果sour>dest则，从前向后拷贝，反之则从后往前拷贝。

void* my_memmove(void* dest, const void* sour, size_t num)
{
    assert(dest && sour);

    void* tmp = dest;
    size_t i = 0;
    if(sour > dest)
    {
        for(i = 0; i < num; i++)
        {
            *(char*)dest = *(char*)sour;
            dest = (char*)dest + 1;
            sour = (char*)sour + 1;
        }
    }
    else
    {
        for(i = num; i-- > 0; )
        {
            *((char*)dest + i) = *((char*)sour + i);
        }
    }
    return tmp;
}

3. memset

（1） 函数的说明

        memset函数用于将值拷贝n个到某个地址去，结构如下：

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

        将“ptr”指向的内存块的前“num”个字节设置为指定值“i"（解释为无符号字符）。

（2） 使用方法举例

        将“str”指向的前6个字节替换为‘-’的ASCLL码值，然后打印出来，代码如下：

#include <stdio.h>
#include <string.h>

int main ()
{
    char str[] = "almost every programmer should know memset!";
    memset(str, '-', 6);
    puts(str);
    return 0;
}

        代码运行结果如下：

（3） 自建函数模拟

        1）使用assert判断传进来的dest是不是空指针，空指针无法拷贝内容。

        2）使用test记录dest的初始位置，并在最后返回。

        3）将前num个数据替换为指定数据。

void* my_memset(void* dest, const int val, size_t num)
{
    assert(dest);

    void* tmp = dest;
    size_t i = 0;
    for(i = 0; i < num; i++)
    {
        *(char*)dest = val;
        dest = (char*)dest + 1;
    }
    return tmp;
}

4. memcmp

（1） 函数的说明

        memcmp函数和strncmp函数的功能差不多，就是把指向的数据分成字节比较大小，结构如下

        int memcmp ( const void * ptr1, const void * ptr2, size_t num );

        将“ptr1”所指向的内存块的前“num”个字节与“ptr2”所指向的“num”个字节进行比较，如果它们都匹配，则返回零；如果不匹配，则为不同于零的值，表示哪个值更大。

        需要注意的是，与strncmp不同，该函数在找到空字符后不会停止比较。

（2） 使用方法举例

        比较buffer1和buffer2的大小，判断输出结果，代码结构如下：

#include <stdio.h>
#include <string.h>

int main ()
{
    char buffer1[] = "DWgaOtP12df0";
    char buffer2[] = "DWGAOTP12DF0";

    int n;

    n = memcmp(buffer1, buffer2, sizeof(buffer1));

    if(n>0) 
        printf("'%s' is greater than '%s'.\n", buffer1, buffer2);
    else if (n<0) 
        printf("'%s' is less than '%s'.\n", buffer1, buffer2);
    else 
        printf("'%s' is the same as '%s'.\n", buffer1, buffer2);

    return 0;
}

        执行结果为：

（3） 自建函数模拟

        1）const修饰ptr1、ptr2是因为ptr1、ptr2处的数据不需要被修改，提前保护起来。

        2）使用assert判断传进来的ptr1、ptr2是不是空指针，空指针无法比较。

        3）不相同的时候，返回相减的值，相同返回0。

int my_memcmp(const void* ptr1, const void* ptr2, size_t num)
{
    assert(ptr1 && ptr2);

    size_t i = 0;
    for(i = 0; i < num; i++)
    {
        if(*((char*)ptr1 + i) != *((char*)ptr2 + i))
        {
            return *((char*)ptr1 + i) - *((char*)ptr2 + i);
        }
    }
    return 0;
}

三. 数据在内存中的存储

1. 计算机中数据都是以二进制在内存中存储的

        对于整数来说，最高位是符号位，0为正，1为负。

        数据以补码的方式储存，正数的补码是原码，负数的补码是原码取反加一。这样在计算机中计算的时候就只需要加法就能计算正数负数。

2. 数据的显示

        在调试窗口中，数据是以16进制的样子显示的，这样显示相比于二进制更节省空间。

3. 数据的储存顺序

        在电脑中，数据得到存储方式有两种，一种是大端存储，另一种是小端存储。

        大端存储是：低地址处存放高地址位的数据，高地址处存放低地址位的数据。

        小端存储是：高地址处存放高地址位的数据，低地址处存放低地址位的数据。

        例如：

        如果想判断你的编译器的数据存储方式可以使用以下代码：

#include <stdio.h>

int main()
{
    int a = 1;
    char* p = (char*)&a;
    if(*p == 1)
    {
        printf("小端存储\n");
    }
    else
    {
        printf("大端存储\n");
    }
    return 0;
}

        利用的原理就是用char*接收a的地址，如果是大端难么*p==0，反之*p==1。

作者结语

        从库函数到数据结构的基础内容颇多，提到数据结构也是因为数据结构和内存函数mem等有关联，这篇博客下来，总共已经写了6篇博客了。比较明显的提升是在前2次博客中，后面的话风格都没怎么改变，想写好博客还是需要长时间打磨的，向这种2天干出一片完美的博客来说应该是不现实的，有的东西需要用图片说明，有的地方还需要继续深挖，但是作为一个刚入坑的新手来说，实在是掏不出来什么干货。

        总之需要时间的东西，急不出来。

随缘与奇迹
关注
  • 20
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
【C语言】C语言库函数
qq_51931342的博客
05-04 1036
前言 我们在使用c语言的时候经常找不到某个函数，今天我就整理了一份C语言常用的库函数。 C语言常用的头文件 <stdio.h><ctype.h>   <time.h>   <stdlib.h>   <math.h>   <string.h> <stdio.h> 简介 stdio .h头文件定义了三个变量类型、一些宏和各种函数来执行输入和输出。 三个...
C/C++常见库函数（巨详细）
2303_76654613的博客
08-25 4746
该文章讲解C/C++的一些常用的库函数，超详细！！！
【C语言进阶】最常用的库函数大全——从入门到精通
睿的博客
01-18 1万+
常见库函数的使用大全！快来看看吧！
C语言常用库函数（含详细用法）
Crazy程序猿
06-06 5639
一、数学函数 调用数学函数时，要求在源文件中包下以下命令行：#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语言标准库函数大全
yang1fei2的博客
06-27 1万+
原文链接 C语言作为影响力最为深远的语言之一，应用范围非常广泛。在一些对性能要求比较高的领域，C语言依然有不可撼动的地位。但是C语言标准库的函数比较多，很多时候我们要实现某个逻辑功能，不知道调用哪些函数。这时就不得不去查询对应的函数文档，这样比较费时。这里把大家能用到的几乎的所有的C语言库函数以表格的形式列出来，供大家参考。根据功能将C语言标准库函数分为:数学运算、文件和目录操作、事件和日期、进程操作、内存分配、字符串处理、系统函数、类型转换、绘图函数九类。下面以表格的形式分别介绍。 数学运算 主
c语言实现库函数
weixin_64448174的博客
03-22 1938
目录 一.strlen函数 1.描述 2.实现 1.计数的方法 2.函数递归的方法 3.指针 - 指针方法 二.strcmp函数 1.描述 2.实现 三.strcpy函数的实现 1.描述 2.实现 四.strcat函数的实现 1.描述 2.实现 五.strstr函数的实现 1.描述 2.实现 1.BF算法实现 2.kmp算法的实现 一.strlen函数 1.描述 C 库函数 size_t strlen(const char *str) 计算字符串 .
C语言库函数速查手册 C语言库函数速查手册
06-16
C语言库函数速查手册C语言库函数速查手册C语言库函数速查手册C语言库函数速查手册C语言库函数速查手册C语言库函数速查手册C语言库函数速查手册C语言库函数速查手册C语言库函数速查手册C语言库函数速查手册C语言...
C语言标准库函数.pdf
12-22
C语言标准库函数
C语言常用库函数
04-12
C语言常用库函数, 包含C语言开发所有标准库函数
基于C语言中库函数的展开形式的识别技术.pdf
09-19
基于C语言中库函数的展开形式的识别技术.pdf
C 语言库函数大全
05-13
C 语言库函数大全C 语言库函数大全C 语言库函数大全C 语言库函数大全C 语言库函数大全C 语言库函数大全
C语言函数库详解(收藏版)
09-12
C语言函数库详解(收藏版)感觉还是比较实用的，作为手册需要时可以查一查各种函数的具体定义和使用方法示例，十分方便的。
C语言常用库函数.docx
04-05
下面是C语言中常用的库函数： 1. assert.h 库函数 assert.h 库函数提供了一些断言函数，用于检查程序中的错误。 assert宏可以在程序中插入断言，检查某个条件是否成立，如果条件不成立，则程序将终止。 2. float....
C语言中常用的库函数和头文件
最新发布
qq_55615339的博客
12-11 1086
isalpha、isdigit：判断字符是否是字母、数字。- isupper、islower：判断字符是否是大写、小写。- strchr、strrchr：在字符串中查找特定字符。- fprintf、fscanf：格式化读写文件。- strcpy、strncpy：复制字符串。- strcat、strncat：连接字符串。- strcmp、strncmp：比较字符串。- floor、ceil：向下取整、向上取整。- fopen、fclose：打开关闭文件。- fgets、fputs：读写字符串。
c语言编写库函数,C语言库函数如何编写？
weixin_34247778的博客
05-19 1776
/****printf.c - print formatted** Copyright (c) 1985-1997, Microsoft Corporation. All rights reserved.**Purpose:* defines printf() - print formatted data***********************************************...
各个头文件
mancinism的专栏
08-13 689
cctype (ctype.h) 3.2.4 节 string 对象中字符的处理 6.3 节 字符函数库 cctype(比前者多个isblank介绍, 比较详细) header Character handling functions This header declares a set of functions to classify and transfo
C语言中最常用标准库函数
热门推荐
candyliuxj
11-10 3万+
标准头文件包括： 一、标准定义（） 文件里包含了标准库的一些常用定义，无论我们包含哪个标准头文件，都会被自动包含进来。 这个文件里定义： l类型size_t（si
C语言当中的函数(库函数及自定义函数)
persistence_Y的博客
04-01 7627
C语言当中函数的分类一般为库函数和自定义函数两种. 首先来看库函数一些例子: 1.在我们C语言的学习过程中,把程序想要得到的结果打印到屏幕上是必不可少的,这个时候我们就会频繁的使用一个功能,即printf(将信息按照一定的格式打印到屏幕上). 2.在编程过程中,我们常常会需要拷贝字符串,这个时候也就用到了(strcpy). 3.当我们在计算一个数n的k次方时,若幂数较小(比如为3),我们可以通过n...
C语言中自己写几个简单的库函数
Loving_Forever_的博客
04-06 8282
在C语言的学习中我们总会遇到一些看似看简单的问题，比如求字符串的长度，判断一个字符串中是否包含一个给定的子字符串，又或者怎么将一个字符串逆序输出，甚至是部分逆序输出，这些问题看似都挺简单，因为我们早已经习惯了使用库函数，求一个字符串的长度，用strlen（）函数，不需要敲几个代码就可以得到结果，当然这也没什么问题，毕竟库函数设计出来就是给人用的，不过有时候你若闲没什么事情做得话，不妨去看看库函数，
C语言库函数大全.doc
06-19
C语言库函数大全 函数名: abort 功 能: 异常终止一个进程 用 法: void abort(void); 程序例: #include #include int main(void) { printf("Calling abort()\n"); abort(); return 0; /* This is never reached */ } 。。。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值