C/C++常用标准库函数

标准的C++库中的内容主要包括：

          (1)基本运行时语言支持

          (2)C语言标准库

          (3)字符串和输入输出流

          (4)标准容器和算法

          (5)对数制计算的支持

》数学函数

    数学函数在头文件<cmath>中被声明，调用前应在源程序文件中加入预处理命令：#include<cmath>

   (1)三角函数

          # acos

          原型：double acos(double x);

          说明：计算参数x的反余弦值。x的取值范围是[-1,+1]。

          返回：以弧度为单位的反余弦值，取值范围是[0，π]。

          # asin

          原型：double asin(double x);

          说明：计算参数x的反正弦值。x的取值范围是[-1,+1]。

          返回：以弧度为单位的反正弦值，取值范围是[-π/2,+π/2]。

          # atan

          原型：double atan(double x);

          说明：计算参数x的反正切值。

          返回：以弧度为单位的反正切值，取值范围是[-π/2,+π/2]。

          # atan2

          原型：double atan2(double y,double x);

          说明：计算y/x的反正切值,并利用两个参数的正负号决定返回值的象限。x,y不能同时取0。

          返回：以弧度为单位的反正切值，取值范围是[-π,+π]。
          # cos

          原型：double cos(double x);

          说明：计算参数x的余弦值。以x为弧度单位。

          返回：余弦值。

          # sin

          原型：double sin(double x);

          说明：计算参数x的正弦值。以x为弧度单位。

          返回：正弦值。

          # tan

          原型：double tan(double x);

          说明：计算参数x的正切值。以x为弧度单位。

          返回：正切值。
   (2)双曲函数         

          # cosh

          原型：double cosh(double x);

          说明：计算参数x的双曲余弦值。

          返回：双曲余弦值。

          # sinh

          原型：double sinh(double x);

          说明：计算参数x的双曲正弦值。

          返回：双曲正弦值。

          # tanh

          原型：double tanh(double x);

          说明：计算参数x的双曲正切值。

          返回：双曲正切值。
   (3)指数和对数函数

          # exp

          原型：double exp(double x);

          说明：计算参数x的指数函数e^x。

          返回：指数函数值。

          # frexp

          原型：double frexp(double value,int* exp);

          说明：将value分解为尾数x和以2为底的指数n，即value=x*2^n。指数n被存放在整型指针exp所指的变量中。

          返回：尾数值x,x的取值范围是[1/2,1]或0。如果value等于0，则尾数x和指数n都返回0。

          # ldexp

          原型：double ldexp(double x,int exp);

          说明：计算参数x与2的exp次幂的乘积。

          返回：结果值y，其中y=x*2^exp。

          # tanh

          原型：double tanh(double x);

          说明：计算参数x的双曲正切值。

          返回：双曲正切值。

          # log

          原型：double log(double x);

          说明：计算参数x的自然对数ln x,x的取值范围是x>0。

          返回：自然对数值。

          # log10

          原型：double log10(double x);

          说明：计算参数x的以10为底的对数lg x,x的取值范围是x>0。

          返回：以10为底的对数值

          # modf

          原型：double modf(double value,double* iptr);

          说明：将value分解为整数部分和小数部分，两部分的正负号都与value相同。整数部分作为double型值被存放在指针iptr所指的变量中。

          返回：value的小数部分。
   (4)幂函数

          # pow

          原型：double pow(double x,double y);

          说明：计算参数x的y次幂，即x^y。

          返回：x^y的值。

          # sqrt

          原型：double sqrt(double x);

          说明：计算参数x的平方根，x的取值范围是x>=0。

          返回：平方根值。
   (5)其他函数

          # ceil

          原型：double ceil(double x);

          说明：计算不小于参数x的最小整数。

          返回：以double类型表示的不小于x的最小整数值。

          # fabs

          原型：double fabs(double x);

          说明：计算参数x的绝对值。

          返回：绝对值。

          # fmod

          原型：double fmod(double x,double y);

          说明：计算x除以y所得的余数。

          返回：以double类型表示的余数值。
》字符函数

    字符函数在头文件<cctype>中被声明，调用前应在源程序文件中加入预处理命令：#include<cctype>

    (1)字符测试函数

     这组函数的返回值规定如下：如果参数满足函数说明中描述的条件，则函数返回非零值；否则，函数返回0。

           # isalnum

           原型：int isalnum(int c);

           说明：测试参数c是否为字母（包括大小写）或数字。

           # isalpha

           原型：int isalpha(int c);

           说明：测试参数c是否为字母（包括大小写）。

           # iscntrl

           原型：int iscntrl(int c);

           说明：测试参数c是否为控制字符（ASCII码0~31,127）。

           # isdigit

           原型：int isdigit(int c);

           说明：测试参数c是否为数字（'0','1',...,'9'）。

           # isgraph

           原型：int isgraph(int c);

           说明：测试参数c是否为不包括空格在内的可打印字符（ASCII码33~126）。

           # islower

           原型：int islower(int c);

           说明：测试参数c是否为小写字母（'a','b',...,'z'）。

           # isprint

           原型：int isprint(int c);

           说明：测试参数c是否为可打印字符（包括空格，即ASCII码32~126）或数字。

           # ispunct

           原型：int ispunct(int c);

           说明：测试参数c是否为不包括空格、字母和数字在内的可打印字符。（即ASCII码33~47,58~64,91~96,123~126）。

           # isspace

           原型：int isspace(int c);

           说明：测试参数c是否为空白字符。在C++语言中空白字符是指：空格(' ')、换页('\f')、换行('\n')、回车(‘\r’)、水平制表('\t')和垂直制表(‘\v’)。

           # isupper

           原型：int isupper(int c);

           说明：测试参数c是否为大写字母（'A','B',...,'Z'）。

           # isxdigit

           原型：int isxdigit(int c);

           说明：测试参数c是否为16进制数字（'0'~'9',‘a’~'f','A'~'F'）。

    (2)字母大小写转换函数

           # tolower

           原型：int tolower(int c);

           说明：将一个大写字母转换为与之对应的小写字母。

           返回：如果参数c是一个大写字母（即c使函数isupper成立），则返回与其对应的小写字母（即返回值使函数islower成立）；否则，返回参数c（即不改变c的值)。

           # toupper

           原型：int toupper(int c);

           说明：将一个小写字母转换为与之对应的大写字母。

           返回：如果参数c是一个小写字母（即c使函数islower成立），则返回与其对应的大写字母（即返回值使函数isupper成立）；否则，返回参数c（即不改变c的值)。
》字符串函数

    字符串函数在头文件<cstring>中被声明，调用前应在源程序文件中加入预处理命令：#include<cstring>

    <cstring>声明了类型size_t,可以将size_t理解成无符号整型；

           #define unsigned int size_t

    (1)复制函数

           # strcpy

           原型：char* strcpy(char* p,const char* q);

           说明：将q指向的字符串（包括结尾的空字符）复制到p指向的字符数组中。

           返回：字符指针p的值。

           # strncpy

           原型：char* strncpy(char* p,const char* q,size_t n);

           说明：将q指向的字符串中不多于前n个字符（空字符之后的字符不会被拷贝）拷贝到p指向的字符数组中。如果q指向的字符串中字符的个数小于n，则将空字符添加到p指向的字符数组中拷贝的结尾，直接写入p中的字符个数达到n。

           返回：字符指针p的值。

    (2)连接函数

           # strcat

           原型：char* strcat(char* p,const char* q);

           说明：将q指向的字符串的一个拷贝（包括结尾的空字符）连接到p指向的字符串结尾。q的首字符会覆盖p结尾的空字符。

           返回：字符指针p的值。

           # strncat

           原型：char* strncat(char* p,const char* q,size_t n);

           说明：将q指向的字符串中不多于前n个字符（空字符及其之后的字符不会被连接）连接到p指向的字符串结尾。q的首字符会覆盖p结尾的空字符。函数总会在结果字符串p的末尾添加一个空字符。

           返回：字符指针p的值。

    (3)比较函数

           # strcmp

           原型：int strcmp(const char* p,const char* q);

           说明：将p指向的字符串与q指向的字符串进行比较。

           返回：如果p<q，则返回负整数；如果p=q，则返回0；如果p>q，则返回正整数。

           # strncmp

           原型：int strncmp(const char* p,const char* q,size_t n);

           说明：在p指向的字符串中查找第一次出现字符c（将参数c由int型转换为char型）的位置。结尾的空字符被认为是字符串的一部分。

           返回：如果p<q，则返回负整数；如果p=q，则返回0；如果p>q，则返回正整数。

    (4)查找函数

           # strchr

           原型：char* strchr(const char* p,int c);

           说明：在p指向的字符串中查找第一次出现字符c（将参数c由int型转换为char型）的位置。结尾的空字符被认为是字符串的一部分。

           返回：如果找到字符c，则返回指向它的指针；否则，返回空指针。

           # strrchr

           原型：char* strrchr(const char* p,int c);

           说明：在p指向的字符串中查找最后一次出现字符c（将参数c由int型转换为char型）的位置。结尾的空字符被认为是字符串的一部分。

           返回：如果找到字符c，则返回指向它的指针；否则，返回空指针

           # strstr

           原型：char* strstr(const char* p,const char* q);

           说明：在p指向的字符串中查找第一次出现q指向的字符串中字符序列（不包括结尾的空字符）的位置。

           返回：如果找到字符序列q，则返回指向它的指针；否则，返回空指针。如果q指向一个长度为0的字符串，则函数返回指针p的值。

           # strpbrk

           原型：char* strpbrk(const char* p,const char* q);

           说明：在p指向的字符串中查找第一次出现q指向的字符串中任何字符的位置。

           返回：如果在p中找到q中含有的任何字符，则返回指向该字符的指针；否则，返回空指针。

           # strspn

           原型：size_t strspn(const char* p,const char* q);

           说明：在p指向的字符串中查找第一个与q指向的字符串中所有字符都不相同的字符下标。

           返回：该字符下标值。

           # strcspn

           原型：size_t strcspn(const char* p,const char* q);

           说明：在p指向的字符串中查找第一个与q指向的字符串中所有字符都相同的字符下标。

           返回：该字符下标值。

    (5)其他函数

           # strlen

           原型：size_t strlen(const char* p);

           说明：计算p指向的字符串的长度。

           返回：出现在结尾空字符之前的字符个数。

》一般工具函数

    一般工具函数在头文件<cstdlib>中被声明，调用前应在源程序文件中加入预处理命令：#include<cstdlib>

    (1)字符串转换函数

           # atof

           原型：double atof(const char* p);

           说明：将p指向的字符串转换为double型数值。

           返回：转换后的double型数值。

           # atoi

           原型：int atoi(const char* p);

           说明：将p指向的字符串转换为int型数值。

           返回：转换后的int型数值。

           # atol

           原型：long atol(const char* p);

           说明：将p指向的字符串转换为long int型数值。

           返回：转换后的long int型数值。

    (2)伪随机数序列产生函数

           # rand

           原型：int rand();

           说明：计算0到RAND_MAX范围内的伪随机整数序列。RAND_MAX至少应等于32767。

           返回：一个伪随机整数值。

           # srand

           原型：void srand(unsigned int seed);

           说明：使用参数seed的值作为接下来调用函数rand产生的伪随机数序列的种子。

           返回：无返回值。

    (3)内存管理函数

     在C++语言中应用new和delete运算符来进行内存管理操作。但为了与C语言兼容，标准C++库中仍保留了malloc,calloc,realloc,free等函数。

           # malloc

           原型：void* malloc(size_t s);

           说明：分配一块大小为s个字节的内存空间。

           返回：如果分配成功，则返回指向这块内存空间的指针；如果分配失败，则返回空指针。

           # calloc

           原型：void* calloc(size_t n,size_t s);

           说明：分配n个数据项的内存空间，每个数据项的大小为s个字节。

           返回：如果分配成功，则返回指向这块内存空间的指针；如果分配失败，则返回空指针。

           # realloc

           原型：void* realloc(void* p,size_t s);

           说明：将p指向的内存空间的大小改变为s个字节。

           返回：如果分配成功，则返回指向改变大小后的内存空间的指针；如果分配失败，则返回空指针。

           # free

           原型：void free(void* p);

           说明：将p指向的内存空间释放。

           返回：无返回值。

    (4)与系统通信的函数

           # abort

           原型：void abort();

           说明：将程序非正常终止。

           返回：此函数不能再返回它的调用者。

           # exit

           原型：void exit(int status);

           说明：将程序正常终止，并把状态值status返回给操作系统。

           返回：此函数不能再返回它的调用者。

           # getenv

           原型：char* getenv(const char* name);

           说明：在操作系统提供的环境变量列表中查找与name指向的字符串匹配的环境变量。

           返回：如果找到该环境变量，则返回指向其值的字符指针；否则，返回空指针。

           # system

           原型：int system(const char* str);

           说明：将str指向的字符串作为操作系统命令执行。

           返回：如果参数str是空指针，则当命令处理程序存在时函数返回非零值。如果参数str不是空指针，则函数返回一个由编译器定义的数值。

    (5)搜索和排序函数

           # bsearch

           原型：void* bsearch(const void* key,const void* base,size_t nmenb,size_t size,int(* cmp)(const void*,const void*));

           说明：base指向含有nmemb个数据项的数组的首元素，size指明数组中每个元素的长度，key指向要搜索的关键数据项，cmp是指向比较函数的指针。本函数使用二分法在base指向的数组中搜索与关键数据项key匹配的元素。

           返回：如果搜索到匹配元素，则返回指向该元素的指针；如果未找到匹配元素，则返回空指针。

           # qsort

           原型：void qsort(void* base,size_t nmemb,size_t size,int(*cmp)(const void*,const void*));

           说明：base指向含有nmemb个数据项的数组的首元素，size指明数组中每个元素的长度，cmp是指向比较函数的指针。本函数使用快速排序法对base指向的数组中的元素进行排序。

           返回：无返回值。

    (6)整数算术函数

           # abs

           原型：int abs(int n);

           说明：计算整数n的绝对值。

           返回：绝对值。

           # labs

           原型：long labs(long n);

           说明：除了参数和返回值类型为long int外，其余与函数abs相同。

           返回：绝对值。

           # div

           原型：div_t div(int n,int d);

           说明：计算n除以d（n/d）所得的商和余数。设商为quot，余数为rem，则

                       n=quot*d+rem;

                       成立。

           返回：一个类型为div_t的结构,其中包含商和余数。div_t的定义如下：

                       struct div_t{

                                 int quot;   //quotient

                                 int rem;    //remainder

                       };

           # ldiv

           原型：ldiv_t ldiv(long int n,long int d);

           说明：除了参数类型为long int,返回值类型为ldiv_t之外，其余与函数div相同。

           返回：一个类型为ldiv_t的结构，其中包含商和余数。ldiv_t的定义如下：

                       struct ldiv_t{

                                long int quot;    //quotient

                                long int rem;     //remainder

                        };