数学库

1、三角函数 Trigonometric functions

1.1、 cos() 函数

/* cos example */

#include <stdio.h> /* printf */

#include <math.h> /* cos */

#define PI 3.14159265

intmain ()

{

doubleparam, result;

param=60.0;

result=cos ( param*PI/180.0 );

printf ("The cosine of %f degrees is %f.\n", param, result );

return0;

}

1.2 sin() 正弦函数

/* sin example */

#include <stdio.h> /* printf */

#include <math.h> /* sin */

#define PI 3.14159265

intmain ()

{

doubleparam, result;

param=30.0;

result=sin (param*PI/180);

printf ("The sine of %f degrees is %f.\n", param, result );

return0;

}

1.3、 tan() 正切函数

/* tan example */

#include <stdio.h> /* printf */

#include <math.h> /* tan */

#define PI 3.14159265

intmain ()

{

doubleparam, result;

param=45.0;

result=tan ( param*PI/180.0 );

printf ("The tangent of %f degrees is %f.\n", param, result );

return0;

}

1.4、 acos() 反余弦函数

/* acos example */

#include <stdio.h> /* printf */

#include <math.h> /* acos */

#define PI 3.14159265

intmain ()

{

doubleparam, result;

param=0.5;

result=acos (param) *180.0/PI;

printf ("The arc cosine of %f is %f degrees.\n", param, result);

return0;

}

1.5、asin() 反正弦函数

/* asin example */

#include <stdio.h> /* printf */

#include <math.h> /* asin */

#define PI 3.14159265

intmain ()

{

doubleparam, result;

param=0.5;

result=asin (param) *180.0/PI;

printf ("The arc sine of %f is %f degrees\n", param, result);

return0;

}

1.6、atan() 反正切函数

/* atan example */

#include <stdio.h> /* printf */

#include <math.h> /* atan */

#define PI 3.14159265

intmain ()

{

doubleparam, result;

param=1.0;

result=atan (param) *180/PI;

printf ("The arc tangent of %f is %f degrees\n", param, result );

return0;

}

1.7、atan2() 带两个参数的反正切函数

/* atan2 example */

#include <stdio.h> /* printf */

#include <math.h> /* atan2 */

#define PI 3.14159265

intmain ()

{

doublex, y, result;

x=-10.0;

y=10.0;

result=atan2 (y,x) *180/PI;

printf ("The arc tangent for (x=%f, y=%f) is %f degrees\n", x, y, result );

return0;

}

2、双曲函数 Hyperbolic functions

2.1、双曲余弦函数

/* cosh example */

#include <stdio.h> /* printf */

#include <math.h> /* cosh, log */

intmain ()

{

doubleparam, result;

param=log(2.0);

result=cosh (param);

printf ("The hyperbolic cosine of %f is %f.\n", param, result );

return0;

}

2.2、双曲正弦函数

/* sinh example */

#include <stdio.h> /* printf */

#include <math.h> /* sinh, log */

int main ()

{

double param, result;

param = log(2.0);

result = sinh (param);

printf ("The hyperbolic sine of %f is %f.\n", param, result );

return 0;

}

2.3、双曲正切函数

/* tanh example */

#include <stdio.h> /* printf */

#include <math.h> /* tanh, log */

int main ()

{

double param, result;

param = log(2.0);

result = tanh (param);

printf ("The hyperbolic tangent of %f is %f.\n", param, result);

return 0;

}

3、指数函数与对数函数 Exponential and logarithmic functions

3.1、exp () 指数函数，以 e 为底数

/* exp example */

#include <stdio.h> /* printf */

#include <math.h> /* exp */

int main ()

{

double param, result;

param = 5.0;

result = exp (param);

printf ("The exponential value of %f is %f.\n", param, result );

return 0;

}

3.2、frexp(param，n) 二进制浮点数表示方法 **x=param*2^n**

/* frexp example */

#include <stdio.h> /* printf */

#include <math.h> /* frexp */

int main ()

{

double param, result;

int n;

param = 8.0;

result = frexp (param , &n);

printf ("%f = %f * 2^%d\n", param, result, n);

return 0;

}

3.3、log(x) x的自然对数 (Natural logarithm of x)

/* log example */

#include <stdio.h> /* printf */

#include <math.h> /* log */

int main ()

{

double param, result;

param = 5.5;

result = log (param);

printf ("log(%f) = %f\n", param, result );

return 0;

}

3.4、log10() 常用对数，以10为底 ( Common logarithm of x )

/* log10 example */

#include <stdio.h> /* printf */

#include <math.h> /* log10 */

int main ()

{

double param, result;

param = 1000.0;

result = log10 (param);

printf ("log10(%f) = %f\n", param, result );

return 0;

}

3.5、modf() 返回x的小数部分，其符号与x相同，但是参数中可以添加整数部分的变量( The fractional part of x, with the same sign)

/* modf example */

#include <stdio.h> /* printf */

#include <math.h> /* modf */

int main ()

{

double param, fractpart, intpart;

param = 3.14159265;

fractpart = modf (param , &intpart);

printf ("%f = %f + %f \n", param, intpart, fractpart);

return 0;

}

3.6、exp2() 返回2的x次方，2 raised to the power of x.

/* exp2 example */

#include <stdio.h> /* printf */

#include <math.h> /* exp2 */

int main ()

{

double param, result;

param = 8.0;

result = exp2 (param);

printf ("2 ^ %f = %f.\n", param, result );

return 0;

}

3.7、log2() x的二进制对数( The binary logarithm of x)

/* log2 example */

#include <stdio.h> /* printf */

#include <math.h> /* log2 */

int main ()

{

double param, result;

param = 1024.0;

result = log2 (param);

printf ("log2 (%f) = %f.\n", param, result );

return 0;

}

4、幂函数 Power functions

4.1、pow(base, power) 幂函数 The result of raising base to the power exponent

/* pow example */

#include <stdio.h> /* printf */

#include <math.h> /* pow */

int main ()

{

printf ("7 ^ 3 = %f\n", pow (7.0, 3.0) );

printf ("4.73 ^ 12 = %f\n", pow (4.73, 12.0) );

printf ("32.01 ^ 1.54 = %f\n", pow (32.01, 1.54) );

return 0;

}

4.2、sqrt(x) 计算x的平方根

/* sqrt example */

#include <stdio.h> /* printf */

#include <math.h> /* sqrt */

int main ()

{

double param, result;

param = 1024.0;

result = sqrt (param);

printf ("sqrt(%f) = %f\n", param, result );

return 0;

}

4.3、cbrt(x) 计算x的立方根

/* cbrt example */

#include <stdio.h> /* printf */

#include <math.h> /* cbrt */

int main ()

{

double param, result;

param = 27.0;

result = cbrt (param);

printf ("cbrt (%f) = %f\n", param, result);

return 0;

}

4.4、hypot(x,y) 计算直角三角形的斜边 ( The square root of (x^2+y^2) )

/* hypot example */

#include <stdio.h> /* printf */

#include <math.h> /* hypot */

int main ()

{

double leg_x, leg_y, result;

leg_x = 3;

leg_y = 4;

result = hypot (leg_x, leg_y);

printf ("%f, %f and %f form a right-angled triangle.\n",leg_x,leg_y,result);

return 0;

}

5、误差与伽马函数 Error and gamma functions

5.1、误差函数erf(x)

网络异常，图片无法展示
|

/* erf example */

#include <stdio.h> /* printf */

#include <math.h> /* erf */

int main ()

{

double param, result;

param = 1.0;

result = erf (param);

printf ("erf (%f) = %f\n", param, result );

return 0;

}

5.2、余差函数erfc(x) erfc(x) = 1-erf(x) 误差函数的补函数

网络异常，图片无法展示
|

/* erfc example */

#include <stdio.h> /* printf */

#include <math.h> /* erfc */

int main ()

{

double param, result;

param = 1.0;

result = erfc (param);

printf ("erfc(%f) = %f\n", param, result );

return 0;

}

5.3、tgamma(x) 伽马函数 ( the gamma function )

网络异常，图片无法展示
|

/* tgamma example */

#include <stdio.h> /* printf */

#include <math.h> /* tgamma */

int main ()

{

double param, result;

param = 0.5;

result = tgamma (param);

printf ("tgamma(%f) = %f\n", param, result );

return 0;

}

5.4、lgamma(x) log伽马函数 ( log-gamma function )

网络异常，图片无法展示
|

/* lgamma example */

#include <stdio.h> /* printf */

#include <math.h> /* lgamma */

int main ()

{

double param, result;

param = 0.5;

result = lgamma (param);

printf ("lgamma(%f) = %f\n", param, result );

return 0;

}

6、四舍五入与余数函数Rounding and remainder functions

6.1、ceil(x) x上取整函数

/* ceil example */

#include <stdio.h> /* printf */

#include <math.h> /* ceil */

int main ()

{

printf ( "ceil of 2.3 is %.1f\n", ceil(2.3) );

printf ( "ceil of 3.8 is %.1f\n", ceil(3.8) );

printf ( "ceil of -2.3 is %.1f\n", ceil(-2.3) );

printf ( "ceil of -3.8 is %.1f\n", ceil(-3.8) );

return 0;

}

6.2、floor(x) x的下取整函数

/* floor example */

#include <stdio.h> /* printf */

#include <math.h> /* floor */

int main ()

{

printf ( "floor of 2.3 is %.1lf\n", floor (2.3) );

printf ( "floor of 3.8 is %.1lf\n", floor (3.8) );

printf ( "floor of -2.3 is %.1lf\n", floor (-2.3) );

printf ( "floor of -3.8 is %.1lf\n", floor (-3.8) );

return 0;

}

6.3、fmod(y, x) y/x的余数

/* fmod example */

#include <stdio.h> /* printf */

#include <math.h> /* fmod */

int main ()

{

printf ( "fmod of 5.3 / 2 is %f\n", fmod (5.3,2) );

printf ( "fmod of 18.5 / 4.2 is %f\n", fmod (18.5,4.2) );

return 0;

}

6.4、round(x) x的四舍五入值

网络异常，图片无法展示
|

/* round vs floor vs ceil vs trunc */

#include <stdio.h> /* printf */

#include <math.h> /* round, floor, ceil, trunc */

int main ()

{

const char * format = "%.1f \t%.1f \t%.1f \t%.1f \t%.1f\n";

printf ("value\tround\tfloor\tceil\ttrunc\n");

printf ("-----\t-----\t-----\t----\t-----\n");

printf (format, 2.3,round( 2.3),floor( 2.3),ceil( 2.3),trunc( 2.3));

printf (format, 3.8,round( 3.8),floor( 3.8),ceil( 3.8),trunc( 3.8));

printf (format, 5.5,round( 5.5),floor( 5.5),ceil( 5.5),trunc( 5.5));

printf (format,-2.3,round(-2.3),floor(-2.3),ceil(-2.3),trunc(-2.3));

printf (format,-3.8,round(-3.8),floor(-3.8),ceil(-3.8),trunc(-3.8));

printf (format,-5.5,round(-5.5),floor(-5.5),ceil(-5.5),trunc(-5.5));

return 0;

}

7、绝对值、最小、最大 Absolute、Minimum, maximum

7.1、fabs(x) x的绝对值函数

/* fabs example */

#include <stdio.h> /* printf */

#include <math.h> /* fabs */

int main ()

{

printf ("The absolute value of 3.1416 is %f\n", fabs (3.1416) );

printf ("The absolute value of -10.6 is %f\n", fabs (-10.6) );

return 0;

}

7.2、abs(x) x的绝对值

// cmath's abs example

#include <iostream> // std::cout

#include <cmath> // std::abs

int main ()

{

std::cout << "abs (3.1416) = " << std::abs (3.1416) << '\n';

std::cout << "abs (-10.6) = " << std::abs (-10.6) << '\n';

return 0;

}

7.3、fmax(x, y) 两个参数中的最大值 (The maximum numeric value of its arguments. Values among which the function selects a maximum )

/* fmax example */

#include <stdio.h> /* printf */

#include <math.h> /* fmax */

int main ()

{

printf ("fmax (100.0, 1.0) = %f\n", fmax(100.0,1.0));

printf ("fmax (-100.0, 1.0) = %f\n", fmax(-100.0,1.0));

printf ("fmax (-100.0, -1.0) = %f\n", fmax(-100.0,-1.0));

return 0;

}

7.4、fmin(x, y) 两个参数中的最小值

/* fmin example */

#include <stdio.h> /* printf */

#include <math.h> /* fmin */

int main ()

{

printf ("fmin (100.0, 1.0) = %f\n", fmin(100.0,1.0));

printf ("fmin (-100.0, 1.0) = %f\n", fmin(-100.0,1.0));

printf ("fmin (-100.0, -1.0) = %f\n", fmin(-100.0,-1.0));

return 0;

}

通用工具库

思维导图大纲

前言

stdlib .h 头文件定义了四个变量类型、一些宏和各种通用工具函数。

double atof(const char *str)函数原型 double atof(const char *str)函数功能：把参数 str 所指向的字符串转换为一个浮点数（类型为 double 型）。

//时间：2019年11月18日

//作者：Kroner

//编译环境：VS 2019

//库函数 stdlib.h

//函数原型 double atof(const char *str)

//函数功能：把参数 str 所指向的字符串转换为一个浮点数（类型为 double 型）。

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

int main()

{

float val;

char str[20];

strcpy(str, "98993489");

val = atof(str);

printf("字符串值 = %s, 浮点值 = %f\n", str, val);

strcpy(str, "runoob");

val = atof(str);

printf("字符串值 = %s, 浮点值 = %f\n", str, val);

return 0;

}

测试结果：

int atoi(const char *str)函数原型 int atoi(const char *str)函数功能：把参数 str 所指向的字符串转换为一个整数（类型为 int 型）。

//时间：2019年11月18日

//作者：Kroner

//编译环境：VS 2019

//库函数 stdlib.h

//函数原型 int atoi(const char *str)

//函数功能：把参数 str 所指向的字符串转换为一个整数（类型为 int 型）。

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

int main()

{

int val;

char str[20];

strcpy(str, "98993489");

val = atoi(str);

printf("字符串值 = %s, 整型值 = %d\n", str, val);

strcpy(str, "runoob.com");

val = atoi(str);

printf("字符串值 = %s, 整型值 = %d\n", str, val);

return 0;

}

测试结果：

long int atol(const char *str)函数原型 long int atol(const char *str)函数功能：把参数 str 所指向的字符串转换为一个长整数（类型为 long int 型）

//时间：2019年11月18日

//作者：Kroner

//编译环境：VS 2019

//库函数 stdlib.h

//函数原型 long int atol(const char *str)

//函数功能：把参数 str 所指向的字符串转换为一个长整数（类型为 long int 型）

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

int main()

{

long val;

char str[20];

strcpy(str, "9899348911");

val = atol(str);

printf("字符串值 = %s, 长整型值 = %ld\n", str, val);

strcpy(str, "runoob.com");

val = atol(str);

printf("字符串值 = %s, 长整型值 = %ld\n", str, val);

return 0;

}

测试结果：

double strtod(const char *str, char endptr)函数原型 double strtod(const char *str, char endptr)函数功能：把参数 str 所指向的字符串转换为一个浮点数（类型为 double 型），str – 要转换为双精度浮点数的字符串。endptr – 对类型为 char* 的对象的引用，其值由函数设置为 str 中数值后的下一个字符。这个当第二个参数为空时和 double atof(const char *str)是相同，但是当而第二形参引用后，第二个指针会指向存储字符串位置的地址。

//时间：2019年11月18日

//作者：Kroner

//编译环境：VS 2019

//库函数 stdlib.h

//函数原型 double strtod(const char *str, char **endptr)

//函数功能：把参数 str 所指向的字符串转换为一个浮点数（类型为 double 型）。

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>

#include <stdlib.h>

int main()

{

char str[30] = "20.30300 This is test";

char* ptr;

double ret;

ret = strtod(str, &ptr);

printf("数字（double）是 %lf\n", ret);

printf("字符串部分是 |%s|", ptr);

return 0;

}

测试结果：

long int strtol(const char *str, char endptr, int base)函数原型 long int strtol(const char *str, char endptr, int base)函数功能：把参数 str 所指向的字符串转换为一个长整数（类型为 long int 型）。str – 要转换为长整数的字符串。endptr – 对类型为 char* 的对象的引用，其值由函数设置为 str 中数值后的下一个字符。base – 基数，必须介于 2 和 36（包含）之间，或者是特殊值 0。这个基数就表示这个多少数字就多少进制如果下列代码改为ret = strtol(str, &ptr, 8);就表示11112是八进制的数

//时间：2019年11月18日

//作者：Kroner

//编译环境：VS 2019

//库函数 stdlib.h

//函数原型 long int strtol(const char *str, char **endptr, int base)

//函数功能：把参数 str 所指向的字符串转换为一个长整数（类型为 long int 型）。

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>

#include <stdlib.h>

int main()

{

char str[30] = "11112 This is test";

char* ptr;

long ret;

ret = strtol(str, &ptr, 10);

printf("数字（无符号长整数）是 %ld\n", ret);

printf("字符串部分是 |%s|", ptr);

return 0;

}

测试结果：

unsigned long int strtoul(const char *str, char endptr, int base)函数原型 unsigned long int strtoul(const char *str, char endptr, int base)函数功能：把参数 str 所指向的字符串转换为一个无符号长整数（类型为 unsigned long int 型）。

//时间：2019年11月19日

//作者：Kroner

//编译环境：VS 2019

//库函数 stdlib.h

//函数原型 unsigned long int strtoul(const char *str, char **endptr, int base)

//函数功能：把参数 str 所指向的字符串转换为一个无符号长整数（类型为 unsigned long int 型）。

#define _CRT_SECURE_NO_WARNINGS

#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;

}

测试结果：

void *calloc(size_t nitems, size_t size)函数原型 void *calloc(size_t nitems, size_t size)函数功能：分配所需的内存空间，并返回一个指向它的指针。malloc 和 calloc 之间的不同点是，malloc 不会设置内存为零，

//时间： 2019年11月19日

//作者： Kroner

//编译环境： VS 2019

//库函数 stdlib.h

//函数原型 void *calloc(size_t nitems, size_t size)

//函数功能：释放之前调用 calloc、malloc 或 realloc 所分配的内存空间。

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>

#include <stdlib.h>

int main()

{

int i, n;

int* a;

printf("要输入的元素个数：");

scanf("%d", &n);

a = (int*)calloc(n, sizeof(int));

printf("输入 %d 个数字：\n", n);

for (i = 0; i < n; i++)

{

scanf("%d", &a[i]);

}

printf("输入的数字为：");

for (i = 0; i < n; i++) {

printf("%d ", a[i]);

}

free(a); // 释放内存

return 0;

}

测试结果：

void free(void *ptr)函数原型 void free(void *ptr)函数功能：分配所需的内存空间，该函数不返回任何值。

//时间：2019年11月19日

//作者：Kroner

//编译环境：VS 2019

//库函数 stdlib.h

//函数原型 void free(void *ptr)

//函数功能：分配所需的内存空间，并返回一个指向它的指针。

// malloc 和 calloc 之间的不同点是，malloc 不会设置内存为零，而 calloc 会设置分配的内存为零。

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

int main()

{

char* str;

/* 最初的内存分配 */

str = (char*)malloc(15);

strcpy(str, "runoob");

printf("String = %s, Address = %p\n", str, str);

/* 重新分配内存 */

str = (char*)realloc(str, 25);

strcat(str, ".com");

printf("String = %s, Address = %p\n", str, str);

/* 释放已分配的内存 */

free(str);

return 0;

}

测试结果：

void *malloc(size_t size)函数原型 void *malloc(size_t size)函数功能：分配所需的内存空间，并返回一个指向它的指针。该函数返回一个指针，指向已分配大小的内存。如果请求失败，则返回 NULL。

//时间：2019年11月15日

//作者：Kroner

//编译环境：VS 2019

//库函数 stdlib.h

//函数原型 void *malloc(size_t size)

//函数功能：分配所需的内存空间，并返回一个指向它的指针。

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

int main()

{

char* str;

/* 最初的内存分配 */

str = (char*)malloc(15);

strcpy(str, "Kroner");

printf("String = %s, Address = %u\n", str, str);

/* 重新分配内存 */

str = (char*)realloc(str, 25);

strcat(str, ".com");

printf("String = %s, Address = %u\n", str, str);

free(str); //释放内存

return 0;

}

测试结果

void *realloc(void *ptr, size_t size)函数原型 void *realloc(void *ptr, size_t size)函数功能：尝试重新调整之前调用 malloc 或 calloc 所分配的 ptr 所指向的内存块的大小。该函数返回一个指针，指向重新分配大小的内存。如果请求失败，则返回 NULL。

//时间：2019年11月15日

//作者：Kroner

//编译环境：VS 2019

//库函数 stdlib.h

//函数原型 void *realloc(void *ptr, size_t size)

//函数功能：尝试重新调整之前调用 malloc 或 calloc 所分配的 ptr 所指向的内存块的大小。

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

int main()

{

char* str;

/* 最初的内存分配 */

str = (char*)malloc(15);

strcpy(str, "Kroner");

printf("String = %s, Address = %p\n", str, str);

/* 重新分配内存 */

str = (char*)realloc(str, 25);

strcat(str, ".com");

printf("String = %s, Address = %p\n", str, str);

free(str);

return 0;

}

测试结果：

void abort(void)函数原型 void abort(void)函数功能：使一个异常程序终止。

//时间：2019年11月15日

//作者：Kroner

//编译环境：VS 2019

//库函数 stdlib.h

//函数原型 void abort(void)

//函数功能：使一个异常程序终止。

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>

#include <stdlib.h>

int main()

{

FILE* fp;

printf("准备打开 nofile.txt\n");

fp = fopen("nofile.txt", "r");

if (fp == NULL)

{

printf("准备终止程序\n");

abort();

}

printf("准备关闭 nofile.txt\n");

fclose(fp);

return(0);

}

测试结果：由于我们没有创建nofile.txt，所以是无法使用fopen()打开文件的，所以就会有弹出这样的异常界面

int atexit(void (func)(void))函数原型 int atexit(void (func)(void))函数功能：当程序正常终止时，调用指定的函数 func。

//时间：2019年11月15日

//作者：Kroner

//编译环境： VS 2019

//库函数 stdlib.h

//函数原型 int atexit(void (*func)(void))

//函数功能：当程序正常终止时，调用指定的函数 func。

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>

#include <stdlib.h>

void functionA()

{

printf("这是函数A\n");

}

int main()

{

/* 注册终止函数 */

atexit(functionA);

printf("启动主程序...\n");

printf("退出主程序...\n");

return 0;

}

测试结果：

void exit(int status)函数原型 void exit(int status)函数功能：使程序正常终止。

//时间：2019年11月15日

//作者：Kroner

//编译环境：VS 2019

//库函数 stdlib.h

//函数原型 void exit(int status)

//函数功能：使程序正常终止。

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>

#include <stdlib.h>

int main()

{

printf("程序的开头....\n");

printf("退出程序....\n");

exit(0);

printf("程序的结尾....\n");

return 0;

}

测试结果：

char *getenv(const char *name)函数原型 char *getenv(const char *name)函数功能：搜索 name 所指向的环境字符串，并返回相关的值给字符串。

//时间：2019年11月15日

//作者：Kroner

//编译环境：VS 2019

//库函数 stdlib.h

//函数原型 char *getenv(const char *name)

//函数功能：搜索 name 所指向的环境字符串，并返回相关的值给字符串。

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>

#include <stdlib.h>

int main()

{

printf("PATH : %s\n", getenv("PATH"));

printf("HOME : %s\n", getenv("HOME"));

printf("ROOT : %s\n", getenv("ROOT"));

return 0;

}

测试结果:

int system(const char *string)函数原型 int system(const char *string)/函数功能：由 string 指定的命令传给要被命令处理器执行的主机环境。

//时间：2019年11月15日

//作者：Kroner

//编译环境： VS 2019

//库函数 stdlib.h

//函数原型 int system(const char *string)

//函数功能：由 string 指定的命令传给要被命令处理器执行的主机环境。

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>

#include <string.h>

#include<stdlib.h>

int main()

{

char command[50];

strcpy(command, "dir");

system(command);

return 0;

}

测试结果：在windows 系统中显示的结果，相当于win+r运行cmd后再输入栏中输入dir的结果

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

函数原型 void *bsearch(const void *key, const void base, size_t nitems, size_t size, int (compar)(const void , const void *))key – 指向要查找的元素的指针，类型转换为 void* 。base – 指向进行查找的数组的第一个对象的指针，类型转换为 void 。nitems – base 所指向的数组中元素的个数。size – 数组中每个元素的大小，以字节为单位。compar – 用来比较两个元素的函数。函数功能：执行二分查找。

//时间：2019年11月15日

//作者：Kroner

//编译环境： VS 2019

//库函数 stdlib.h

//函数原型 void *bsearch(const void *key, const void *base, size_t nitems, size_t size, int (*compar)(const void *, const void *))

// key -- 指向要查找的元素的指针，类型转换为 void* 。

// base -- 指向进行查找的数组的第一个对象的指针，类型转换为 void* 。

// nitems -- base 所指向的数组中元素的个数。

// size -- 数组中每个元素的大小，以字节为单位。

// compar -- 用来比较两个元素的函数。

//函数功能：执行二分查找。

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>

#include <stdlib.h>

int cmpfunc(const void* a, const void* b)

{

return (*(int*)a - *(int*)b);

}

int values[] = { 5, 20, 29, 32, 63 };

int main()

{

int* item;

int key = 20;

/* 使用 bsearch() 在数组中查找值 32 */

item = (int*)bsearch(&key, values, 5, sizeof(int), cmpfunc);

if (item != NULL)

{

printf("Found item = %d\n", *item);

}

else

{

printf("Item = %d could not be found\n", *item);

}

return(0);

}

测试结果：这个相当于C语言封装的一个二分算法。后缀讲解算法题目的时候在讲解。

void qsort(void base, size_t nitems, size_t size, int (compar)(const void , const void))函数原型 void qsort(void base, size_t nitems, size_t size, int (compar)(const void , const void))base – 指向要排序的数组的第一个元素的指针。nitems – 由 base 指向的数组中元素的个数。size – 数组中每个元素的大小，以字节为单位。compar – 用来比较两个元素的函数。函数功能：数组排序

//时间：2019年11月15日

//作者：Kroner

//编译环境： VS 2019

//库函数 stdlib.h

//函数原型 void qsort(void *base, size_t nitems, size_t size, int (*compar)(const void *, const void*))

// base -- 指向要排序的数组的第一个元素的指针。

// nitems -- 由 base 指向的数组中元素的个数。

//size -- 数组中每个元素的大小，以字节为单位。

//compar -- 用来比较两个元素的函数。

//函数功能：数组排序

#define _CRT_SECURE_NO_WARNINGS

#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(values, sizeof(values)/sizeof(int), sizeof(int), cmpfunc);

printf("\n排序之后的列表：\n");

for (n = 0; n < 5; n++) {

printf("%d ", values[n]);

}

return 0;

}

测试结果：若是要从大到小排列只需要cmpfunc的返回值前加个一个符号就可以。

int abs(int x)函数原型 int abs(int x)函数功能：返回 x 的绝对值。

//时间：2019年11月15日

//作者：Kroner

//编译环境： VS 2019

//库函数 stdlib.h

//函数原型 int abs(int x)

//函数功能：返回 x 的绝对值。

#define _CRT_SECURE_NO_WARNINGS

#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;

}

测试结果：

div_t div(int numer, int denom)函数原型 div_t div(int numer, int denom)函数功能：分子除以分母。

//时间：2019年11月15日

//作者：Kroner

//编译环境： VS 2019

//库函数 stdlib.h

//函数原型： div_t div(int numer, int denom)

//函数功能：分子除以分母。

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>

#include <stdlib.h>

int main()

{

div_t output;

output = div(27, 4);

printf("(27/ 4) 的商 = %d\n", output.quot);

printf("(27/4) 的余数 = %d\n", output.rem);

output = div(27, 3);

printf("(27/ 3) 的商 = %d\n", output.quot);

printf("(27/3) 的余数 = %d\n", output.rem);

return 0;

}

测试结果：

int rand(void)
void srand(unsigned int seed)函数原型： int rand(void)函数原型： void srand(unsigned int seed)函数功能：返回一个范围在 0 到 RAND_MAX 之间的伪随机数。函数功能：该函数播种由函数 rand 使用的随机数发生器。

//时间：2019年11月15日

//作者：Kroner

//编译环境： VS 2019

//库函数 stdlib.h

//函数原型： int rand(void)

//函数原型 void srand(unsigned int seed)

//函数功能：返回一个范围在 0 到 RAND_MAX 之间的伪随机数。

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

int main()

{

int i, n;

time_t t;

n = 5;

/* 初始化随机数发生器以CPU的时间作为随机种子所以是伪随机数*/

srand((unsigned)time(&t));

/* 输出 0 到 49 之间的 5 个随机数 */

for (i = 0; i < n; i++) {

printf("%d\n", rand() % 50);

}

return 0;

}

测试结果： d

断言库

title	date	tags	categories	description
C语言断言库assert.h	2020-04-02 03:42:57 -0700	断言库	C语言	assert.h是一个用于辅助调试程序的小型库

assert宏

assert()宏接收一个整型表达式作为参数，如果表达式为假，就在标准错误stderr中写入一条错误信息，如测试名，文件名，行号等，并调用abort()终止程序

示例

#include <stdio.h>

#include <assert.h>

int Div(int a, int b)

{

assert(b != 0);

return a / b;

}

int main()

{

printf("%d\n", Div(5, 0));

}

假设程序名为test.c，编译出的可执行文件为test,运行程序

test: test.c:5: Div: Assertion `b != 0' failed.

执行test文件，其源文件是test.c，第5行，b!=0的测试未通过

禁用assert 如果认为已经排除了bug，可以关闭assert()，断言库提供了无须更改代码就可开闭assert的机制通过在导入<assert.h>之前加上如下的宏定义，可以关闭assert断言

//此宏定义必须在导入assert.h之前

#define NDEBUG

#include <assert.h>

_Static_assert(C11)

assert是在运行时检查，C11新增_Static_assert声明，可以在编译时检查assert()表达式，assert会导致程序的终止，_Static_assert会导致编译的失败 _Static_assert接收两个参数，第一个参数是整型常量表达式，第二个参数是一个字符串，如果第一个表达式求值为假(0或_False)，编译器会显示字符串，且不通过编译

示例

#include <assert.h>

#include <limits.h>

#include <stdio.h>

_Static_assert(CHAR_BIT==16, "char不是16位");

intmain()

{

printf("OK\n");

}

假设该文件名为test.c，使用gcc编译它

$gcc-otesttest.c

test.c:4:1: 错误：静态断言错误："char is not 16bits"

4|_Static_assert(CHAR_BIT==16, "char is not 16bits");

|^~~~~~~~~~~~~~

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

C语言——标准函数库

数学库

1、三角函数 Trigonometric functions

1.1、 cos() 函数

1.2 sin() 正弦函数

1.3、 tan() 正切函数

1.4、 acos() 反余弦函数

1.5、asin() 反正弦函数

1.6、atan() 反正切函数

1.7、atan2() 带两个参数的反正切函数

2、双曲函数 Hyperbolic functions

2.1、双曲余弦函数

2.2、双曲正弦函数

2.3、双曲正切函数

3、指数函数与对数函数 Exponential and logarithmic functions

3.1、exp () 指数函数，以 e 为底数

3.2、frexp(param，n) 二进制浮点数表示方法 x=param*2^n

3.3、log(x) x的自然对数 (Natural logarithm of x)

3.4、log10() 常用对数，以10为底 ( Common logarithm of x )

3.5、modf() 返回x的小数部分，其符号与x相同 ，但是参数中可以添加整数部分的变量( The fractional part of x, with the same sign)

3.6、exp2() 返回2的x次方，2 raised to the power of x.

3.7、log2() x的二进制对数( The binary logarithm of x)

4、幂函数 Power functions

4.1、pow(base, power) 幂函数 The result of raising base to the power exponent

4.2、sqrt(x) 计算x的平方根

4.3、cbrt(x) 计算x的立方根

4.4、hypot(x,y) 计算直角三角形的斜边 ( The square root of (x^2+y^2) )

5、误差与伽马函数 Error and gamma functions

5.1、误差函数erf(x) 网络异常，图片无法展示 |

5.2、余差函数erfc(x) erfc(x) = 1-erf(x) 误差函数的补函数 网络异常，图片无法展示 |

5.3、tgamma(x) 伽马函数 ( the gamma function ) 网络异常，图片无法展示 |

5.4、lgamma(x) log伽马函数 ( log-gamma function ) 网络异常，图片无法展示 |

6、四舍五入与余数函数Rounding and remainder functions

6.1、ceil(x) x上取整函数

6.2、floor(x) x的下取整函数

6.3、fmod(y, x) y/x的余数

6.4、round(x) x的四舍五入值 网络异常，图片无法展示 |

7、绝对值、最小、最大 Absolute、Minimum, maximum

7.1、fabs(x) x的绝对值函数

7.2、abs(x) x的绝对值

7.3、fmax(x, y) 两个参数中的最大值 (The maximum numeric value of its arguments. Values among which the function selects a maximum )

7.4、fmin(x, y) 两个参数中的最小值

通用工具库

思维导图大纲

前言

断言库

assert宏

_Static_assert(C11)

热门文章

最新文章

相关课程

相关电子书

相关实验场景

3.2、frexp(param，n) 二进制浮点数表示方法 **x=param*2^n**

3.5、modf() 返回x的小数部分，其符号与x相同，但是参数中可以添加整数部分的变量( The fractional part of x, with the same sign)

5.1、误差函数erf(x)

网络异常，图片无法展示
|

5.2、余差函数erfc(x) erfc(x) = 1-erf(x) 误差函数的补函数

网络异常，图片无法展示
|

5.3、tgamma(x) 伽马函数 ( the gamma function )

网络异常，图片无法展示
|

5.4、lgamma(x) log伽马函数 ( log-gamma function )

网络异常，图片无法展示
|

6.4、round(x) x的四舍五入值

网络异常，图片无法展示
|