【C语言】库函数-实用函数

最新推荐文章于 2025-03-03 17:45:00 发布

Nebula嵌入式

最新推荐文章于 2025-03-03 17:45:00 发布

阅读量1.4k

点赞数 32

分类专栏： C语言基础文章标签： c语言

本文链接：https://blog.csdn.net/qq_46004287/article/details/142714195

版权

C语言基础专栏收录该内容

15 篇文章

订阅专栏

前言

本文主要是总结头文件<stdlib.h>中比较常用的函数，大部分功能为数值转换。同时也总结了头文件<ctype.h>中比较常用的测试字符的函数。

版本迭代

时间	版本	版本改动
2024.10.05	V1.0	初始版本

atof函数

声明

#include <stdlib.h>
double atof(const char *str);

描述

将字符串str转换为双精度浮点数。忽略字符串开头的空白字符。如果字符串中包含有效的浮点数格式，atof会将其转换为double类型。如果字符串中没有有效的浮点数，则返回0.0。

参数

str:要转换为长整数的字符串。

实例

#include <stdio.h>
#include <stdlib.h>

int main() {
    const char *str1 = "3.14159";
    const char *str2 = "   2.71828";
    const char *str3 = "not a number";
    
    double num1 = atof(str1);
    double num2 = atof(str2);
    double num3 = atof(str3);

    printf("Converted value 1: %f\n", num1); // 输出: 3.141590
    printf("Converted value 2: %f\n", num2); // 输出: 2.718280
    printf("Converted value 3: %f\n", num3); // 输出: 0.000000

    return 0;
}

结果

// 输出: 3.141590
// 输出: 2.718280
// 输出: 0.000000

atoi函数

声明

#include <stdlib.h>
int atoi(const char *str);

描述

将字符串str转换为int类型的整数。atoi忽略字符串开头的空白字符，并转换字符串中的数字部分为整数。如果字符串中没有有效的整数，则返回0。如果字符串包含非数字字符，在这些字符之前的部分会被转换成整数，字符之后的部分会被忽略。

参数

str:要转换为长整数的字符串。

实例

#include <stdio.h>
#include <stdlib.h>

int main() {
    const char *str1 = "12345";
    const char *str2 = "   -6789";
    const char *str3 = "42abc";
    const char *str4 = "abc123";

    int num1 = atoi(str1);
    int num2 = atoi(str2);
    int num3 = atoi(str3);
    int num4 = atoi(str4);

    printf("Converted value 1: %d\n", num1); // 输出: 12345
    printf("Converted value 2: %d\n", num2); // 输出: -6789
    printf("Converted value 3: %d\n", num3); // 输出: 42
    printf("Converted value 4: %d\n", num4); // 输出: 0

    return 0;
}

结果

atoi("12345") 转换为 12345。
atoi("   -6789") 转换为 -6789。
atoi("42abc") 转换为 42，因为在 42 之后的部分被忽略。
atoi("abc123") 转换为 0，因为字符串以非数字字符开始。

atol函数

声明

#include <stdlib.h>
long int atol(const char *str);

描述

将字符串str转换为long类型的整数。atol忽略字符串开头的空白字符，并转换字符串中的数字部分为长整数。如果字符串中没有有效的长整数，则返回0。如果字符串包含非数字字符，在这些字符之前的部分会被转换成整数，字符之后的部分会被忽略。

参数

str:要转换为长整数的字符串。

实例

#include <stdio.h>
#include <stdlib.h>

int main() {
    const char *str1 = "123456789";
    const char *str2 = "   -9876543210";
    const char *str3 = "456xyz";
    const char *str4 = "xyz456";

    long num1 = atol(str1);
    long num2 = atol(str2);
    long num3 = atol(str3);
    long num4 = atol(str4);

    printf("Converted value 1: %ld\n", num1); // 输出: 123456789
    printf("Converted value 2: %ld\n", num2); // 输出: -9876543210
    printf("Converted value 3: %ld\n", num3); // 输出: 456
    printf("Converted value 4: %ld\n", num4); // 输出: 0

    return 0;
}

结果

atol("123456789") 转换为 123456789。
atol("   -9876543210") 转换为 -9876543210。
atol("456xyz") 转换为 456，因为在 456 之后的部分被忽略。
atol("xyz456") 转换为 0，因为字符串以非数字字符开始。

strtod函数

声明

#include <stdlib.h>
double strtod(const char *str, char **endptr);

描述

将字符串str转换为double类型的浮点数。strtod解析字符串中的数字部分并将其转换为双精度浮点数。endptr指针如果非NULL，将指向字符串中第一个未被转换的字符。如果字符串无法转换成数字，则返回0.0。

参数

str:字符串表示要转换的浮点数。
endptr:指向字符指针的指针，用于存储字符串中第一个未被转换的字符的地址（可选）。

返回值

该函数返回转换后的双精度浮点数，如果没有执行有效的转换，则返回零（0.0）。

实例

#include <stdio.h>
#include <stdlib.h>

int main() {
    const char *str1 = "123.456";
    const char *str2 = "   -789.0123abc";
    const char *str3 = "3.14";
    const char *str4 = "abc456";
    char *endptr;

    double num1 = strtod(str1, NULL);
    double num2 = strtod(str2, &endptr);
    double num3 = strtod(str3, NULL);
    double num4 = strtod(str4, &endptr);

    printf("Converted value 1: %f\n", num1); // 输出: 123.456
    printf("Converted value 2: %f\n", num2); // 输出: -789.0123
    printf("Remaining string after conversion 2: %s\n", endptr); // 输出: abc
    printf("Converted value 3: %f\n", num3); // 输出: 3.140
    printf("Converted value 4: %f\n", num4); // 输出: 0.000
    printf("Remaining string after conversion 4: %s\n", endptr); // 输出: 456

    return 0;
}

结果

strtod("123.456", NULL) 转换为 123.456。
strtod("   -789.0123abc", &endptr) 转换为 -789.0123，endptr 指向 abc。
strtod("3.14", NULL) 转换为 3.14。
strtod("abc456", &endptr) 转换为 0.0，endptr 指向 abc456。

strtol函数

声明

long int strtol(const char *str, char **endptr, int base)

描述

把参数str所指向的字符串根据给定的base转换为一个长整数（类型为 long int 型），base必须介于2和36（包含）之间，或者是特殊值0。

参数

str:要转换为长整数的字符串。
endptr:对类型为char*的对象的引用，其值由函数设置为str中数值后的下一个字符。
base:基数，必须介于 2 和 36（包含）之间，或者是特殊值 0。如果 base 为 0，则会根据字符串的前缀来判断进制：如果字符串以 ‘0x’ 或 ‘0X’ 开头，则将其视为十六进制；如果字符串以 ‘0’ 开头，则将其视为八进制；否则将其视为十进制。

返回值

函数返回被转换的长整型整数值。如果输入字符串不符合数字格式，strtol() 将返回 0。如果转换结果超出了 long 整数的表示范围，那么将产生溢出，并设置errno为 ERANGE。你可以使用 <errno.h> 头文件中的 errno变量来检查是否有溢出发生。

实例

如果输入字符串不能被完全转换为整数，strtol() 函数将返回转换成功的部分，而endptr将指向未转换部分的第一个字符。在这个例子中，endptr 是指向字符串末尾的空字符 ‘\0’，表示整个输入字符串都被成功转换为整数。

如果输入字符串包含非数字字符，例如 “12ab”，那么endptr将指向 “ab” 的起始位置，指示转换失败。

#include <stdio.h>
#include <stdlib.h>

int main() {
    char str[] = "12ab";
    char *endptr;
    long int num;

    num = strtol(str, &endptr, 10);

    if (*endptr != '\0') {
        printf("转换失败：输入字符串不是一个有效的整数。未转换部分：%s\n", endptr);
    } else {
        printf("转换结果：%ld\n", num);
    }

    return 0;
}

结果

转换失败：输入字符串不是一个有效的整数。未转换部分：ab

strtoul函数

声明

#include <stdlib.h>  
unsigned long int strtoul(const char *str, char **endptr, int base);

描述

strtoul函数将字符串str转换为无符号长整型数。转换可以基于不同的数制（如二进制、八进制、十进制和十六进制）。如果转换成功，函数会返回转换后的数值。如果转换过程中遇到无效字符，则停止转换并返回已转换的部分。它与strtol函数很相似他返回的是无符号长整型数。

参数

str:要转换为无符号长整数的字符串。
endptr:指向char*的指针，用于存储转换结束的位置。如果不需要此信息，可以传递NULL。
base:用于指定转换的基数（数制），可以是2到36之间的值，或者是特殊值0。如果为0，则字符串的前缀（如"0x"或"0"）会决定基数。

返回值

该函数返回转换后的长整数，如果没有执行有效的转换，则返回一个零值。

实例

#include <stdio.h>
#include <stdlib.h>

int main()
{
   char str[30] = "2030300 This is test";
   char *ptr;
   long ret;

   ret = strtoul(str, &ptr, 10);
   printf("数字（无符号长整数）是 %lu\n", ret);
   printf("字符串部分是 |%s|", ptr);

   return(0);
}

结果

数字（无符号长整数）是 2030300
字符串部分是 | This is test|

bsearch函数

声明

void *bsearch(const void *key, const void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *));

描述

用于在有序数组中执行二分查找。

参数

key：指向要查找的目标元素的指针。
base：指向数组起始位置的指针。
nmemb：数组中的元素数量。
size：每个元素的大小（以字节为单位）。
compar：指向比较函数的指针，该函数用于比较两个元素。

返回值

如果找到了匹配的元素，bsearch返回指向该元素的指针。
如果没有找到匹配的元素，bsearch返回NULL。

比较函数

比较函数必须符合以下签名：

int compar(const void *a, const void *b);

函数返回：

一个负值，如果a小于b。
零，如果a等于b。
一个正值，如果a大于b。

实例

#include <stdio.h>
#include <stdlib.h>
 
// 比较函数，用于 bsearch 查找
int cmpfunc(const void * a, const void * b) {
    return (*(int*)a - *(int*)b);
}
 
int main() {
    int values[] = { 5, 20, 29, 32, 63 };
    int key = 32;
    int *item;
 
    // 计算数组长度
    size_t array_size = sizeof(values) / sizeof(values[0]);
 
    // 使用 bsearch 在数组中查找值 32
    item = (int*) bsearch(&key, values, array_size, sizeof(int), cmpfunc);
 
    // 检查查找结果并输出
    if (item != NULL) {
        printf("Found item = %d\n", *item);
    } else {
        printf("Item = %d could not be found\n", key);
    }
 
    return 0;
}

结果

Found item = 32

abs函数

声明

int abs(int x)

描述

返回整数 x 的绝对值。abs() 函数只适用于整数，如果需要计算浮点数的绝对值，需要使用fabs()函数。

参数

x:要计算绝对值的整数。

返回值

如果 x 是正数，则返回 x，如果 x 是负数，则返回它的相反数，即 -x。如果 x 是 0，则返回 0。

实例

#include <stdio.h>
#include <stdlib.h>

int main ()
{
   int a, b;

   a = abs(5);
   printf("a 的值 = %d\n", a);

   b = abs(-10);
   printf("b 的值 = %d\n", b);
   
   return(0);
}

结果

a 的值 = 5
b 的值 = 10

qsort函数

声明

void qsort(void *base, size_t nitems, size_t size, int (*compar)(const void *, const void *));

描述

使用的是快速排序算法对数组进行快速排序。

参数

base:指向待排序数组的第一个元素的指针。
nitems:数组中的元素数量。
size:数组中每个元素的大小（以字节为单位）。
compar:比较函数的指针，该函数用于比较两个元素。比较函数应当返回一个整数，表示比较结果：
- 小于零：表示第一个元素小于第二个元素。
- 等于零：表示两个元素相等。
- 大于零：表示第一个元素大于第二个元素。

返回值

无返回值。

实例

#include <stdio.h>
#include <stdlib.h>

// 定义一个包含五个整数的数组
int values[] = { 88, 56, 100, 2, 25 };

// 比较函数，用于比较两个整数
int cmpfunc (const void * a, const void * b)
{
   return ( *(int*)a - *(int*)b );
}

int main()
{
   int n;

   // 输出排序之前的数组内容
   printf("排序之前的列表：\n");
   for( n = 0 ; n < 5; n++ ) {
      printf("%d ", values[n]);
   }

   // 使用 qsort 函数对数组进行排序
   qsort(values, 5, sizeof(int), cmpfunc);

   // 输出排序之后的数组内容
   printf("\n排序之后的列表：\n");
   for( n = 0 ; n < 5; n++ ) {
      printf("%d ", values[n]);
   }
  
   return 0;
}

结果

排序之前的列表：
88 56 100 2 25 
排序之后的列表：
2 25 56 88 100

isalnum函数

声明

int isalnum(int c);

描述

检查所传的字符是否是字母和数字。

参数

c:这是要检查的字符。

返回值

如果 c 是一个数字或一个字母，则该函数返回非零值，否则返回 0。

实例

#include <stdio.h>
#include <ctype.h>

int main()
{
   int var1 = 'd';
   int var2 = '2';
   int var3 = '\t';
   int var4 = ' ';
    
   if( isalnum(var1) )
   {
      printf("var1 = |%c| 是字母数字\n", var1 );
   }
   else
   {
      printf("var1 = |%c| 不是字母数字\n", var1 );
   }
   if( isalnum(var2) )
   {
      printf("var2 = |%c| 是字母数字\n", var2 );
   }
   else
   {
      printf("var2 = |%c| 不是字母数字\n", var2 );
   }
   if( isalnum(var3) )
   {
      printf("var3 = |%c| 是字母数字\n", var3 );
   }
   else
   {
      printf("var3 = |%c| 不是字母数字\n", var3 );
   }
   if( isalnum(var4) )
   {
      printf("var4 = |%c| 是字母数字\n", var4 );
   }
   else
   {
      printf("var4 = |%c| 不是字母数字\n", var4 );
   }
        
   return(0);
}

结果

var1 = |d| 是字母数字
var2 = |2| 是字母数字
var3 = | | 不是字母数字
var4 = | | 不是字母数字

isalpha函数

声明

int isalpha(int c);

描述

检查所传的字符是否是字母。

参数

c – 这是要检查的字符。

返回值

如果 c 是一个字母，则该函数返回非零值，否则返回 0。

实例

#include <stdio.h>
#include <ctype.h>

int main()
{
   int var1 = 'd';
   int var2 = '2';
   int var3 = '\t';
   int var4 = ' ';
    
   if( isalpha(var1) )
   {
      printf("var1 = |%c| 是一个字母\n", var1 );
   }
   else
   {
      printf("var1 = |%c| 不是一个字母\n", var1 );
   }
   if( isalpha(var2) )
   {
      printf("var2 = |%c| 是一个字母\n", var2 );
   }
   else
   {
      printf("var2 = |%c| 不是一个字母\n", var2 );
   }
   if( isalpha(var3) )
   {
      printf("var3 = |%c| 是一个字母\n", var3 );
   }
   else
   {
      printf("var3 = |%c| 不是一个字母\n", var3 );
   }
   if( isalpha(var4) )
   {
      printf("var4 = |%c| 是一个字母\n", var4 );
   }
   else
   {
      printf("var4 = |%c| 不是一个字母\n", var4 );
   }
   
   return(0);
}

结果

var1 = |d| 是一个字母
var2 = |2| 不是一个字母
var3 = | | 不是一个字母
var4 = | | 不是一个字母

isgraph函数

声明

int isgraph(int c);

描述

检查所传的字符是否有图形表示法。带有图形表示法的字符是除了空白字符（比如 ’ '）以外的所有可打印的字符。

参数

c – 这是要检查的字符。

返回值

如果 c 有图形表示法，则该函数返回非零值，否则返回 0。

实例

#include <stdio.h>
#include <ctype.h>
 
int main()
{
   int var1 = '3';
   int var2 = 'm';
   int var3 = ' ';
    
   if( isgraph(var1) )
   {
       printf("var1 = |%c| 是可打印的\n", var1 );
   }
   else
   {
      printf("var1 = |%c| 是不可打印的\n", var1 );
   }
   if( isgraph(var2) )
   {
       printf("var2 = |%c| 是可打印的\n", var2 );
   }
   else
   {
      printf("var2 = |%c| 是不可打印的\n", var2 );
   }
   if( isgraph(var3) )
   {
       printf("var3 = |%c| 是可打印的\n", var3 );
   }
   else
   {
      printf("var3 = |%c| 是不可打印的\n", var3 );
   }
   
   return(0);
}

结果

var1 = |3| 是可打印的
var2 = |m| 是可打印的
var3 = | | 是不可打印的

isprint函数

声明

int isprint(int c);

描述

检查所传的字符是否是可打印的。可打印字符是非控制字符的字符。

除了空白字符 (例如 ’ ')外，isgraph和isprint在相同条件下，返回值是一样的。对于空白字符，isprint检查的时候返回true，而isgraph检查的时候返回false。

参数

c – 这是要检查的字符。

返回值

如果 c 是一个可打印的字符，则该函数返回非零值（true），否则返回 0（false）。

实例

#include <stdio.h>
#include <ctype.h>

int main()
{
   int var1 = 'k';
   int var2 = '8';
   int var3 = '\t';
   int var4 = ' ';
    
   if( isprint(var1) )
   {
      printf("var1 = |%c| 是可打印的\n", var1 );
   }
   else
   {
      printf("var1 = |%c| 是不可打印的\n", var1 );
   }
   if( isprint(var2) )
   {
      printf("var2 = |%c| 是可打印的\n", var2 );
   }
   else
   {
      printf("var2 = |%c| 是不可打印的\n", var2 );
   }
   if( isprint(var3) )
   {
      printf("var3 = |%c| 是可打印的\n", var3 );
   }
   else
   {
      printf("var3 = |%c| 是不可打印的\n", var3 );
   }
   if( isprint(var4) )
   {
      printf("var4 = |%c| 是可打印的\n", var4 );
   }
   else
   {
      printf("var4 = |%c| 是不可打印的\n", var4 );
   }
   
   return(0);
}

结果

var1 = |k| 是可打印的
var2 = |8| 是可打印的
var3 = |    | 是不可打印的
var4 = | | 是可打印的

ispunct函数

声明

int ispunct(int c);

描述

检查所传的字符是否是标点符号字符。标点符号字符可以是非字母数字（正如isalnum中的一样）的任意图形字符（正如isgraph中的一样）。

参数

c – 这是要检查的字符。

返回值

如果 c 是一个标点符号字符，则该函数返回非零值（true），否则返回 0（false）。

实例

#include <stdio.h>
#include <ctype.h>

int main()
{
   int var1 = 't';
   int var2 = '1';
   int var3 = '/';
   int var4 = ' ';

   if( ispunct(var1) )
   {
       printf("var1 = |%c| 是标点符号字符\n", var1 );
   }
   else
   {
       printf("var1 = |%c| 不是标点符号字符\n", var1 );
   }
   if( ispunct(var2) )
   {
       printf("var2 = |%c| 是标点符号字符\n", var2 );
   }
   else
   {
       printf("var2 = |%c| 不是标点符号字符\n", var2 );
   }
   if( ispunct(var3) )
   {
       printf("var3 = |%c| 是标点符号字符\n", var3 );
   }
   else
   {
       printf("var3 = |%c| 不是标点符号字符\n", var3 );
   }
   if( ispunct(var4) )
   {
       printf("var4 = |%c| 是标点符号字符\n", var4 );
   }
   else
   {
       printf("var4 = |%c| 不是标点符号字符\n", var4 );
   }
   
   return(0);
}

结果

var1 = |t| 不是标点符号字符
var2 = |1| 不是标点符号字符
var3 = |/| 是标点符号字符
var4 = | | 不是标点符号字符

isspace函数

声明

int isspace(int c);

描述

检查所传的字符是否是空白字符。

' '     (0x20)    space (SPC) 			空格符
'\t'    (0x09)    horizontal tab (TAB) 	水平制表符    
'\n'    (0x0a)    newline (LF) 			换行符
'\v'    (0x0b)    vertical tab (VT) 	垂直制表符
'\f'    (0x0c)    feed (FF) 			换页符
'\r'    (0x0d)    carriage return (CR) 	回车符

参数

c – 这是要检查的字符。

返回值

如果 c 是一个空白字符，则该函数返回非零值（true），否则返回 0（false）。

实例

#include <stdio.h>
#include <ctype.h>

int main()
{
   int var1 = 't';
   int var2 = '1';
   int var3 = ' ';

   if( isspace(var1) )
   {
       printf("var1 = |%c| 是空白字符\n", var1 );
   }
   else
   {
       printf("var1 = |%c| 不是空白字符\n", var1 );
   }
   if( isspace(var2) )
   {
       printf("var2 = |%c| 是空白字符\n", var2 );
   }
   else
   {
       printf("var2 = |%c| 不是空白字符\n", var2 );
   }
   if( isspace(var3) )
   {
       printf("var3 = |%c| 是空白字符\n", var3 );
   }
   else
   {
       printf("var3 = |%c| 不是空白字符\n", var3 );
   }
   
   return(0);
}

结果

var1 = |t| 不是空白字符
var2 = |1| 不是空白字符
var3 = | | 是空白字符

isupper函数

声明

int isupper(int c);

描述

检查所传的字符是否是大写字母。

参数

c – 这是要检查的字符。

返回值

如果 c 是一个大写字母，则该函数返回非零值（true），否则返回 0（false）。

实例

#include <stdio.h>
#include <ctype.h>

int main()
{
   int var1 = 'M';
   int var2 = 'm';
   int var3 = '3';
    
   if( isupper(var1) )
   {
      printf("var1 = |%c| 是大写字母\n", var1 );
   }
   else
   {
      printf("var1 = |%c| 不是大写字母\n", var1 );
   }
   if( isupper(var2) )
   {
      printf("var2 = |%c| 是大写字母\n", var2 );
   }
   else
   {
      printf("var2 = |%c| 不是大写字母\n", var2 );
   }   
   if( isupper(var3) )
   {
      printf("var3 = |%c| 是大写字母\n", var3 );
   }
   else
   {
      printf("var3 = |%c| 不是大写字母\n", var3 );
   }
   
   return(0);
}

结果

var1 = |M| 是大写字母
var2 = |m| 不是大写字母
var3 = |3| 不是大写字母

islower函数

声明

int islower(int c);

描述

检查所传的字符是否是小写字母。

参数

c – 这是要检查的字符。

返回值

如果 c 是一个小写字母，则该函数返回非零值（true），否则返回 0（false）。

实例

#include <stdio.h>
#include <ctype.h>

int main()
{
   int var1 = 'Q';
   int var2 = 'q';
   int var3 = '3';
    
   if( islower(var1) )
   {
       printf("var1 = |%c| 是小写字母\n", var1 );
   }
   else
   {
      printf("var1 = |%c| 不是小写字母\n", var1 );
   }
   if( islower(var2) )
   {
       printf("var2 = |%c| 是小写字母\n", var2 );
   }
   else
   {
      printf("var2 = |%c| 不是小写字母\n", var2 );
   }
   if( islower(var3) )
   {
       printf("var3 = |%c| 是小写字母\n", var3 );
   }
   else
   {
      printf("var3 = |%c| 不是小写字母\n", var3 );
   }
   
   return(0);
}

结果

var1 = |Q| 不是小写字母
var2 = |q| 是小写字母
var3 = |3| 不是小写字母

isxdigit函数

声明

int isxdigit(int c);

描述

检查所传的字符是否是十六进制数字。
十六进制一般用数字0到9和字母A到F（或a-f）表示，其中A-F表示10~15: 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F。

参数

c – 这是要检查的字符。

返回值

如果 c 是一个十六进制数字，则该函数返回非零的整数值，否则返回 0。

实例

#include <ctype.h>
#include <stdio.h>
 
int main() {
   char c = '5';
   int result;
 
   // 传入字符
   result = isxdigit(c); // result 返回非 0
   printf("%c 传入到 isxdigit() 函数结果为: %d", c, isxdigit(c));
   printf("\n");  // 换行
   c = 'M';
 
   // 非十六进制数作为参数
   result = isxdigit(c); // result 为 0
 
   printf("%c 传入到 isxdigit() 函数结果为: %d", c, isxdigit(c));
 
   return 0;
}

结果

5 传入到 isxdigit() 函数结果为: 1
M 传入到 isxdigit() 函数结果为: 0

isdigit函数

声明

int isdigit(int c);

描述

检查所传的字符是否是十进制数字字符。

十进制数字是：0 1 2 3 4 5 6 7 8 9

参数

c – 这是要检查的字符。

返回值

如果 c 是一个数字，则该函数返回非零值，否则返回 0。

实例

#include <stdio.h>
#include <ctype.h>

int main()
{
   int var1 = 'h';
   int var2 = '2';
    
   if( isdigit(var1) )
   {
      printf("var1 = |%c| 是一个数字\n", var1 );
   }
   else
   {
      printf("var1 = |%c| 不是一个数字\n", var1 );
   }
   if( isdigit(var2) )
   {
      printf("var2 = |%c| 是一个数字\n", var2 );
   }
   else
   {
      printf("var2 = |%c| 不是一个数字\n", var2 );
   }
  
   return(0);
}

结果

var1 = |h| 不是一个数字
var2 = |2| 是一个数字

tolower函数

声明

int tolower(int c);

描述

把给定的字母转换为小写字母。

参数

c – 这是要被转换为小写的字母。

返回值

如果 c 有相对应的小写字母，则该函数返回 c 的小写字母，否则 c 保持不变。返回值是一个可被隐式转换为 char 类型的 int 值。

实例

#include <stdio.h>
#include <ctype.h>
 
int main()
{
   int i = 0;
   char c;
   char str[] = "RUNOOB";
 
   while( str[i] ) 
   {
      putchar(tolower(str[i]));
      i++;
   }
 
   return(0);
}

结果

runoob

toupper函数

声明

int toupper(int c);

描述

把小写字母转换为大写字母。

参数

c – 这是要被转换为大写的字母。

返回值

如果 c 有相对应的大写字母，则该函数返回 c 的大写字母，否则 c 保持不变。返回值是一个可被隐式转换为 char 类型的int值。

实例

#include <stdio.h>
#include <ctype.h>

int main()
{
   int i = 0;
   char c;
   char str[] = "runoob";
   
   while(str[i])
   {
      putchar(toupper(str[i]));
      i++;
   }
   
  return(0);
}