C语言函数大全--f开头的函数（下）

总览

函数声明 函数功能
double floor (double x); 获取小于或等于 x 的最大整数（double）。
float floorf (float x); 获取小于或等于 x 的最大整数（float）。
long double floorl (long double x) 获取小于或等于 x 的最大整数（long double）。
int _flushall(void); 清除所有缓冲区，返回打开的流（输入和输出）的数量
double fma (double x, double y, double z); 计算x*y+z的值，并将结果四舍五入（double）。
float fmaf (float x, float y, float z ); 计算x*y+z的值，并将结果四舍五入（float ）。
long double fmal (long double x, long double y, long double z); 计算x*y+z的值，并将结果四舍五入（double）。
double fmax (double x, double y); 获取 x 和 y 中的最大值（double）
float fmaxf (float x, float y); 获取 x 和 y 中的最大值（float）
long double fmaxl (long double x, long double y); 获取 x 和 y 中的最大值（long double）
double fmin (double x, double y); 获取 x 和 y 中的最小值（double）
float fminf (float x, float y); 获取 x 和 y 中的最小值（float）
long double fminl (long double x, long double y); 获取 x 和 y 中的最小值（long double）
double fmod (double x, double y); 计算 x 除以 y 的余数（double）。
float fmodf (float x, float y); 计算 x 除以 y 的余数（float）。
long double fmodl (long double x, long double y); 计算 x 除以 y 的余数（long double）。
FILE *fopen(const char *filename, const char *mode); 使用给定的模式mode打开filename所指向的文件。
int fprintf(FILE *stream, char *format[, argument,...]); 格式化输出到一个流文件中
int fputc(int ch, FILE *stream); 将字符【ch为字符的ascii码】写到文件指针stream所指向的文件的当前写指针的位置
int fputchar(char ch); 送一个字符到标准输出流(stdout)中，出错则返回EOF
int fputs(const char *str, FILE *stream); 把字符串写入到指定的流( stream) 中，但不包括空字符。
int fread(void *buffer, int size, int count, FILE *stream); 从给定输入流stream读取最多count个对象到数组buffer中
void free(void *ptr); 释放ptr指向的存储空间
FILE * freopen(const char *filename, const char *mode, FILE *stream); 以指定模式重新指定到另一个文件
double frexp (double x, int * exp); 将x 分解为有效位 和 2 的整数指数。（double）。
float frexpf (float x, int * exp); 将x 分解为有效位 和 2 的整数指数。（float）。
long double frexpl (long double x, int * exp); 将x 分解为有效位 和 2 的整数指数。（long double）。
int fscanf(FILE *stream, char *format[,argument...]); 从一个流中执行格式化输入
int fseek(FILE *stream, long offset, int fromwhere); 重定位流上的文件指针位置
int fsetpos(FILE *stream, const fpos_t *pos); 将文件指针定位在pos指定的位置上。如果成功返回0，否则返回非0。
int fstat(int handle,struct stat *buf); 由文件描述符获取文件状态
long ftell(FILE *stream); 获取文件指针当前位置相对于文件首的偏移字节数
int fwrite(const void *ptr, int size, int nitems, FILE *stream); 把ptr所指向的数组中的数据写入到给定流stream中

1. floor，floorf，floorl

1.1 函数说明

函数声明 函数功能
double floor (double x); 获取小于或等于 x 的最大整数（double）。
float floorf (float x); 获取小于或等于 x 的最大整数（float）。
long double floorl (long double x) 获取小于或等于 x 的最大整数（long double）。

1.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include<stdio.h>
#include<math.h>

int main()
{
    double x = 10.24;
    printf("floor(%.2lf) = %.2lf\n", x, floor(x));

    float xf = 5.63;
    printf("floorf(%.2f) = %.2f\n", xf, floorf(xf));

    long double xL = 2.89;
    printf("floorl(%.2Lf) = %.2Lf\n", xL, floorl(xL));
    return 0;
}

1.3 运行结果

2. _flushall

2.1 函数说明

函数声明 函数功能
int _flushall(void); 清除所有缓冲区，返回打开的流（输入和输出）的数量

2.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>

int main()
{
    FILE *stream = fopen("STU.FIL", "w");
    // 清除所有缓冲区
    // 返回打开的流（输入和输出）的数量
    printf("%d streams were flushed.\n", _flushall());
    fclose(stream);
    return 0;
}

2.3 运行结果

3. fma，fmaf，fmal

3.1 函数说明

函数声明 函数功能
double fma (double x, double y, double z); 计算x*y+z的值，并将结果四舍五入（double）。
float fmaf (float x, float y, float z ); 计算x*y+z的值，并将结果四舍五入（float ）。
long double fmal (long double x, long double y, long double z); 计算x*y+z的值，并将结果四舍五入（double）。

3.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
#include <math.h>

int main() {
    
    double x = 2.0, y = 3.0, z = 4.0;
    float xf = 2.0, yf = 3.0, zf = 4.0;
    long double xL = 2.0, yL = 3.0, zL = 4.0;

    printf("fma(%lf, %lf, %lf) = %lf\n", x, y, z, fma(x, y, z));
    printf("fmaf(%f, %f, %f) = %f\n", xf, yf, zf, fmaf(xf, yf, zf));
    printf("fmal(%Lf, %Lf, %Lf) = %Lf\n", xL, yL, zL, fmal(xL, yL, zL));
    
    return 0;
}

3.3 运行结果

4. fmax，fmaxf，fmaxl

4.1 函数说明

函数声明 函数功能
double fmax (double x, double y); 获取 x 和 y 中的最大值（double）
float fmaxf (float x, float y); 获取 x 和 y 中的最大值（float）
long double fmaxl (long double x, long double y); 获取 x 和 y 中的最大值（long double）

4.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include<stdio.h>
#include<math.h>

int main()
{
    double x = 10.24, y = 5.63;
    printf("fmax(%.2lf, %.2lf) = %.2lf\n", x, y, fmax(x, y));

    float xf = 5.63, yf = 2.89;
    printf("fmaxf(%.2f, %.2f) = %.2f\n", xf, yf, fmaxf(xf, yf));

    long double xL = 2.89, yL = 4.56;
    printf("fmaxl(%.2Lf, %.2Lf) = %.2Lf\n", xL, yL, fmaxl(xL, yL));
    return 0;
}

4.3 运行结果

5. fmin，fminf，fminl

5.1 函数说明

函数声明 函数功能
double fmin (double x, double y); 获取 x 和 y 中的最小值（double）
float fminf (float x, float y); 获取 x 和 y 中的最小值（float）
long double fminl (long double x, long double y); 获取 x 和 y 中的最小值（long double）

5.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include<stdio.h>
#include<math.h>

int main()
{
    double x = 10.24, y = 5.63;
    printf("fmin(%.2lf, %.2lf) = %.2lf\n", x, y, fmin(x, y));

    float xf = 5.63, yf = 2.89;
    printf("fminf(%.2f, %.2f) = %.2f\n", xf, yf, fminf(xf, yf));

    long double xL = 2.89, yL = 4.56;
    printf("fminl(%.2Lf, %.2Lf) = %.2Lf\n", xL, yL, fminl(xL, yL));
    return 0;
}

5.3 运行结果

6. fmod，fmodf，fmodl

6.1 函数说明

函数声明 函数功能
double fmod (double x, double y); 计算 x 除以 y 的余数（double）。
float fmodf (float x, float y); 计算 x 除以 y 的余数（float）。
long double fmodl (long double x, long double y); 计算 x 除以 y 的余数（long double）。

6.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include<stdio.h>
#include<math.h>

int main()
{
    double x = 10.24, y = 5.63;
    printf("fmod(%.2lf, %.2lf) = %.20lf\n", x, y, fmod(x, y));

    float xf = 5.63, yf = 2.89;
    printf("fmodf(%.2f, %.2f) = %.20f\n", xf, yf, fmodf(xf, yf));

    long double xL = 2.89, yL = 4.56;
    printf("fmodl(%.2Lf, %.2Lf) = %.20Lf\n", xL, yL, fmodl(xL, yL));
    return 0;
}

6.3 运行结果

7. fopen

7.1 函数说明

函数声明 函数功能
FILE *fopen(const char *filename, const char *mode); 使用给定的模式mode打开filename所指向的文件。

参数：

  • filename： 要打开的文件全路径名
  • mode： 文件访问模式

返回值：
如果文件顺利打开后，指向该流的文件指针就会被返回；否则文件打开失败则返回 NULL，并把错误代码存在 error 中。

文件访问模式

文件访问模式 说明
"r" 以只读模式打开文件，该文件必须存在。
"w" 以只写模式打开文件。若文件不存在则创建该文件。若文件存在则其现有内容将被清除。
"a" 以追加模式打开只写文件。若文件不存在则创建该文件；如果文件存在，则新写入的数据会被加到文件尾后。
"r+" 以读写模式打开文件，该文件必须存在。
"w+" 以读写模式打开文件。若文件不存在则创建该文件。若文件存在则其内容将被清除。
"a+" 以追加模式打开可读写文件。若文件不存在则创建该文件；如果文件存在，则新写入的数据会被加到文件尾后。
"rb" 以只读模式打开一个二进制文件。
"wb" 以只写模式打开或新建一个二进制文件。
"ab" 以追加模式打开一个二进制文件，并在文件末尾写入数据。
"rb+" 以读写模式打开一个二进制文件，该文件必须存在。
"wb+" 以读写模式打开或创建一个二进制文件。
"ab+" 以追加模式打开一个二进制文件，以便在文件末尾写入数据。该文件也是可读的。
"rt" 以只读模式打开一个文本文件。
"wt" 以只读模式打开或创建文本文件。
"at" 以追加模式打开一个文本文件，并在文件末尾写入数据。
"rt+" 以读写模式打开一个文本文件。
"wt+" 以读写模式打开或创建文本文件。
"at+" 以追加模式打开文本文件，以便在文件末尾写入数据。该文件也是可读的。

7.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <string.h>
#include <stdio.h>

int main(void)
{
    FILE *fp;
    char buf[30] = "Hello, Huazie 123456789";
    fp = fopen("STU.FIL", "w");
    printf("temp.txt is created and opened\n");
    fwrite(&buf, strlen(buf), 1, fp);
    printf("temp.txt is writed\n");
    fclose(fp);
    printf("temp.txt is closed");
    return 0;
}

7.3 运行结果

8. fprintf

8.1 函数说明

函数声明 函数功能
int fprintf(FILE *stream, char *format[, argument,...]); 格式化输出到一个流文件中

8.2 演示示例

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>

int main()
{
    FILE *stream;
    stream = fopen("temp.txt", "w");
    fprintf(stream, "%s:%d\n", "Hello Huazie", 456);
    fclose(stream);
    return 0;
}

8.3 运行结果

9. fputc

9.1 函数说明

函数声明 函数功能
int fputc(int ch, FILE *stream); 将字符【ch为字符的ascii码】写到文件指针stream所指向的文件的当前写指针的位置

注意： 在正常调用情况下，函数返回写入文件的字符的 ASCII 码值，出错时，返回 EOF（-1）。当正确写入一个字符或一个字节的数据后，文件内部写指针会自动后移一个字节的位置。EOF是在头文件 stdio.h中定义的宏。

9.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>

int main(void)
{
   char msg[] = "Hello Huazie";
   int i = 0;

   while (msg[i])
   {
      fputc(msg[i], stdout);
      i++;
   }
   return 0;
}

9.3 运行结果

10. fputchar

10.1 函数说明

函数声明 函数功能
int fputchar(char ch); 送一个字符到标准输出流(stdout)中，出错则返回EOF

10.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>

int main(void)
{
    char msg[] = "This is a test";
    int i = 0;

    while (msg[i])
    {
      fputchar(msg[i]);
      i++;
    }
    return 0;
}

10.3 运行结果

11. fputs

11.1 函数说明

函数声明 函数功能
int fputs(const char *str, FILE *stream); 把字符串写入到指定的流( stream) 中，但不包括空字符。

注意： fputs 函数如果成功则返回 0，如果发生错误则返回 EOF(-1)

11.2 演示示例

1
2
3
4
5
6
7
8
#include <stdio.h>

int main()
{
    int result = fputs("Hello Huazie\n1234", stdout);
    printf("\nresult = %d", result);
    return 0;
}

11.3 运行结果

12. fread

12.1 函数说明

函数声明 函数功能
int fread(void *buffer, int size, int count, FILE *stream); 从给定输入流stream读取最多count个对象到数组buffer中

参数：

  • buffer ： 指向要读取的数组中首个对象的指针
  • size : 每个对象的大小（单位是字节）
  • count : 要读取的对象个数
  • stream : 指定输入流

返回值：
返回成功读取的对象个数，若出现错误或到达文件末尾，则可能小于count。
若 size 或 count 为零，则 fread 返回零且不进行其他动作。
fread 不区分文件尾和错误，因此调用者必须用 feof 和 ferror 才能判断发生了什么。

注意： 如果读取成功，流的文件位置指示器前进读取的字节数；否则出现错误，则流的文件位置指示器的位置不确定。同样若没有完整地读入最后一个元素，则其值也不确定。

12.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <string.h>
#include <stdio.h>

int main(void)
{
    FILE *stream;
    char msg[20] = "Hello, Huazie";
    char buf[20];

    // 以读写模式打开文件。若文件不存在则创建该文件。若文件存在则其内容将被清除。
    if ((stream = fopen("temp.txt", "w+")) == NULL)
    {
        fprintf(stderr, "Cannot open output file.\n");
        return 1;
    }
    // 向文件流中写入数据
    fwrite(msg, strlen(msg)+1, 1, stream);
    // 重定位流上的文件指针到文件开头
    fseek(stream, SEEK_SET, 0);
    // 从文件流中读取数据
    fread(buf, strlen(msg)+1, 1, stream);
    printf("%s\n", buf);

    fclose(stream);
    return 0;
}

12.3 运行结果

13. free

13.1 函数说明

函数声明 函数功能
void free(void *ptr); 释放ptr指向的存储空间

注意： 被释放的空间通常被送入可用存储区池，以后可以在调用 malloc、realloc 以及 calloc 函数来再分配。

13.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>
#include <string.h>
#include <malloc.h>
int main()
{
    char *str;
    str = (char *) malloc(7); 
    strcpy(str, "huazie");
    printf("string = %-10s, Address = %u, len = %d\n", str, str, strlen(str));
    str = (char *) realloc(str,25); //重新分配内存
    strcat(str, ".com");
    printf("string = %-10s, Address = %u, len = %d\n", str, str, strlen(str));
    free(str);// 释放已分配的内存空间
    //内存空间释放后，该空间上的值未知
    printf("string = %-10s, Address = %u, len = %d\n", str, str, strlen(str));
    return 0;
}

13.3 运行结果

14. freopen

14.1 函数说明

函数声明 函数功能
FILE * freopen(const char *filename, const char *mode, FILE *stream); 以指定模式重新指定到另一个文件

参数：

  • filename： 需要重定向到的文件名或文件路径。
  • mode： 代表文件访问权限的字符串。 参见 27 fopen
  • stream： 需要被重定向的文件流。

14.2 演示示例

1
2
3
4
5
6
7
8
9
#include<stdio.h>
int main()
{
    if(freopen("temp.txt", "w", stdout) == NULL)
        fprintf(stderr,"error redirecting stdout\n");
    printf("Hello, %s", "Huazie");
    fclose(stdout);
    return 0;
}

14.3 运行结果

15. frexp，frexpf，frexpl

15.1 函数说明

函数声明 函数功能
double frexp (double x, int * exp); 将x 分解为有效位 和 2 的整数指数。（double）。
float frexpf (float x, int * exp); 将x 分解为有效位 和 2 的整数指数。（float）。
long double frexpl (long double x, int * exp); 将x 分解为有效位 和 2 的整数指数。（long double）。

注意： 有效位的绝对值范围为 0.5（包括） 到 1（不包括）。x = 有效位 * $2^{exp}$

15.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include<stdio.h>
#include<math.h>

int main()
{
    int exp;
    double x = 10.24;
    printf("frexp(%.2lf, exp = %d) = %.20lf\n", x, exp, frexp(x, &exp));

    float xf = 5.63;
    printf("frexpf(%.2f, exp = %d) = %.20f\n", xf, exp, frexpf(xf, &exp));

    long double xL = 2.89;
    printf("frexpl(%.2Lf, exp = %d) = %.20Lf\n", xL, exp, frexpl(xL, &exp));
    return 0;
}

15.3 运行结果

16. fscanf

16.1 函数说明

函数声明 函数功能
int fscanf(FILE *stream, char *format[,argument...]); 从一个流中执行格式化输入

注意： fscanf 遇到空格和换行时结束。它与 fgets 有区别，fgets 遇到空格不结束。

16.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdlib.h>
#include <stdio.h>

int main(void)
{
    int i;
    printf("Input an integer: ");
    if (fscanf(stdin, "%d", &i))
      printf("The integer is: %d\n", i);
    else
    {
      fprintf(stderr, "Error reading an integer from stdin.\n");
      exit(1);
    }
    return 0;
}

16.3 运行结果

17. fseek

17.1 函数说明

函数声明 函数功能
int fseek(FILE *stream, long offset, int fromwhere); 重定位流上的文件指针位置

注意： 如果执行成功，stream 将指向以 fromwhere【偏移起始位置：文件头 **0(SEEK_SET)**，当前位置 1(SEEK_CUR)，文件尾2(SEEK_END) 】为基准，偏移 offset（指针偏移量）个字节的位置。如果执行失败(比如 offset 超过文件自身大小)，则不改变 stream 指向的位置。

17.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <stdio.h>

long filesize(FILE *stream);

int main(void)
{
    FILE *stream = fopen("temp.txt", "w+");
    fprintf(stream, "This is a test");
    printf("The size of temp.txt is %ld bytes\n", filesize(stream));
    fclose(stream);
    return 0;
}

long filesize(FILE *stream)
{
    long curpos, length;
    // 文件指针当前位置相对于文件首的偏移字节数
    curpos = ftell(stream);
    // 重定向文件指针到文件尾，偏移量 0
    fseek(stream, 0L, SEEK_END);
    length = ftell(stream);
    return length;
}

17.3 运行结果


18. fsetpos

18.1 函数说明

函数声明 函数功能
int fsetpos(FILE *stream, const fpos_t *pos); 将文件指针定位在pos指定的位置上。如果成功返回0，否则返回非0。

18.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <stdlib.h>
#include <stdio.h>

void showpos(FILE *stream);

int main(void)
{
    FILE *stream;
    fpos_t filepos;

    stream = fopen("STU.FIL", "w+");
    // 获取当前文件指针的位置
    fgetpos(stream, &filepos);
    fprintf(stream, "This is a test");
    // 展示当前文件指针的位置
    showpos(stream);

    /* set a new file position, display it */
    if (fsetpos(stream, &filepos) == 0)
        showpos(stream);
    else
    {
        fprintf(stderr, "Error setting file pointer.\n");
        exit(1);
    }

    fclose(stream);
    return 0;
}

void showpos(FILE *stream)
{
    fpos_t pos;
    // 展示当前文件指针的位置
    fgetpos(stream, &pos);
    printf("File position: %ld\n", pos);
}

18.3 运行结果

19. fstat

19.1 函数说明

函数声明 函数功能
int fstat(int handle,struct stat *buf); 由文件描述符获取文件状态

19.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include <sys\stat.h>
#include <stdio.h>
#include <time.h>

int main()
{
    struct stat statbuf;
    FILE *stream;

    if ((stream = fopen("STU.FIL", "w+")) == NULL)
    {
        fprintf(stderr, "Cannot open output file.\n");
        exit(1);
    }
    fprintf(stream, "This is a test");
    fflush(stream);

    // get information about the file
    fstat(fileno(stream), &statbuf);
    fclose(stream);

    if (statbuf.st_mode & S_IFCHR)
        printf("Handle refers to a device.\n");
    if (statbuf.st_mode & S_IFREG)
        printf("Handle refers to an ordinary file.\n");
    if (statbuf.st_mode & S_IREAD)
        printf("User has read permission on file.\n");
    if (statbuf.st_mode & S_IWRITE)
        printf("User has write permission on file.\n");
    // 不知道为啥，我这里文件的驱动号是空
    printf("Drive letter of file: %c\n", statbuf.st_dev);
    printf("Size of file in bytes: %ld\n", statbuf.st_size);
    printf("Time file last opened: %s\n", ctime(&statbuf.st_ctime));
    return 0;
}

19.3 运行结果

20. ftell

20.1 函数说明

函数声明 函数功能
long ftell(FILE *stream); 获取文件指针当前位置相对于文件首的偏移字节数

20.2 演示示例

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>

int main(void)
{
    FILE *stream = fopen("temp.txt", "w+");
    fprintf(stream, "This is a test");
    printf("The file pointer is at byte %ld\n", ftell(stream));
    fclose(stream);
    return 0;
}

20.3 运行结果

21. fwrite

21.1 函数说明

函数声明 函数功能
int fwrite(const void *ptr, int size, int nitems, FILE *stream); 把ptr所指向的数组中的数据写入到给定流stream中
参数：
  • ptr： 指向要被写入的元素数组的指针。
  • size： 要被写入的每个元素的大小，以字节为单位。
  • nitems： 元素的个数，每个元素的大小为 size 字节。
  • stream： 指向 FILE 对象的指针，该 FILE 对象指定了一个输出流。

注意： 如果写入成功，fwrite 返回一个 size_t 对象，表示元素的总数，该对象是一个整型数据类型。如果该数字与 nitems 参数不同，则会显示一个错误。

21.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include <stdio.h>

struct mystruct
{
    int i;
    char ch;
};

int main(void)
{
    FILE *stream;
    struct mystruct s;
    // 以只写模式打开或新建一个二进制文件。
    if ((stream = fopen("test.txt", "wb")) == NULL) 
    {
        fprintf(stderr, "Cannot open output file.\n");
        return 1;
    }
    s.i = 0;
    s.ch = 'A';
    fwrite(&s, sizeof(s), 1, stream); 
    fclose(stream); 

    // 以只读模式打开或新建一个二进制文件。
    if ((stream = fopen("test.txt", "rb")) == NULL) 
    {
        fprintf(stderr, "Cannot open output file.\n");
        return 1;
    }
    struct mystruct s1;
    fread(&s1, sizeof(s1), 1, stream);
    printf("%d %c", s1.i, s1.ch);
    fclose(stream);

    return 0;
}

21.3 运行结果

参考

  1. [API Reference Document]
  2. [IO-标准C库]
  3. [fread]
  4. [freopen]
  5. [fseek]
  6. [fwrite]

C语言函数大全--f开头的函数（上）

总览

函数声明 函数功能
double fabs(double x); 返回 x 的绝对值（double）
float fabsf(float x); 返回 x 的绝对值（float）
long double fabsl(long double x); 返回 x 的绝对值（long double）
int fclose(FILE *stream); 关闭一个文件流
int fcloseall(void); 关闭除标准流（stdin、stdout、stderr、stdprn、stdaux）之外的所有打开的流，刷新所有的流缓冲区，并返回关闭的流数。
char * fcvt(double value, int ndigit, int *decpt, int *sign); 把一个双精度浮点数转换为字符串
double fdim (double x, double y); 计算 x 和 y 之间的正差值 （double）
float fdimf (float x, float y); 计算 x 和 y 之间的正差值 （float）
long double fdiml (long double x, long double y); 计算 x 和 y 之间的正差值 （long double）
FILE * fdopen(int handle, char *type); 将文件描述符和文件流相关联
int feof(FILE *stream); 检测流上的文件结束符。如果文件结束，则返回非0值，否则返回0
int ferror(FILE *stream); 检测流上的错误【返回0，表示未出错；返回非零值，表示出错。】
int fflush(FILE *stream); 清除读写缓冲区，并将缓冲区内的数据写回参数stream指向的文件中。
int fgetc(FILE *stream); 从流中读取字符
int fgetchar(void); 从流中读取字符
int fgetpos(FILE *stream); 依据当前文件的句柄，获取当前访问指针位置信息
char * fgets(char *str, int n, FILE *stream); 从指定的流中读取数据，每次读取一行
long filelength(int handle); 获取文件的长度
int fileno(FILE *stream); 获取参数stream指定的文件流所使用的文件描述符
void fillellipse(int x, int y, int xradius, int yradius); 画出并填充一椭圆
void fillpoly(int numpoints, int *polypoints); 画并填充一个多边形
int _findfirst(char *pathname, struct _finddata_t *_FindData); 搜索与指定的文件名称匹配的第一个文件，若成功则返回第一个文件的文件描述符，否则返回-1L。
int _findnext(int handle, struct _finddata_t *_FindData); 搜索与_findfirst函数提供的文件名称匹配的下一个实例，若成功则返回0，否则返回－1
int finitef (double x); 检查 x 是无穷大值还是NaN 值（double）。如果是无穷大值或NaN值，返回 0；否则返回 1。
int finitef (float x); 检查 x 是无穷大值还是NaN 值（float）。如果是无穷大值或NaN值，返回 0；否则返回 1。
void floodfill(int x, int y, int border); 填充一个有界区域

1. fabs，fabsf，fabsl

1.1 函数说明

函数声明 函数功能
double fabs(double x); 返回 x 的绝对值（double）
float fabsf(float x); 返回 x 的绝对值（float）
long double fabsl(long double x); 返回 x 的绝对值（long double）

1.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
#include <math.h>

int main(void)
{
    double result, x = -4.5;
    result = fabs(x); // 取绝对值

    float resultf, xf = -3.5;
    resultf = fabsf(xf);

    long double resultL, xL = -2.5;
    resultL = fabsl(xL);

    printf("The absolute value of %lf is %lf\n", x, result);

    printf("The absolute value of %f is %f\n", xf,  resultf);

    printf("The absolute value of %Lf is %Lf\n", xL, resultL);

    return 0;
}

1.3 运行结果

2. fclose

2.1 函数说明

函数声明 函数功能
int fclose(FILE *stream); 关闭一个文件流

2.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <string.h>
#include <stdio.h>

int main(void)
{
    FILE *fp;
    char buf[30] = "Hello, Huazie 123456789";
    fp = fopen("temp.txt", "w");
    printf("temp.txt is created and opened\n");
    fwrite(&buf, strlen(buf), 1, fp);
    printf("temp.txt is writed\n");
    fclose(fp);
    printf("temp.txt is closed");
    return 0;
}

2.3 运行结果


3. fcloseall

3.1 函数说明

函数声明 函数功能
int fcloseall(void); 关闭除标准流（stdin、stdout、stderr、stdprn、stdaux）之外的所有打开的流，刷新所有的流缓冲区，并返回关闭的流数。

3.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>

#define fcloseall() _fcloseall();

int main()
{
    int streams_closed;

    fopen("temp.one", "w");
    fopen("temp.two", "w");

    // 关闭打开流
    streams_closed = fcloseall();

    if (streams_closed == EOF)
        perror("Error");
    else
        printf("%d streams were closed.\n", streams_closed);

    return 0;
}

3.3 运行结果

4. fcvt

4.1 函数说明

函数声明 函数功能
char * fcvt(double value, int ndigit, int *decpt, int *sign); 把一个双精度浮点数转换为字符串
  • value： 要转换的双精度浮点数，输入参数
  • ndigit： 取小数的位数，输入参数
  • decpt： 表示小数点的位置,输出参数
  • sign： 表示value的符号，0为正数，1为负数，输出参数

4.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>

int main()
{
    char *string;
    double value;
    int decpt, sign;

    int ndigit = 10;
    value = 9.876;
    string = fcvt(value, ndigit, &decpt, &sign);
    printf("string = %-18s decpt = %d sign = %d value = %lf\n", string, decpt, sign, value);

    value = -123.45;
    ndigit= 15;
    string = fcvt(value, ndigit, &decpt, &sign);
    printf("string = %-18s decpt = %d sign = %d value = %lf\n", string, decpt, sign, value);

    value = 0.6789e5; /* 科学记数法 scientific notation */
    ndigit = 5;
    string = fcvt(value, ndigit, &decpt, &sign);
    printf("string = %-18s decpt = %d sign = %d value = %lf\n", string, decpt, sign, value);

    return 0;
}

4.3 运行结果

5. fdim，fdimf，fdiml

5.1 函数说明

函数声明 函数功能
double fdim (double x, double y); 计算 x 和 y 之间的正差值 （double）
float fdimf (float x, float y); 计算 x 和 y 之间的正差值 （float）
long double fdiml (long double x, long double y); 计算 x 和 y 之间的正差值 （long double）

5.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <stdio.h>  
#include <math.h>
  
int main() {  

  double x = 5.000011;
    double y = 3.000041;

    double result_d = fdim(x, y);

    float xf = 5.000011f;
    float yf = 3.000031f;
    float result_f = fdimf(xf, yf);

    long double xLD = 5.000011L;
    long double yLD = 3.000021L;
    long double result_ld = fdiml(xLD, yLD);

    printf("fdim(%.6lf, %.6lf) = %.6lf\n", x, y, result_d);
    printf("fdimf(%.6f, %.6f) = %.6f\n", xf, yf, result_f);
    printf("fdiml(%.6Lf, %Lf) = %.6Lf\n", xLD, yLD, result_ld);
  
    return 0;  
}

5.3 运行结果

6. fdopen

6.1 函数说明

函数声明 函数功能
FILE * fdopen(int handle, char *type); 将文件描述符和文件流相关联

6.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <sys\stat.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>

int main(void)
{
    int handle;
    FILE *stream;
    // 打开 temp.txt 文件
    handle = open("temp.txt", O_CREAT | O_RDWR, S_IREAD | S_IWRITE);
    // 将文件描述符和文件流关联
    stream = fdopen(handle, "w");

    if (stream == NULL)
        printf("fdopen failed\n");
    else
    {
        fprintf(stream, "%s:%d\n", "Hello world", 123);
        fclose(stream);
    }
    return 0;
}

6.3 运行结果

7. feof

7.1 函数说明

函数声明 函数功能
int feof(FILE *stream); 检测流上的文件结束符。如果文件结束，则返回非0值，否则返回0

7.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>

int main(void)
{
    FILE *stream;
    // 以读取模式，打开文件 temp.txt
    stream = fopen("temp.txt", "r");

    // 检查是否文件结束【0：未结束 非0：结束】
    while (!feof(stream))
        printf("%c", fgetc(stream));

    fclose(stream);
    return 0;
}

7.3 运行结果

8. ferror

8.1 函数说明

函数声明 函数功能
int ferror(FILE *stream); 检测流上的错误【返回0，表示未出错；返回非零值，表示出错。】

8.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>

int main(void)
{
    FILE *stream;
    // 以写模式打开文件STU.FIL
    stream = fopen("STU.FIL", "w");
    // 通过尝试读取来强制出现错误条件
    (void) getc(stream);
    // 检测流上的错误【返回0，表示未出错；返回非零值，表示出错。】
    if (ferror(stream))
    {
        printf("Error reading from STU.FIL\n");
        // 重置错误和EOF标志
        clearerr(stream);
    }
    fclose(stream);
    return 0;
}

8.3 运行结果

9. fflush

9.1 函数说明

函数声明 函数功能
int fflush(FILE *stream); 清除读写缓冲区，并将缓冲区内的数据写回参数stream指向的文件中。

9.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <string.h>
#include <stdio.h>
#include <conio.h>
#include <io.h>

void flush(FILE *stream);

int main(void)
{
    FILE *stream;
    char msg[] = "This is a test";

    stream = fopen("STU.FIL", "w");
    fwrite(msg, strlen(msg), 1, stream);

    printf("Press any key to flush STU.FIL:");
    getchar();

    // 将数据刷新到 STU.FIL 中而不关闭它
    flush(stream);

    printf("\nFile was flushed, Press any key to quit:");
    getchar();
    return 0;
}

void flush(FILE *stream)
{
    int duphandle;

    // flush the stream's internal buffer
    fflush(stream);

    // make a duplicate file handle
    duphandle = dup(fileno(stream));

    // close the duplicate handle to flush the DOS buffer
    close(duphandle);
}

9.3 运行结果

10. fgetc

10.1 函数说明

函数声明 函数功能
int fgetc(FILE *stream); 从流中读取字符

10.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <string.h>
#include <stdio.h>

int main(void)
{
    FILE *stream;
    char string[] = "This is a test";
    char ch;

    stream = fopen("STU.FIL", "w+");
    fwrite(string, strlen(string), 1, stream);
    fseek(stream, 0, SEEK_SET);
    
    do
    {
        ch = fgetc(stream);
        putchar(ch);
    } while (ch != EOF);

    fclose(stream);
    return 0;
}

10.3 运行结果

11. fgetchar

11.1 函数说明

函数声明 函数功能
int fgetchar(void); 从流中读取字符

11.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>

int main(void)
{
    char ch;
    printf("Enter a character followed by <Enter>: ");
    // read the character from stdin
    ch = fgetchar();
    printf("The character read is: '%c'\n", ch);
    return 0;
}

11.3 运行结果

12. fgetpos

12.1 函数说明

函数声明 函数功能
int fgetpos(FILE *stream); 依据当前文件的句柄，获取当前访问指针位置信息

12.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <string.h>
#include <stdio.h>

int main(void)
{
    FILE *stream;
    char string[] = "This is a test";
    fpos_t filepos;
    stream = fopen("STU.FIL", "w+");
    fwrite(string, strlen(string), 1, stream);
    // report the file pointer position
    fgetpos(stream, &filepos);
    printf("The file pointer is at byte %lld\n", filepos);
    fclose(stream);
    return 0;
}

12.3 运行结果

13. fgets

13.1 函数说明

函数声明 函数功能
char * fgets(char *str, int n, FILE *stream); 从指定的流中读取数据，每次读取一行

参数：

  • str : 这是指向一个字符数组的指针，该数组存储了要读取的字符串。
  • n： 这是要读取的最大字符数（包括最后的空字符）。通常是使用以 str 传递的数组长度。
  • stream： 这是指向 FILE 对象的指针，该 FILE 对象标识了要从中读取字符的流。

注意： 如果文件中的一行，不足 n-1 个字符，则读完该行就直接结束。如若该行（包括最后一个换行符）的字符数超过 n-1，则 fgets 只返回一个不完整的行，但是，缓冲区总是以 NULL 字符结尾，对 fgets 的下一次调用会继续读该行。函数成功将返回 stream，失败或读到文件结尾返回 NULL。因此不能直接通过 fgets 的返回值来判断函数是否是出错而终止的，应该借助 feof 函数或者 ferror 函数来判断。

13.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <string.h>
#include <stdio.h>

int main(void)
{
    FILE *stream;
    char str[] = "This is a test\n12344";
    char msg[20];

    stream = fopen("STU.FIL", "w+");
    fwrite(str, strlen(str), 1, stream);
    // seek to the start of the file
    fseek(stream, 0, SEEK_SET);
    while(!feof(stream))
    {
        fgets(msg, strlen(str) + 1, stream);
        printf("%s", msg);
    }
    fclose(stream);
    return 0;
}

13.3 运行结果

14. filelength

14.1 函数说明

函数声明 函数功能
long filelength(int handle); 获取文件的长度

14.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
#include <fcntl.h>
#include <io.h>

int main(void)
{
    int handle;
    char buf[30] = "This is a test\n12344";
    handle = open("STU.FIL", O_CREAT);
    write(handle, buf, strlen(buf));
    printf("file length in bytes: %ld\n", filelength(handle));
    close(handle);
    return 0;
}

14.3 运行结果

15. fileno

15.1 函数说明

函数声明 函数功能
int fileno(FILE *stream); 获取参数stream指定的文件流所使用的文件描述符

15.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include <fcntl.h>
#include <io.h>

int main(void)
{
    FILE *stream;
    char buf[30] = "This is a test\n12344";
    stream = fopen("STU.FIL", "w+");
    fwrite(buf, strlen(buf), 1, stream);
    // 清除读写缓冲区，并将缓冲区内的数据写回参数stream指向的文件中。
    fflush(stream);
    // 获取参数stream指定的文件流所使用的文件描述符
    int handle = fileno(stream);
    printf("file length in bytes: %ld\n", filelength(handle));
    fclose(stream);
    return 0;
}

15.3 运行结果

16. fillellipse

16.1 函数说明

函数声明 函数功能
void fillellipse(int x, int y, int xradius, int yradius); 画出并填充一椭圆

参数：

  • int x ：椭圆中心点的x坐标。在二维图形环境中，x坐标通常表示水平方向上的位置，从左到右增加；
  • int y ：椭圆中心点的y坐标。在二维图形环境中，y坐标通常表示垂直方向上的位置，从上到下增加；
  • int xradius ：椭圆在x轴方向上的半径。它是从椭圆中心点到椭圆边缘在x轴方向上的最大距离。如果 xradius 较大，椭圆在水平方向上会显得更宽;
  • int yradius ：椭圆在y轴方向上的半径。它是从椭圆中心点到椭圆边缘在y轴方向上的最大距离。如果 yradius 较大，椭圆在垂直方向上会显得更高。

16.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <graphics.h>

int main(void)
{
    int gdriver = DETECT, gmode;
    int xcenter, ycenter, i;

    initgraph(&gdriver,&gmode,"");
    xcenter = getmaxx() / 2;
    ycenter = getmaxy() / 2;

    for (i=EMPTY_FILL; i<USER_FILL; i++)
    {
        cleardevice();
        // 设置填充图样和颜色
        setfillstyle(i, WHITE);
        fillellipse(xcenter, ycenter, 100, 50);
        getch();
    }

    closegraph();
    return 0;
}

16.3 运行结果

17. fillpoly

17.1 函数说明

函数声明 函数功能
void fillpoly(int numpoints, int *polypoints); 画并填充一个多边形

参数：

  • numpoints ： 多边形边数
  • polypoints ： 存储各顶点坐标的数组，每两个一组表示一个顶点的X，Y坐标

17.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>

int main(void)
{
    int gdriver = DETECT, gmode, errorcode;
    int i, maxx, maxy;

    int poly[8];

    initgraph(&gdriver, &gmode, "");

    errorcode = graphresult();
    if (errorcode != grOk)
    {
        printf("Graphics error: %s\n", grapherrormsg(errorcode));
        printf("Press any key to halt:");
        getch();
        exit(1);
    }

    maxx = getmaxx();
    maxy = getmaxy();

    poly[0] = 20;
    poly[1] = maxy / 2;

    poly[2] = maxx - 20;
    poly[3] = 20;

    poly[4] = maxx - 50;
    poly[5] = maxy - 20;

    poly[6] = maxx / 2;
    poly[7] = maxy / 2;

    for (i=EMPTY_FILL; i<USER_FILL; i++)
    {
        setfillstyle(i, getmaxcolor());
        fillpoly(4, poly);
        getch();
    }

    closegraph();
    return 0;
}

17.3 运行结果

18. findfirst, findnext

18.1 函数说明

函数声明 函数功能
int _findfirst(char *pathname, struct _finddata_t *_FindData); 搜索与指定的文件名称匹配的第一个文件，若成功则返回第一个文件的文件描述符，否则返回-1L。
int _findnext(int handle, struct _finddata_t *_FindData); 搜索与_findfirst函数提供的文件名称匹配的下一个实例，若成功则返回0，否则返回－1

_findfirst 参数：

  • char *pathname ：一个指向以 null 结尾的字符串的指针，该字符串指定了要搜索的文件名模式。文件名模式可以包含通配符，如 *（匹配任意数量的字符）和 ?（匹配单个字符）。例如，"*.txt" 会匹配所有以 .txt 为扩展名的文件。如果 pathname 字符串的最后一个字符是目录分隔符，那么函数将搜索该目录下的所有文件和子目录；如果 pathname 是一个空字符串，函数将搜索当前目录。
  • struct _finddata_t *_FindData ：一个指向 _finddata_t 结构体的指针，该结构体用于接收关于找到的文件的信息。_finddata_t 结构体通常包含文件的属性（如是否只读、是否隐藏等）、创建时间、访问时间、修改时间、文件大小以及文件名等信息。调用 _findfirst 函数后， _FindData 指向的结构体将被填充为与文件名模式匹配的第一个文件的信息。如果搜索成功，_findfirst 函数将返回一个唯一的搜索句柄，这个句柄可以在后续的 _findnext 函数调用中使用，以查找与相同文件名模式匹配的其他文件。

_findnext 参数：

  • int handle ：一个由 _findfirst 函数返回的搜索句柄。这个句柄标识了一个特定的文件搜索操作，该操作在调用 _findfirst 后开始。搜索句柄是一个唯一的标识符，用于后续调用 _findnext 来检索与原始搜索条件匹配的下一个文件或目录。
  • struct _finddata_t *_FindData ：同上 _findfirst 的参数

18.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include<stdio.h>
#include<io.h>

int main()
{
    int handle;
    struct _finddata_t FileInfo;
    // 搜索与指定的文件名称匹配的第一个文件，若成功则返回第一个文件的文件描述符，否则返回-1L。
    if((handle=_findfirst("E:\\Pic\\*.png", &FileInfo))==-1L)
        printf("没有找到匹配的项目\n");
    else
    {
        printf("handle=%d\n", handle);
        printf("%s\n\n", FileInfo.name);
        // 搜索与_findfirst函数提供的文件名称匹配的下一个实例，若成功则返回0，否则返回－1
        while(_findnext(handle, &FileInfo)==0)
            printf("%s\n",FileInfo.name);
        _findclose(handle);
    }
    return 0;
}

18.3 运行结果

19. finite，finitef

19.1 函数说明

函数声明 函数功能
int finitef (double x); 检查 x 是无穷大值还是NaN 值（double）。如果是无穷大值或NaN值，返回 0；否则返回 1。
int finitef (float x); 检查 x 是无穷大值还是NaN 值（float）。如果是无穷大值或NaN值，返回 0；否则返回 1。

19.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include<stdio.h>
#include<math.h>

int main()
{
    double x = NAN, y = INFINITY, z = 10.24;
    printf("finite(%.2lf) = %d\n", x, finite(x));
    printf("finite(%.2lf) = %d\n", y, finite(y));
    printf("finite(%.2lf) = %d\n", z, finite(z));

    float xf = NAN, yf = INFINITY, zf = 5.63;
    printf("\nfinitef(%.2f) = %d\n", xf, finitef(xf));
    printf("finitef(%.2f) = %d\n", yf, finitef(yf));
    printf("finitef(%.2f) = %d\n", zf, finitef(zf));
    return 0;
}

19.3 运行结果

20. floodfill

20.1 函数说明

函数声明 函数功能
void floodfill(int x, int y, int border); 填充一个有界区域

参数：

  • int x ：要开始填充的区域的起始点的 x 坐标；
  • int y ：要开始填充的区域的起始点的 y 坐标；
  • int border ：填充的边界颜色。泛洪填充算法会从起始点 (x, y) 开始，将所有相邻的、颜色与起始点相同的区域填充为新的颜色，直到遇到边界颜色 border 为止。这样，算法就不会越过由 border 颜色定义的边界，从而保证了填充区域的准确性。

20.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>

int main(void)
{
    int gdriver = DETECT, gmode, errorcode;
    int maxx, maxy;

    initgraph(&gdriver, &gmode, "");

    errorcode = graphresult();
    if (errorcode != grOk)
    {
      printf("Graphics error: %s\n", grapherrormsg(errorcode));
      printf("Press any key to halt:");
      getch();
      exit(1);
    }

    maxx = getmaxx();
    maxy = getmaxy();

    // select drawing color
    setcolor(getmaxcolor());
    // select fill color
    setfillstyle(SOLID_FILL, getmaxcolor());
    // draw a border around the screen
    rectangle(0, 0, maxx, maxy);
    // draw some circles
    circle(maxx / 3, maxy /2, 50);
    circle(maxx / 2, 20, 100);
    circle(maxx-20, maxy-50, 75);
    circle(20, maxy-20, 25);

    getch();

    // fill in bounded region
    floodfill(2, 2, getmaxcolor());

    getch();
    closegraph();
    return 0;
}

20.3 运行结果

参考

  1. [API Reference Document]
  2. [fgets]
  3. [_findfirst]
  4. [MATH-标准C库]

C语言函数大全--e开头的函数

总览

函数声明 函数功能
char ecvt(double value, int ndigit, int *decpt, int *sign); 把一个双精度浮点型数转换为字符串，转换结果中不包括十进制小数点
void ellipse(int x, int y, int stangle, int endangle, int xradius, int yradius); 画一段椭圆线
int eof(int *handle); 检测文件结束
int execl(const char *pathname, const char *arg0, ... const char *argn, NULL); 载入并运行其它程序
int execlp(char *pathname, char *arg0, ... const char *argn, NULL); 载入并运行其它程序
int execlpe(const char *pathname, const char *arg0, ... const char *argn, NULL, const char *const *envp); 载入并运行其它程序
int execv(const char *pathname, char *const *argv); 载入并运行其它程序
int execve(const char *pathname, char *const argv[], char *const envp[]); 载入并运行其它程序
int execvp(const char *pathname, char *const argv[]); 载入并运行其它程序
int execvpe(const char *pathname, char *const argv[], char *const envp[]); 载入并运行其它程序
void exit(int status); 终止程序
double exp(double x); 计算 x 的基数e指数（double）
float expf(float x); 计算 x 的基数e指数（float）
long double expl(long double x); 计算 x 的基数e指数（long double）
double exp2(double x); 计算 x 的基数为2的指数（double）
float exp2f(float x); 计算 x 的基数为2的指数（float）
long double exp2l(long double x); 计算 x 的基数为2的指数（long double）
double expm1 (double x); 计算 e 的 x 次方 减 1，即 (e^x) - 1 （double）
float expm1f (float x); 计算 e 的 x 次方 减 1，即 (e^x) - 1 （float）
long double expm1l (long double x); 计算 e 的 x 次方 减 1，即 (e^x) - 1 （long double）
double erf (double x); 计算 x 的 误差函数（double）
float erff (float x); 计算 x 的 误差函数（float）
long double erfl (long double x); 计算 x 的 误差函数（long double）
double erfc (double x); 计算 x 的互补误差函数（double）
float erfcf (float x); 计算 x 的互补误差函数（float）
long double erfcl (long double x); 计算 x 的互补误差函数（long double）

1. ecvt

1.1 函数说明

函数声明 函数功能
char ecvt(double value, int ndigit, int *decpt, int *sign); 把一个双精度浮点型数转换为字符串，转换结果中不包括十进制小数点
  • value ： 待转换的双精度浮点数。
  • ndigit ：存储的有效数字位数。这个函数存储最多 ndigit 个数字值作为一个字符串，并添加一个结束符(‘\0’)，如果 value 中的数字个数超过 ndigit，低位数字被舍入。如果少于 ndigit 个数字，该字符串用 0填充。
  • decpt ：指出给出小数点位置的整数值, 它是从该字符串的开头位置计算的。0 或负数指出小数点在第一个数字的左边。
  • sign ：指出一个指出转换的数的符号的整数。如果该整数为 0,这个数为正数,否则为负数。

1.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>

int main()
{
    char *string;
    double value;
    int decpt, sign;

    int ndigit = 10;
    value = 9.876;
    string = ecvt(value, ndigit, &decpt, &sign);
    printf("string = %-16s decpt = %d sign = %d value = %lf\n", string, decpt, sign, value);

    value = -123.45;
    ndigit= 15;
    string = ecvt(value, ndigit, &decpt, &sign);
    printf("string = %-16s decpt = %d sign = %d value = %lf\n", string, decpt, sign, value);

    value = 0.6789e5; /* 科学记数法 scientific notation */
    ndigit = 5;
    string = ecvt(value, ndigit, &decpt, &sign);
    printf("string = %-16s decpt = %d sign = %d value = %lf\n", string, decpt, sign, value);

    return 0;
}

1.3 运行结果

2. ellipse

2.1 函数说明

函数声明 函数功能
void ellipse(int x, int y, int stangle, int endangle, int xradius, int yradius); 画一段椭圆线

以 (x, y) 为中心，xradius、yradius 为 x 轴 和 y 轴 半径，从角 stangle 开始，endangle 结束，画一段椭圆线。当stangle=0，endangle=360 时，画出一个完整的椭圆

2.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>

int main(void)
{
    // request auto detection
    int gdriver = DETECT, gmode, errorcode;
    int midx, midy;
    int stangle = 0, endangle = 360, midangle = 180;
    int xradius = 100, yradius = 50;

    // initialize graphics, local variables
    initgraph(&gdriver, &gmode, "");

    // read result of initialization
    errorcode = graphresult();
    if (errorcode != grOk) // an error occurred
    {
        printf("Graphics error: %s\n", grapherrormsg(errorcode));
        printf("Press any key to halt:");
        getch();
        exit(1);
    }

    midx = getmaxx() / 2;
    midy = getmaxy() / 2;
    setcolor(getmaxcolor());

    // draw ellipse
    ellipse(midx, 50, midangle, endangle, xradius, yradius);

    ellipse(midx, midy, stangle, endangle, xradius, yradius);

    ellipse(midx, getmaxy() - 50, stangle, midangle, xradius, yradius);

    getch();
    closegraph();
    return 0;
}

2.3 运行结果

3. eof

3.1 函数说明

函数声明 函数功能
int eof(int *handle); 检测文件结束

3.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <sys\stat.h>
#include <string.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>

int main(void)
{
    int handle;
    char msg[] = "This is a test";
    char ch;

    // create a file 
    handle = open("STU.FIL", O_CREAT | O_RDWR, S_IREAD | S_IWRITE);

    // write some data to the file 
    write(handle, msg, strlen(msg));

    // seek to the beginning of the file 
    lseek(handle, 0L, SEEK_SET);

    // reads chars from the file until hit EOF
    do
    {
        read(handle, &ch, 1);
        printf("%c", ch);
    } while (!eof(handle));

    close(handle);
    return 0;
}

3.3 运行结果

4. execl

4.1 函数说明

函数声明 函数功能
int execl(const char *pathname, const char *arg0, ... const char *argn, NULL); 载入并运行其它程序

注意： execl 函数，其后缀 l 代表 list，也就是参数列表的意思。第一个参数 path 字符指针指向要执行的文件路径， 接下来的参数代表执行该文件时传递的参数列表：argv[0],argv[1]... ，最后一个参数须用空指针 NULL 作结束。

4.2 演示示例

4.2.1 SubTest.c

1
2
3
4
5
6
#include <stdio.h>
int main(int argc, char *argv[])
{
  printf("exec %s, Hello, %s", argv[0], argv[1]);
  return 0;
}

4.2.2 Test.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <process.h>
#include <stdio.h>
#include <errno.h>

void main(int argc, char *argv[])
{
    int i;
    printf("Command line arguments:\n");
    for (i=0; i<argc; i++)
        printf("[%d] : %s\n", i, argv[i]);
    printf("exec SubTest with subargv ...\n");
    // 成功则不返回值， 失败返回-1， 失败原因存于errno中，可通过perror()打印
    // 第一个参数需要执行文件的全路径，这里写直接文件名，是因为和当前源码在同一目录中
    int result = execl("SubTest.exe", argv[0], "Huazie" , NULL);
    // 执行成功，这里不会执行到
    printf("result = %d\n", result);
    perror("exec error");
    exit(1);
}

4.3 运行结果

执行失败：

执行成功：

5. execle

5.1 函数说明

函数声明 函数功能
int execle(const char *pathname, const char *arg0, ... const char *argn, NULL, const char *const *envp); 载入并运行其它程序

注意： execl 函数是用来执行参数 path 字符串所代表的文件路径。接下来的参数代表执行该文件时传递过去的 argv[0], argv[1]…，并且倒数第二个参数必须用空指针 NULL 作结束，最后一个参数为 环境变量。

5.2 演示示例

5.2.1 SubEnvTest.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <process.h>
#include <processenv.h>
#include <stdio.h>

int main(int argc, char *argv[], char **envp)
{
    printf("SubEnvTest Command line arguments:\n");
    for (int i=0; i<argc; i++)
        printf("[%d] : %s\n", i, argv[i]);
    printf("exec %s, Hello, %s\n", argv[0], argv[1]);

    for (int i = 0; envp[i] != NULL; i++)
    {
        printf("%s\n", envp[i]);
    }
    // while(*envp != NULL)
    //     printf("  %s\n", *(envp++));

    return 0;
}

5.2.2 Test.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <process.h>
#include <stdio.h>
#include <errno.h>

void main(int argc, char *argv[])
{
    int i;
    printf("Command line arguments:\n");
    for (i=0; i<argc; i++)
        printf("[%d] : %s\n", i, argv[i]);
    printf("exec SubEnvTest with subargv ...\n");
    const char *envp[] = {"AUTHOR=Huazie", "DATE=2023-03-28", NULL}; // 环境变量
    
    // 成功则不返回值， 失败返回-1， 失败原因存于errno中，可通过perror()打印
    // 第一个参数需要执行文件的全路径，这里直接写文件名，是因为和当前源码在同一目录中
    int result = execle("SubEnvTest.exe", argv[0], "Huazie" , NULL, envp);
    // 执行成功，这里不会执行到
    printf("result = %d\n", result);
    perror("exec error");
    exit(1);
}

5.3 运行结果

6. execlp

6.1 函数说明

函数声明 函数功能
int execlp(char *pathname, char *arg0, ... const char *argn, NULL); 载入并运行其它程序

注意： execlp 函数会从 PATH 环境变量所指的目录中查找符合参数 pathname 的文件名，找到后便执行该文件，然后将第二个以后的参数当做该文件的arg0, arg1, …，最后一个参数必须用 空指针 NULL 作结束。

6.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <process.h>
#include <stdio.h>
#include <errno.h>

void main(int argc, char *argv[])
{
    int i;
    printf("Command line arguments:\n");
    for (i=0; i<argc; i++)
        printf("[%d] : %s\n", i, argv[i]);
    printf("exec java with subargv ...\n");
    // 成功则不返回值， 失败返回-1， 失败原因存于errno中，可通过perror()打印
    int result = execlp("java.exe", "java", "-version", NULL);
    // 执行成功，这里不会执行到
    printf("result = %d\n", result);
    perror("exec error");
    exit(1);
}

6.3 运行结果

7. execlpe

7.1 函数说明

函数声明 函数功能
int execlpe(const char *pathname, const char *arg0, ... const char *argn, NULL, const char *const *envp); 载入并运行其它程序

注意： execlp 函数会从 PATH 环境变量所指的目录中查找符合参数 pathname 的文件名，找到后便执行该文件，然后将第二个以后的参数当做该文件的arg0, arg1, …，其中倒数第二个参数必须用 空指针 NULL 作结束，最后一个参数为 环境变量。

7.2 演示示例

7.2.1 SubEnvTest.c

参考 5.2.1 的 SubEnvTest.c

7.2.2 Test.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <process.h>
#include <stdio.h>
#include <errno.h>

void main(int argc, char *argv[])
{
    int i;
    printf("Command line arguments:\n");
    for (i=0; i<argc; i++)
        printf("[%d] : %s\n", i, argv[i]);
    printf("exec SubEnvTest with subargv ...\n");
    const char *envp[] = {"AUTHOR=Huazie", "DATE=2023-03-28", NULL}; // 环境变量
    // 成功则不返回值， 失败返回-1， 失败原因存于errno中，可通过perror()打印
    int result = execlpe("SubEnvTest", argv[0], "Huazie", NULL, envp);
    // 执行成功，这里不会执行到
    printf("result = %d\n", result);
    perror("exec error");
    exit(1);
}

7.3 运行结果

8. execv

8.1 函数说明

函数声明 函数功能
int execv(const char *pathname, char *const *argv); 载入并运行其它程序

注意：execv 函数用来运行參数 pathname 字符串所指向的程序，第二个参数 argv 为參数列表【该数组的最后一个元素必须是空指针 NULL】。

8.2 演示示例

8.2.1 SubTest.c

参考 4.2.1 的 SubTest.c

8.2.2 Test.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <process.h>
#include <stdio.h>
#include <errno.h>

void main(int argc, char *argv[])
{
    int i;
    printf("Command line arguments:\n");
    for (i=0; i<argc; i++)
        printf("[%d] : %s\n", i, argv[i]);
    printf("exec SubTest with subargv ...\n");
    char *const subargv[]  = {argv[0], "Huazie" , NULL}; // 参数列表
    // 成功则不返回值， 失败返回-1， 失败原因存于errno中，可通过perror()打印
    // 第一个参数需要执行文件的全路径，这里写直接文件名，是因为和当前源码在同一目录中
    int result = execv("SubTest.exe", subargv);
    // 执行成功，这里不会执行到
    printf("result = %d\n", result);
    perror("exec error");
    exit(1);
}

8.3 运行结果

9. execve

9.1 函数说明

函数声明 函数功能
int execve(const char *pathname, char *const argv[], char *const envp[]); 载入并运行其它程序

注意：execve 函数用来运行參数 pathname 字符串所指向的程序，第二个参数 argv 为參数列表【该数组的最后一个元素必须是空指针 NULL】，最后一个参数为 环境变量。

9.2 演示示例

9.2.1 SubEnvTest.c

参考 5.2.1 的 SubEnvTest.c

9.2.2 Test.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <process.h>
#include <stdio.h>
#include <errno.h>

void main(int argc, char *argv[])
{
    int i;
    printf("Command line arguments:\n");
    for (i=0; i<argc; i++)
        printf("[%d] : %s\n", i, argv[i]);
    printf("exec SubEnvTest with subargv ...\n");
    char *const subargv[]  = {argv[0], "Huazie" , NULL}; // 参数列表
    char *const envp[] = {"AUTHOR=Huazie", "DATE=2023-03-28", NULL}; // 环境变量
    // 成功则不返回值， 失败返回-1， 失败原因存于errno中，可通过perror()打印
    // 第一个参数需要执行文件的全路径，这里写直接文件名，是因为和当前源码在同一目录中
    int result = execve("SubEnvTest.exe", subargv, envp);
    // 执行成功，这里不会执行到
    printf("result = %d\n", result);
    perror("exec error");
    exit(1);
}

9.3 运行结果

10. execvp

10.1 函数说明

函数声明 函数功能
int execvp(const char *pathname, char *const argv[]); 载入并运行其它程序

注意：execvp 函会从 PATH 环境变量所指的目录中查找符合参数 pathname 的文件名，找到后便执行该文件，第二个参数 argv 为參数列表【该数组的最后一个元素必须是空指针 NULL】。

10.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <process.h>
#include <stdio.h>
#include <errno.h>

void main(int argc, char *argv[])
{
    int i;
    printf("Command line arguments:\n");
    for (i=0; i<argc; i++)
        printf("[%d] : %s\n", i, argv[i]);
    printf("exec java with subargv ...\n");
    char *const subargv[]  = {"java", "-version" , NULL}; // 参数列表
    // 成功则不返回值， 失败返回-1， 失败原因存于errno中，可通过perror()打印
    int result = execvp("java.exe", subargv);
    // 执行成功，这里不会执行到
    printf("result = %d\n", result);
    perror("exec error");
    exit(1);
}

10.3 运行结果

11. execvpe

11.1 函数说明

函数声明 函数功能
int execvpe(const char *pathname, char *const argv[], char *const envp[]); 载入并运行其它程序

注意：execvpe 函会从 PATH 环境变量所指的目录中查找符合参数 pathname 的文件名，找到后便执行该文件，第二个参数 argv 为參数列表【该数组的最后一个元素必须是空指针 NULL】，最后一个参数为 环境变量。

11.2 演示示例

11.2.1 SubEnvTest.c

参考 5.2.1 的 SubEnvTest.c

11.2.2 Test.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <process.h>
#include <stdio.h>
#include <errno.h>

void main(int argc, char *argv[])
{
    int i;
    printf("Command line arguments:\n");
    for (i=0; i<argc; i++)
        printf("[%d] : %s\n", i, argv[i]);
    printf("exec SubEnvTest with subargv ...\n");
    char *const subargv[]  = {argv[0], "Huazie" , NULL}; // 参数列表
    char *const envp[] = {"AUTHOR=Huazie", "DATE=2023-03-28", NULL}; // 环境变量
    // 成功则不返回值， 失败返回-1， 失败原因存于errno中，可通过perror()打印
    int result = execvpe("SubEnvTest.exe", subargv, envp);
    // 执行成功，这里不会执行到
    printf("result = %d\n", result);
    perror("exec error");
    exit(1);
}

11.3 运行结果

12. exit

12.1 函数说明

函数声明 函数功能
void exit(int status); 终止程序

注意： exit 函数通常是用来终结程序用的，使用后程序自动结束，跳回操作系统。exit(0) 表示程序正常退出【相当于主函数 return 0;】，exit⑴ 表示程序异常退出【相当于主函数 return 1;】。

12.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdlib.h>
#include <stdio.h>

int main(void)
{
    int status;

    printf("Enter either 1 or 2\n");
    status = getchar();
    /* Sets DOS errorlevel  */
    exit(status - '0');

    /* Note: this line is never reached */
    printf("this line is never reached!");
    return 0;
}

12.3 运行结果

13. exp，expf，expl

13.1 函数说明

函数声明 函数功能
double exp(double x); 计算 x 的基数e指数（double）
float expf(float x); 计算 x 的基数e指数（float）
long double expl(long double x); 计算 x 的基数e指数（long double）

13.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
#include <math.h>

int main(void)
{
    double result, x = 4.0;
    result = exp(x);

    float resultf, xf = 4.0;
    resultf = expf(xf);

    long double resultL, xL = 4.0;
    resultL = expl(xL);

    printf("\n'e' raised to the power of %lf (e ^ %lf) = %.20lf\n", x, x, result);
    printf("\n'e' raised to the power of %f (e ^ %f) = %.20f\n", xf, xf, resultf);
    printf("\n'e' raised to the power of %Lf (e ^ %Lf) = %.20Lf\n", xL, xL, resultL);

    return 0;
}

13.3 运行结果

14. exp2，exp2f，exp2l

14.1 函数说明

函数声明 函数功能
double exp2(double x); 计算 x 的基数为2的指数（double）
float exp2f(float x); 计算 x 的基数为2的指数（float）
long double exp2l(long double x); 计算 x 的基数为2的指数（long double）

14.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
#include <math.h>

int main(void)
{
    double result, x = 4.5;
    result = exp2(x);

    float resultf, xf = 4.5;
    resultf = exp2f(xf);

    long double resultL, xL = 4.5;
    resultL = exp2l(xL);

    printf("\n'2' raised to the power of %lf (2 ^ %lf) = %.20lf\n", x, x, result);
    printf("\n'2' raised to the power of %f (2 ^ %f) = %.20f\n", xf, xf, resultf);
    printf("\n'2' raised to the power of %Lf (2 ^ %Lf) = %.20Lf\n", xL, xL, resultL);

    return 0;
}

14.3 运行结果

15. expm1，expm1f，expm1l

15.1 函数说明

函数声明 函数功能
double expm1 (double x); 计算 e 的 x 次方 减 1，即 (e^x) - 1 （double）
float expm1f (float x); 计算 e 的 x 次方 减 1，即 (e^x) - 1 （float）
long double expm1l (long double x); 计算 e 的 x 次方 减 1，即 (e^x) - 1 （long double）

15.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <stdio.h>
#include <math.h>

int main(void)
{
    double result, result1, x = 4.0;
    result = exp(x);
    result1 = expm1(x);

    float resultf, resultf1, xf = 4.0;
    resultf = expf(xf);
    resultf1 = expm1f(xf);

    long double resultL, resultL1, xL = 4.0;
    resultL = expl(xL);
    resultL1 = expm1l(xL);

    printf("\n'e' raised to the power of %lf (e ^ %lf) = %.20lf\n", x, x, result);
    printf("\n'e' raised to the power of %lf minus one (e ^ %lf - 1) = %.20lf\n", x, x, result1);

    printf("\n'e' raised to the power of %f (e ^ %f) = %.20f\n", xf, xf, resultf);
    printf("\n'e' raised to the power of %f minus one (e ^ %f - 1) = %.20f\n", xf, xf, resultf1);

    printf("\n'e' raised to the power of %Lf (e ^ %Lf) = %.20Lf\n", xL, xL, resultL);
    printf("\n'e' raised to the power of %Lf minus one (e ^ %Lf - 1) = %.20Lf\n", xL, xL, resultL1);

    return 0;
}

15.3 运行结果

16. erf，erff，erfl

16.1 函数说明

函数声明 函数功能
double erf (double x); 计算 x 的 误差函数（double）
float erff (float x); 计算 x 的 误差函数（float）
long double erfl (long double x); 计算 x 的 误差函数（long double）

16.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
#include <math.h>

int main(void)
{
    double result, x = 2.0;
    result = erf(x); // 高斯误差函数

    float resultf, xf = 2.0;
    resultf = erff(xf);

    long double resultL, xL = 2.0;
    resultL = erfl(xL);

    printf("the error function of %lf = %.20lf\n", x, result);
    printf("the error function of %f = %.20f\n", xf, resultf);
    printf("the error function of %Lf = %.20Lf\n", xL, resultL);    
    
    return 0;
}

16.3 运行结果

17. erfc，erfcf，erfcl

17.1 函数说明

函数声明 函数功能
double erfc (double x); 计算 x 的互补误差函数（double）
float erfcf (float x); 计算 x 的互补误差函数（float）
long double erfcl (long double x); 计算 x 的互补误差函数（long double）

17.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
#include <math.h>

int main(void)
{
    double result, x = 2.0;
    result = erfc(x); // 互补误差函数

    float resultf, xf = 2.0;
    resultf = erfcf(xf);

    long double resultL, xL = 2.0;
    resultL = erfcl(xL);

    printf("the complementary error function of %lf = %.20lf\n", x, result);
    printf("the complementary error function of %f = %.20f\n", xf, resultf);
    printf("the complementary error function of %Lf = %.20Lf\n", xL, resultL);    
    
    return 0;
}

17.3 运行结果

参考

  1. [API Reference Document]
  2. [ecvt 函数]
  3. [exec函数]

C语言函数大全--d开头的函数

总览

函数声明 函数功能
void detectgraph(int *graphdriver, int *graphmode); 通过检测硬件确定图形驱动程序和模式
double difftime(time_t time2, time_t time1); 计算两个时刻之间的时间差
void disable(void); 屏蔽中断
div_t div(int number, int denom); 将两个整数相除, 返回商和余数
void drawpoly(int numpoints, int *polypoints); 画多边形
int dup(int handle); 复制文件描述符；若成功为新的文件描述，若出错为-1
int dup2(int oldhandle, int newhandle); 复制文件描述符；若成功为新的文件描述，若出错为-1。

1. detectgraph

1.1 函数说明

函数声明 函数功能
void detectgraph(int *graphdriver, int *graphmode); 通过检测硬件确定图形驱动程序和模式

1.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>

/* names of the various cards supported */
char *dname[] = {
    "requests detection",
    "a CGA",
    "an MCGA",
    "an EGA",
    "a 64K EGA",
    "a monochrome EGA",
    "an IBM 8514",
    "a Hercules monochrome",
    "an AT&T 6300 PC",
    "a VGA",
    "an IBM 3270 PC"
};

int main(void)
{
    int gdriver, gmode, errorcode;

    detectgraph(&gdriver, &gmode);

    initgraph(&gdriver, &gmode, "");

    errorcode = graphresult();

    if (errorcode != grOk)
    {
        printf("Graphics error: %s\n", grapherrormsg(errorcode));
        printf("Press any key to halt:");
        getch();
        exit(1);
    }

    printf("You have [%s] video display card.\n", dname[gdriver]);
    printf("Press any key to halt:");
    getch();
    return 0;
}

1.3 运行结果

2. difftime

2.1 函数说明

函数声明 函数功能
double difftime(time_t time2, time_t time1); 计算两个时刻之间的时间差

2.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
#include <time.h>

int main(void)
{
    time_t first, second; // time_t 相当于 long
    first = time(NULL);  // Gets system time 
    getchar();
    second = time(NULL); // Gets system time again 
    printf("The difference is: %lf seconds\n", difftime(second, first));
    return 0;
}

在上述的示例代码中，

  • 首先，我们定义了两个 time_t 类型的变量 first 和 second；
  • 然后，调用 time(NULL) 函数获取当前的系统时间，并赋值给 first；
  • 接着，调用 getchar() 函数等待用户输入，模拟延时的功能；
  • 再然后，继续调用 time(NULL) 函数获取当前的系统时间，并赋值给 second；
  • 再接着，调用 difftime() 函数计算 first 和 second 之间的时间差【单位：秒】
  • 最终，输出时间差，并结束程序。

2.3 运行结果

3. disable

3.1 函数说明

函数声明 函数功能
void disable(void); 屏蔽中断

3.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
// 中断服务示例
#include <stdio.h>
#include <dos.h>
#include <conio.h>
// 定义一个宏INTR，代表时钟中断的十六进制向量值
#define INTR 0X1C  
// 声明一个函数指针oldhandler，该指针指向一个没有参数且返回void的函数。
// 这种函数通常用于中断处理程序
void interrupt (*oldhandler)(void);

int count=0;

void interrupt handler(void)
{
    // 禁用其他中断，确保此中断处理程序执行完毕前不再响应其他中断
    disable();
    count++;
    // 启用其他中断
    enable(); 
    // 调用原先的中断处理程序
    (*oldhandler)();
}

int main(void)
{
    // 获取时钟中断的原始处理程序，并将其存储在oldhandler指向的函数中
    oldhandler = getvect(INTR);
    // 将时钟中断的处理程序设置为handler函数
    setvect(INTR, handler);

    while (count < 20)
        printf("count is %d\n",count);
    // 恢复时钟中断的原始处理程序
    setvect(INTR, oldhandler);

    return 0;
}

注意： 这个程序可能无法在现代操作系统上直接运行，因为其中的一些函数（如disable()、enable()、getvect() 和 setvect()）是特定于 DOS 的。如果你想在现代操作系统（如 Linux 或 Windows）上运行这个程序，你可能需要使用更现代的方法来处理中断或使用 DOS 模拟器。

4. div

4.1 函数说明

函数声明 函数功能
div_t div(int number, int denom); 将两个整数相除, 返回商和余数

4.2 演示示例

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
#include <math.h>

int main(void)
{
    div_t x = div(10,3);
    // 商 和 余数
    printf("10 div 3 = %d remainder %d\n", x.quot, x.rem);
    return 0;
}

4.3 运行结果

5. drawpoly

5.1 函数说明

函数声明 函数功能
void drawpoly(int numpoints, int *polypoints); 画多边形

参数说明：

  • numpoints：多边形顶点的数量

  • polypoints：一个整数数组，包含多边形的各个顶点的坐标。

5.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#include <graphics.h>
#include <stdio.h>

int main(void)
{
    // request auto detection
    int gdriver = DETECT, gmode, errorcode;
    int maxx, maxy;

    // our polygon array
    int poly[10];

    // initialize graphics and local variables
    initgraph(&gdriver, &gmode, "");

    // read result of initialization
    errorcode = graphresult();
    if (errorcode != grOk) // an error occurred
    {
        printf("Graphics error: %s\n", grapherrormsg(errorcode));
        printf("Press any key to halt:");
        getch();
        // terminate with an error code
        exit(1);
    }

    maxx = getmaxx();
    maxy = getmaxy();

    poly[0] = 20;
    poly[1] = maxy / 2;

    poly[2] = maxx - 20;
    poly[3] = 20;

    poly[4] = maxx - 50;
    poly[5] = maxy - 20;

    poly[6] = maxx / 2;
    poly[7] = maxy / 2;

    // drawpoly doesn't automatically close the polygon, so we close it.

    poly[8] = poly[0];
    poly[9] = poly[1];

    // draw the polygon
    drawpoly(5, poly);

    // clean up
    getch();
    closegraph();
    return 0;
}

5.3 运行结果

6. dup

6.1 函数说明

函数声明 函数功能
int dup(int handle); 复制文件描述符；若成功为新的文件描述，若出错为-1

dup 返回的新文件描述符一定是当前可用文件描述中的最小数值。

6.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <stdio.h>
#include <conio.h>
#include <fcntl.h>
#include <io.h>

void flush(FILE *stream);

int main(void)
{
    FILE *fp;
    char msg[] = "This is a test";

    fp = fopen("STU.FIL", "w");

    fwrite(msg, strlen(msg), 1, fp);

    int handle;

    handle = open("temp.txt", _O_RDWR | _O_CREAT, _S_IREAD | _S_IWRITE);
    printf("file hanlde : %d\n", handle);

    printf("Press any key to flush STU.FIL:");
    getchar();

    flush(fp);

    printf("\nFile was flushed, Press any key to quit:");
    getchar();
    return 0;
}

void flush(FILE *stream)
{
    int duphandle;

    fflush(stream);

    duphandle = dup(fileno(stream));

    printf("duplicate file hanlde : %d", duphandle);

    close(duphandle);
}

上述代码可以简单总结如下：

  1. 首先，它打开一个名为"STU.FIL"的文件，并以写入模式打开。
  2. 然后，将字符串"This is a test"写入该文件。
  3. 接下来，它打开一个名为 "temp.txt" 的文件，并获取其文件句柄。
  4. 然后，提示用户按下任意键以刷新 "STU.FIL" 文件。
  5. 接着，调用自定义的flush函数来刷新文件缓冲区。
    • 首先调用fflush函数来刷新传入的文件流的缓冲区;
    • 然后，使用dup函数复制文件描述符，并将其存储在duphandle变量中;
    • 接着，打印出复制的文件句柄；
    • 最后，关闭复制的文件句柄。
  6. 最后，再次提示用户按下任意键以退出程序。

6.3 运行结果

7. dup2

7.1 函数说明

函数声明 函数功能
int dup2(int oldhandle, int newhandle); 复制文件描述符；若成功为新的文件描述，若出错为-1。

dup2 可以用 newhandle 参数指定新的描述符数值。如果 newhandle 已经打开，则先关闭。若 oldhandle = newhandle，则 dup2 返回 newhandle，而不关闭它。

7.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <sys\stat.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <io.h>

int main(void)
{
    #define STDOUT 1

    int handle, oldstdout;
    char msg[] = "This is a test1";

    handle = open("STU.FIL", O_CREAT | O_RDWR, S_IREAD | S_IWRITE);
    printf("open file handle : %d\n", handle);

    oldstdout = dup(STDOUT);
    printf("dup file handle : %d", oldstdout);

    dup2(handle, STDOUT);

    close(handle);

    write(STDOUT, msg, strlen(msg));

    dup2(oldstdout, STDOUT);

    close(oldstdout);

    return 0;
}

上述代码简单分析如下：

  • 定义常量 STDOUT，其值为 1，表示标准输出的文件描述符；
  • 定义整型变量 handle 和 oldstdout，以及字符数组 msg，用于存储要写入文件的字符串；
  • 使用 open 函数打开名为 "STU.FIL" 的文件，以创建和读写模式（O_CREAT | O_RDWR）打开，并设置文件权限为可读可写（S_IREAD | S_IWRITE）；将返回的文件描述符赋值给 handle，并打印出来；
  • 使用 dup 函数备份当前的标准输出（STDOUT），将备份的文件描述符赋值给 oldstdout，并打印出来；
  • 使用 dup2 函数将标准输出重定向到 handle 指向的文件，即将后续的输出内容写入到 "STU.FIL" 文件中；
  • 关闭 handle 指向的文件句柄；
  • 使用 write 函数将 msg 字符串写入到标准输出（此时已经重定向到文件），长度为字符串的长度；
  • 使用 dup2 函数将标准输出恢复到备份的文件描述符 oldstdout，即将后续的输出内容输出到屏幕上。
  • 关闭 oldstdout 指向的文件句柄。

7.3 运行结果

参考

  1. [API Reference Document]

C语言函数大全--c开头的函数

总览

函数声明 函数功能
double cbrt (double x) 计算 x 的立方根（double）
float cbrtf (float x) 计算 x 的立方根（float）
long double cbrtl (long double x) 计算 x 的立方根（long double）
double ceil (double x) 计算大于或等于x的最小整数（double）
float ceilf (float x) 计算大于或等于x的最小整数（float）
long double ceill (long double x) 计算大于或等于x的最小整数（long double）
double copysign (double x, double y); 通过组合x的大小和y的符号生成一个值。（double） 例如，如果x为2.0，y为-1.0，则将生成值-2.0。
float copysignf (float x, float y); 通过组合x的大小和y的符号生成一个值。（float） 例如，如果x为2.0，y为-1.0，则将生成值-2.0。
long double copysignl (long double x, long double y); 通过组合x的大小和y的符号生成一个值。（long double） 例如，如果x为2.0，y为-1.0，则将生成值-2.0。
int chdir(const char *path); 更改当前的工作目录。如果成功返回 0，否则返回 -1
int chmod( const char *filename, int pmode); 变更文件或目录的权限。如果改变成功返回0，否则返回-1
int chsize(int handle, long size); 改变文件大小
void circle(int x, int y, int radius); 在给定半径radius，以(x, y)为圆心画圆
void cleardevice(void); 清除图形屏幕
void clearerr(FILE *stream); 复位错误标志，使用它可以使文件错误标志和文件结束标志置为 0。
void clearviewport(); 清除图形视区
int close(int handle); 通过文件描述符handle，来关闭文件，成功返回0，出错返回-1
long clock(void); 确定处理器调用某个进程或函数所用的时间
void closegraph(); 关闭图形系统
double cos(double x); 计算x的余弦（double）
float cosf(float x); 计算x的余弦（float）
long double cosl(long double x); 计算x的余弦（long double）
double cosh(double x); 计算x的双曲余弦（double）
float coshf(float x); 计算x的双曲余弦（float）
long double coshl(long double x); 计算x的双曲余弦（long double）
int creat (const char *filename, int mode); 创建一个新文件或重写一个已存在的文件
char *ctime(const time_t *time); 把日期和时间转换为字符串

1. cbrt，cbrtf，cbrtl

1.1 函数说明

函数声明 函数功能
double cbrt (double x) 计算 x 的立方根（double）
float cbrtf (float x) 计算 x 的立方根（float）
long double cbrtl (long double x) 计算 x 的立方根（long double）

1.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
#include <math.h>

int main(void)
{
    double x = 8.0;
    float xf = 27.0;
    long double xL = 64.0;

    // 立方根
    printf("The cube root of the double value %.4lf is %.4lf\n", x, cbrt(x));
    printf("The cube root of the float value %.4f is %.4f\n", xf, cbrtf(xf));
    printf("The cube root of the long double value %.4Lf is %.4Lf", xL, cbrtl(xL));    

    return 0;
}

1.3 运行结果

2. ceil，ceilf，ceill

2.1 函数说明

函数声明 函数功能
double ceil (double x) 计算大于或等于x的最小整数（double）
float ceilf (float x) 计算大于或等于x的最小整数（float）
long double ceill (long double x) 计算大于或等于x的最小整数（long double）

2.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
#include <math.h>

int main(void)
{
    double x = 2.3;
    float xf = 2.5;
    long double xL = 2.8;

    // 计算大于或等于x的最小整数
    printf("The minimum integer greater than or equal to the [x = %.4lf] is %.4lf\n", x, ceil(x));
    printf("The minimum integer greater than or equal to the [x = %.4f]  is %.4f\n", xf, ceilf(xf));
    printf("The minimum integer greater than or equal to the [x = %.4Lf] is %.4Lf", xL, ceill(xL));    
    return 0;
}

2.3 运行结果

3. copysign，copysignf，copysignl

3.1 函数说明

函数声明 函数功能
double copysign (double x, double y); 通过组合x的大小和y的符号生成一个值。（double） 例如，如果x为2.0，y为-1.0，则将生成值-2.0。
float copysignf (float x, float y); 通过组合x的大小和y的符号生成一个值。（float） 例如，如果x为2.0，y为-1.0，则将生成值-2.0。
long double copysignl (long double x, long double y); 通过组合x的大小和y的符号生成一个值。（long double） 例如，如果x为2.0，y为-1.0，则将生成值-2.0。

3.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
#include <math.h>

int main(void)
{
    double x = 2.0, y = -1.0;
    float xf = 2.0, yf = -1.0;
    long double xL = 2.0, yL = -1.0;

    // 通过组合x的大小和y的符号生成一个值
    printf("The double value by combining the magnitude of [x = %.4lf] and the sign of [y = %.4lf] is %.4lf\n", x, y, copysign(x, y));
    printf("The float value by combining the magnitude of [x = %.4f] and the sign of [y = %.4f] is %.4f\n", xf, yf, copysignf(xf, yf));
    printf("The long double value by combining the magnitude of [x = %.4Lf] and the sign of [y = %.4Lf] is %.4Lf", xL, yL, copysignl(xL, yL));    
    return 0;
}

3.3 运行结果

4. chdir

4.1 函数说明

函数声明 函数功能
int chdir(const char *path); 更改当前的工作目录。如果成功返回 0，否则返回 -1

4.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include <stdio.h>
#include <stdlib.h>
#include <dir.h>

#define MAXDIR 1000
char old_dir[MAXDIR];
char new_dir[MAXDIR];

int main()
{
    if (!getcwd(old_dir, MAXDIR)) // 获取当前的目录
    {
        perror("getcwd()");
        exit(1);
    }
    printf("Current directory is: %s\n", old_dir); 

    if (chdir("D:\\")) // 切换目录，成功返回0，失败返回-1
    {
        perror("chdir()");
        exit(1);
    }

    if (!getcwd(new_dir, MAXDIR))
    {
        perror("getcwd()");
        exit(1);
    }
    printf("Current directory is now: %s\n", new_dir);

    printf("\nChanging back to orignal directory: %s\n", old_dir);

    if (chdir(old_dir))
    {
        perror("chdir()");
        exit(1);
    }

    return 0;
}

4.3 运行结果

5. chmod

5.1 函数说明

函数声明 函数功能
int chmod( const char *filename, int pmode); 变更文件或目录的权限。如果改变成功返回0，否则返回-1

5.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <sys\stat.h>
#include <stdio.h>
#include <io.h>

void make_read_only(char *filename);

int main(void)
{
    make_read_only("NOTEXIST.FIL");
    make_read_only("students.txt");
    return 0;
}

void make_read_only(char *filename)
{
    int stat;

    stat = chmod(filename, S_IREAD);
    if (stat)
        printf("Couldn't make %s read-only\n", filename);
    else
        printf("Made %s read-only\n", filename);
}

5.3 运行结果

6. chsize

6.1 函数说明

函数声明 函数功能
int chsize(int handle, long size); 改变文件大小

6.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>
int main()
{
   int fh, result;
   unsigned int nbytes = 2048;
   // 打开文件
   if((fh=open("temp.txt", _O_RDWR | _O_CREAT, _S_IREAD | _S_IWRITE))  != -1)
   {
      printf("File length before: %ld\n", filelength(fh)); // 获取文件大小
      if((result=chsize(fh, nbytes))== 0)
         printf("Size successfully changed\n");
      else
         printf("Problem in changing the size\n");
      printf("File length after:  %ld\n", filelength(fh));
      close(fh);
   }
   return 0;
}

6.3 运行结果

7. circle

7.1 函数说明

函数声明 函数功能
void circle(int x, int y, int radius); 在给定半径radius，以(x, y)为圆心画圆

7.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>

int main(void)
{
    /* request auto detection */
    int gdriver = DETECT, gmode, errorcode;
    int midx, midy;
    int radius = 100;

    /* initialize graphics and local variables */
    initgraph(&gdriver, &gmode, "");

    /* read result of initialization */
    errorcode = graphresult();
    if (errorcode != grOk)  /* an error occurred */
    {
      printf("Graphics error: %s\n", grapherrormsg(errorcode));
      printf("Press any key to halt:");
      getch();
      exit(1); /* terminate with an error code */
    }

    midx = getmaxx() / 2;
    midy = getmaxy() / 2;
    setcolor(getmaxcolor());

    /* draw the circle */
    circle(midx, midy, radius);

    /* clean up */
    getch();
    closegraph();
    return 0;
}

7.3 运行结果

8. cleardevice

8.1 函数说明

函数声明 函数功能
void cleardevice(void); 清除图形屏幕

8.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>

int main(void)
{
    /* request auto detection */
    int gdriver = DETECT, gmode, errorcode;
    int midx, midy;

    /* initialize graphics and local variables */
    initgraph(&gdriver, &gmode, "");

    /* read result of initialization */
    errorcode = graphresult();
    if (errorcode != grOk)  /* an error occurred */
    {
        printf("Graphics error: %s\n", grapherrormsg(errorcode));
        printf("Press any key to halt:");
        getch();
        exit(1); /* terminate with an error code */
    }

    midx = getmaxx() / 2;
    midy = getmaxy() / 2;
    setcolor(getmaxcolor());

    /* for centering screen messages */
    settextjustify(CENTER_TEXT, CENTER_TEXT);

    /* output a message to the screen */
    outtextxy(midx, midy, "press any key to clear the screen:");

    /* wait for a key */
    getch();

    /* clear the screen */
    cleardevice();

    /* output another message */
    outtextxy(midx, midy, "press any key to quit:");

    /* clean up */
    getch();
    closegraph();
    return 0;
}

8.3 运行结果

9. clearerr

9.1 函数说明

函数声明 函数功能
void clearerr(FILE *stream); 复位错误标志，使用它可以使文件错误标志和文件结束标志置为 0。

9.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <stdio.h>

int main(void)
{
    FILE *fp;
    char ch;

    /* open a file for writing */
    fp = fopen("temp.txt", "w");

    /* force an error condition by attempting to read */
    ch = fgetc(fp);
    printf("%c\n",ch);

    int errorFlag = ferror(fp);
    printf("Error Flag : %d\n", errorFlag);
    if (errorFlag)
    {
        /* display an error message */
        printf("Error reading from temp.txt\n");

        /* reset the error and EOF indicators */
        clearerr(fp);
    }

    printf("Error Flag : %d", ferror(fp));

    fclose(fp);
    return 0;
}

9.3 运行结果

10. clearviewport

10.1 函数说明

函数声明 函数功能
void clearviewport(); 清除图形视区

10.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>

#define CLIP_ON 1   /* activates clipping in viewport */

int main(void)
{
    /* request auto detection */
    int gdriver = DETECT, gmode, errorcode;
    int ht;

    /* initialize graphics and local variables */
    initgraph(&gdriver, &gmode, "");

    /* read result of initialization */
    errorcode = graphresult();
    if (errorcode != grOk)  /* an error occurred */
    {
        printf("Graphics error: %s\n", grapherrormsg(errorcode));
        printf("Press any key to halt:");
        getch();
        exit(1); /* terminate with an error code */
    }

    setcolor(getmaxcolor());
    ht = textheight("W");

    /* message in default full-screen viewport */
    outtextxy(0, 0, "* <-- (0, 0) in default viewport");

    /* create a smaller viewport */
    setviewport(50, 50, getmaxx()-50, getmaxy()-50, CLIP_ON);

    /* display some messages */
    outtextxy(0, 0, "* <-- (0, 0) in smaller viewport");
    outtextxy(0, 2*ht, "Press any key to clear viewport:");

    /* wait for a key */
    getch();

    /* clear the viewport */
    clearviewport();

    /* output another message */
    outtextxy(0, 0, "Press any key to quit:");

    /* clean up */
    getch();
    closegraph();
    return 0;
}

10.3 运行结果

11. close

11.1 函数说明

函数声明 函数功能
int close(int handle); 通过文件描述符handle，来关闭文件，成功返回0，出错返回-1

11.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>

int main()
{
    int handle;
    char buf[11] = "0123456789";

    /* create a file containing 10 bytes */
    handle = open("temp.txt", _O_RDWR | _O_CREAT, _S_IREAD | _S_IWRITE);
    if (handle > -1)
    {
        write(handle, buf, strlen(buf));
        printf("Write successfully\n");
        /* close the file */
        close(handle);
        printf("Close File successfully");
    }
    else
    {
        printf("Error opening file\n");
    }
    return 0;
}

11.3 运行结果

12. clock

12.1 函数说明

函数声明 函数功能
long clock(void); 确定处理器调用某个进程或函数所用的时间

12.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <time.h>
#include <stdio.h>
#include <dos.h>

int main(void)
{
    clock_t start, end;
    start = clock();
    printf("start = %ld\n", start);
    getchar();

    end = clock();
    printf("end = %ld\n", end);
    printf("The time was: %.3lfs\n", (double) (end - start) / CLK_TCK);

    return 0;
}

12.3 运行结果

13. closegraph

13.1 函数说明

函数声明 函数功能
void closegraph(); 关闭图形系统

13.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>

int main(void)
{
    /* request auto detection */
    int gdriver = DETECT, gmode, errorcode;
    int x, y;

    /* initialize graphics mode */
    initgraph(&gdriver, &gmode, "");

    /* read result of initialization */
    errorcode = graphresult();

    if (errorcode != grOk)  /* an error occurred */
    {
        printf("Graphics error: %s\n", grapherrormsg(errorcode));
        printf("Press any key to halt:");
        getch();
        exit(1); /* terminate with an error code */
    }

    x = getmaxx() / 2;
    y = getmaxy() / 2;

    /* output a message */
    settextjustify(CENTER_TEXT, CENTER_TEXT);
    outtextxy(x, y, "Press a key to close the graphics system:");

    /* wait for a key */
    getch();

    /* closes down the graphics system */
    closegraph();

    printf("We're now back in text mode.\n");
    printf("Press any key to halt:");
    getchar();
    return 0;
}

13.3 运行结果

14. cos，cosf，cosl

14.1 函数说明

函数声明 函数功能
double cos(double x); 计算x的余弦（double）
float cosf(float x); 计算x的余弦（float）
long double cosl(long double x); 计算x的余弦（long double）

14.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// Huazie
#include <stdio.h>
#include <math.h>

int main(void)
{
    double x = 1.0;
    double result = cos(x); // 余弦

    float xf = 1.0f;
    float resultf = cosf(xf);

    long double xL = 1.0;
    long double resultL = cosl(xL);

    printf("The cosine of %lf is %.16lf\n", x, result);
    printf("The cosine of %f is %.16f\n", xf, resultf);
    printf("The cosine of %Lf is %.16Lf\n", xL, resultL);

    return 0;
}

14.3 运行结果

15. cosh，coshf，coshl

15.1 函数说明

函数声明 函数功能
double cosh(double x); 计算x的双曲余弦（double）
float coshf(float x); 计算x的双曲余弦（float）
long double coshl(long double x); 计算x的双曲余弦（long double）

15.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// Huazie
#include <stdio.h>
#include <math.h>

int main(void)
{
    double x = 1.0;
    double result = cosh(x); // 双曲余弦

    float xf = 1.0f;
    float resultf = coshf(xf);

    long double xL = 1.0;
    long double resultL = coshl(xL);

    printf("The hyperbolic coshine of %lf is %.16lf\n", x, result);
    printf("The hyperbolic coshine of %f is %.16f\n", xf, resultf);
    printf("The hyperbolic coshine of %Lf is %.16Lf\n", xL, resultL);

    return 0;
}

15.3 运行结果

16. creat

16.1 函数说明

函数声明 函数功能
int creat (const char *filename, int mode); 创建一个新文件或重写一个已存在的文件

16.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <sys/stat.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>

int main(void)
{
   int handle;
   char buf[11] = "0123456789";

   handle = creat("temp1.txt", S_IREAD | S_IWRITE);

   printf("Create file successfully");

   /* write 10 bytes to the file */
   write(handle, buf, strlen(buf));

   /* close the file */
   close(handle);
   return 0;
}

16.3 运行结果

17. ctime

17.1 函数说明

函数声明 函数功能
char *ctime(const time_t *time); 把日期和时间转换为字符串

17.2 演示示例

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
#include <time.h>

int main(void)
{
    time_t t;
    time(&t);
    printf("Today's date and time: %s\n", ctime(&t));
    return 0;
}

17.3 运行结果

参考

  1. [API Reference Document]

C语言函数大全--c开头的函数之复数篇

总览

函数声明 函数功能
double cabs (double complex z); 计算复数 z 的绝对值（double）
float cabsf (float complex z); 计算复数 z 的绝对值（float）
long double cabsl (long double complex z); 计算复数 z 的绝对值（long double）
double creal (double complex z); 计算复数z的实部（double）
float crealf (float complex z); 计算复数z的实部（float）
long double creall (long double complex z); 计算复数z的实部（long double）
double cimag (double complex z); 计算复数z的虚部（double）
float cimagf (float complex z); 计算复数z的虚部（float）
long double cimagl (long double complex z); 计算复数z的虚部（long double）
double carg (double complex z); 计算复数z的相位角 （double）
float cargf (float complex z); 计算复数z的相位角（float）
long double cargl (long double complex z); 计算复数z的相位角（long double）
double complex cacos (double complex z); 计算复数z的反余弦 （double complex）
float complex cacosf (float complex z); 计算复数z的反余弦（float complex）
long double complex cacosl (long double complex z); 计算复数z的反余弦（long double complex）
double complex cacosh (double complex z); 计算复数z的反双曲余弦（double complex）
float complex cacoshf (float complex z); 计算复数z的反双曲余弦（float complex）
long double complex cacoshl (long double complex z); 计算复数z的反双曲余弦（long double complex）
double complex casin (double complex z); 计算复数z的反正弦（double complex）
float complex casinf (float complex z); 计算复数z的反正弦（float complex）
long double complex casinl (long double complex z); 计算复数z的反正弦（long double complex）
double complex casinh (double complex z); 计算复数z的反双曲正弦（double complex）
float complex casinhf (float complex z); 计算复数z的反双曲正弦（float complex）
long double complex casinhl (long double complex z); 计算复数z的反双曲正弦（long double complex）
double complex catan (double complex z); 计算复数z的反正切（double complex）
float complex catanf (float complex z); 计算复数z的反正切（float complex）
long double complex catanl (long double complex z); 计算复数z的反正切（long double complex）
double complex catanh (double complex z); 计算复数z的反双曲正切（double complex）
float complex catanhf (float complex z); 计算复数z的反双曲正切（float complex）
long double complex catanhl (long double complex z); 计算复数z的反双曲正切（long double complex）
double complex ccos (double complex z); 计算复数z的余弦（double complex）
float complex ccosf (float complex z); 计算复数z的余弦（float complex）
long double complex ccosl (long double complex z); 计算复数z的余弦（long double complex）
double complex ccosh (double complex z); 计算复数z的双曲余弦（double complex）
float complex ccoshf (float complex z); 计算复数z的双曲余弦（float complex）
long double complex ccoshl (long double complex z); 计算复数z的双曲余弦（long double complex）
double complex csin (double complex z); 计算复数z的正弦（double complex）
float complex csinf (float complex z); 计算复数z的正弦（float complex）
long double complex csinl (long double complex z); 计算复数z的正弦（long double complex）
double complex csinh (double complex z); 计算复数z的双曲正弦（double complex）
float complex csinhf (float complex z); 计算复数z的双曲正弦（float complex）
long double complex csinhl (long double complex z); 计算复数z的双曲正弦（long double complex）
double complex ctan (double complex z); 计算复数z的正切（double complex）
float complex ctanf (float complex z); 计算复数z的正切（float complex）
long double complex ctanl (long double complex z); 计算复数z的正切（long double complex）
double complex ctanh (double complex z); 计算复数z的双曲正切（double complex）
float complex ctanhf (float complex z); 计算复数z的双曲正切（float complex）
long double complex ctanhl (long double complex z); 计算复数z的双曲正切（long double complex）
double complex cexp (double complex z); 计算复数z的指数基数e（double complex）
float complex cexpf (float complex z); 计算复数z的指数基数e（float complex）
long double complex cexpl (long double complex z); 计算复数z的指数基数e（long double complex）
double complex clog (double complex z); 计算复数z的自然对数（以e为底）（double complex）
float complex clogf (float complex z); 计算复数z的自然对数（以e为底）（float complex）
long double complex clogl (long double complex z); 计算复数z的自然对数（以e为底）（long double complex）
double complex conj (double complex z); 计算复数z的共轭（double complex）
float complex conjf (float complex z); 计算复数z的共轭（float complex）
long double complex conjl (long double complex z); 计算复数z的共轭（long double complex）
double complex cpow (double complex x, double complex y); 计算x的y次方值 （double complex）
float complex cpowf (float complex x, float complex y); 计算x的y次方值 （float complex）
long double complex cpowl (long double complex x, long double complex y); 计算x的y次方值 （double complex）
double complex cproj (double complex z); 计算复数z在黎曼球面上的投影（double complex）
float complex cprojf (float complex z); 计算复数z在黎曼球面上的投影（float complex）
long double complex cprojl (long double complex z); 计算复数z在黎曼球面上的投影（long double complex）
double complex csqrt (double complex z); 计算复数z的平方根（double complex）
float complex csqrtf (float complex z); 计算复数z的平方根（float complex）
long double complex csqrtl (long double complex z); 计算复数z的平方根（long double complex）

1. cabs，cabsf，cabsl

1.1 函数说明

函数声明 函数功能
double cabs (double complex z); 计算复数 z 的绝对值（double）
float cabsf (float complex z); 计算复数 z 的绝对值（float）
long double cabsl (long double complex z); 计算复数 z 的绝对值（long double）

1.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// Huazie
#include <stdio.h>
#include <complex.h>

int main(void)
{
    double complex z;
    double x = 2.0, y = 2.0, val;
    z = x + y * I; // I 代指 虚数单位 i
    val = cabs(z); // 计算复数 z 的绝对值

    float complex zf;
    float xf = 2.0, yf = 2.0, valf;
    zf = xf + yf * I;
    valf = cabsf(zf);

    long double complex zL;
    long double xL = 2.0, yL = 2.0, valL;
    zL = xL + yL * I;
    valL = cabsl(zL);
    
    printf("The absolute value of (%.4lf + %.4lfi) is %.20lf\n", x, y, val);
    printf("The absolute value of (%.4f + %.4fi) is %.20f\n", xf, yf, valf);
    printf("The absolute value of (%.4Lf + %.4Lfi) is %.20Lf", xL, yL, valL);

    return 0;
}

1.3 运行结果

2. creal，crealf，creall

2.1 函数说明

函数声明 函数功能
double creal (double complex z); 计算复数z的实部（double）
float crealf (float complex z); 计算复数z的实部（float）
long double creall (long double complex z); 计算复数z的实部（long double）

2.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// Huazie
#include <stdio.h>
#include <complex.h>

int main(void)
{
    double complex z;
    double x = 2.0, y = 1.0;
    z = x + y * I; // I 代指 虚数单位 i

    float complex zf;
    float xf = 3.0, yf = 1.0;
    zf = xf + yf * I;

    long double complex zL;
    long double xL = 4.0, yL = 1.0;
    zL = xL + yL * I;

    printf("The real part of (%.4lf + %.4lfi) is %.4lf\n", x, y, creal(z));
    printf("The real part of (%.4f + %.4fi) is %.4f\n", xf, yf, crealf(zf));
    printf("The real part of (%.4Lf + %.4Lfi) is %.4Lf", xL, yL, creall(zL));

    return 0;
}

2.3 运行结果

3. cimag，cimagf，cimagl

3.1 函数说明

函数声明 函数功能
double cimag (double complex z); 计算复数z的虚部（double）
float cimagf (float complex z); 计算复数z的虚部（float）
long double cimagl (long double complex z); 计算复数z的虚部（long double）

3.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// Huazie
#include <stdio.h>
#include <complex.h>

int main(void)
{
    double complex z;
    double x = 1.0, y = 2.0;
    z = x + y * I; // I 代指 虚数单位 i

    float complex zf;
    float xf = 1.0, yf = 3.0;
    zf = xf + yf * I;

    long double complex zL;
    long double xL = 1.0, yL = 4.0;
    zL = xL + yL * I;

    printf("The imaginary part of (%.4lf + %.4lfi) is %.4lf\n", x, y, cimag(z));
    printf("The imaginary part of (%.4f + %.4fi) is %.4f\n", xf, yf, cimagf(zf));
    printf("The imaginary part of (%.4Lf + %.4Lfi) is %.4Lf", xL, yL, cimagl(zL));

    return 0;
}

3.3 运行结果

4. carg，cargf，cargl

4.1 函数说明

函数声明 函数功能
double carg (double complex z); 计算复数z的相位角 （double）
float cargf (float complex z); 计算复数z的相位角（float）
long double cargl (long double complex z); 计算复数z的相位角（long double）

相位角是描述波形在时间轴上的位置的一个重要参数，它决定了波形的起始位置和变化状态。在实际应用中，相位角的测量和控制对于电路设计和信号处理至关重要。通过对相位角的理解和应用，可以更好地分析和控制波动现象，从而实现对电力系统和通信系统的优化。

4.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
#include <complex.h>

int main(void)
{
    double complex z;
    z = 1.0 + 2.0 * I; // I 代指 虚数单位 i

    float complex zf;
    zf = 1.0f + 2.0f * I;

    long double complex zL;
    zL = (long double) 1.0 + (long double) 2.0 * I;

    printf("The phase angle of (%.4lf + %.4lfi) is %.60lf\n", creal(z), cimag(z), carg(z));
    printf("The phase angle of (%.4f + %.4fi) is %.60f\n", crealf(zf), cimagf(zf), cargf(zf));
    printf("The phase angle of (%.4Lf + %.4Lfi) is %.60Lf", creall(zL), cimagl(zL), cargl(zL));

    return 0;
}

4.3 运行结果

5. cacos，cacosf，cacosl

5.1 函数说明

函数声明 函数功能
double complex cacos (double complex z); 计算复数z的反余弦 （double complex）
float complex cacosf (float complex z); 计算复数z的反余弦（float complex）
long double complex cacosl (long double complex z); 计算复数z的反余弦（long double complex）

5.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <stdio.h>
#include <math.h>
#include <complex.h>

int main(void)
{
    double complex z, zcacos;
    z = 1.0 + 2.0 * I; // I 代指 虚数单位 i
    zcacos = cacos(z); // 计算复数z的反余弦

    float complex zf, zcacosf;
    zf = 1.0f + 2.0f * I;
    zcacosf = cacosf(zf);

    long double complex zL, zcacosl;
    zL = (long double) 1.0 + (long double) 2.0 * I;
    zcacosl = cacosl(zL);

    double zimag = cimag(zcacos);
    float zimagf = cimagf(zcacosf);
    long double zimagl = cimagl(zcacosl);
    if (zimag < 0) 
        printf("The arc cosine of (%.4lf + %.4lfi) is (%.20lf - %.20lfi)\n", creal(z), cimag(z), creal(zcacos), fabs(zimag));
    else 
        printf("The arc cosine of (%.4lf + %.4lfi) is (%.20lf + %.20lfi)\n", creal(z), cimag(z), creal(zcacos), zimag);       

    if (zimagf < 0) 
        printf("The arc cosine of (%.4f + %.4fi) is (%.20f - %.20fi)\n", crealf(zf), cimagf(zf), crealf(zcacosf), fabsf(zimagf));
    else 
        printf("The arc cosine of (%.4f + %.4fi) is (%.20f + %.20fi)\n", crealf(zf), cimagf(zf), crealf(zcacosf), zimagf);

    if (zimagl < 0) 
        printf("The arc cosine of (%.4Lf + %.4Lfi) is (%.20Lf - %.20Lfi)", creall(zL), cimagl(zL), creall(zcacosl), fabsl(zimagl));
    else 
        printf("The arc cosine of (%.4Lf + %.4Lfi) is (%.20Lf + %.20Lfi)", creall(zL), cimagl(zL), creall(zcacosl), zimagl);
    return 0;
}

5.3 运行结果

6. cacosh，cacoshf，cacoshl

6.1 函数说明

函数声明 函数功能
double complex cacosh (double complex z); 计算复数z的反双曲余弦（double complex）
float complex cacoshf (float complex z); 计算复数z的反双曲余弦（float complex）
long double complex cacoshl (long double complex z); 计算复数z的反双曲余弦（long double complex）

6.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <stdio.h>
#include <math.h>
#include <complex.h>

int main(void)
{
    double complex z, zcacosh;
    z = 1.0 + 2.0 * I; // I 代指 虚数单位 i
    zcacosh = cacosh(z); // 反双曲余弦

    float complex zf, zcacoshf;
    zf = 1.0f + 2.0f * I;
    zcacoshf = cacoshf(zf);

    long double complex zL, zcacoshl;
    zL = (long double) 1.0 + (long double) 2.0 * I;
    zcacoshl = cacoshl(zL);

    double zimag = cimag(zcacosh);
    float zimagf = cimagf(zcacoshf);
    long double zimagl = cimagl(zcacoshl);
    if (zimag < 0) 
        printf("The inverse hyperbolic cosine of (%.4lf + %.4lfi) is (%.20lf - %.20lfi)\n", creal(z), cimag(z), creal(zcacosh), fabs(zimag));
    else 
        printf("The inverse hyperbolic cosine of (%.4lf + %.4lfi) is (%.20lf + %.20lfi)\n", creal(z), cimag(z), creal(zcacosh), zimag);       

    if (zimagf < 0) 
        printf("The inverse hyperbolic cosine of (%.4f + %.4fi) is (%.20f - %.20fi)\n", crealf(zf), cimagf(zf), crealf(zcacoshf), fabsf(zimagf));
    else 
        printf("The inverse hyperbolic cosine of (%.4f + %.4fi) is (%.20f + %.20fi)\n", crealf(zf), cimagf(zf), crealf(zcacoshf), zimagf);

    if (zimagl < 0) 
        printf("The inverse hyperbolic cosine of (%.4Lf + %.4Lfi) is (%.20Lf - %.20Lfi)", creall(zL), cimagl(zL), creall(zcacoshl), fabsl(zimagl));
    else 
        printf("The inverse hyperbolic cosine of (%.4Lf + %.4Lfi) is (%.20Lf + %.20Lfi)", creall(zL), cimagl(zL), creall(zcacoshl), zimagl);
    return 0;
}

6.3 运行结果

7. casin，casinf，casinl

7.1 函数说明

函数声明 函数功能
double complex casin (double complex z); 计算复数z的反正弦（double complex）
float complex casinf (float complex z); 计算复数z的反正弦（float complex）
long double complex casinl (long double complex z); 计算复数z的反正弦（long double complex）

7.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <stdio.h>
#include <math.h>
#include <complex.h>

int main(void)
{
    double complex z, zcasin;
    z = 1.0 + 2.0 * I; // I 代指 虚数单位 i
    zcasin = casin(z); // 反正弦

    float complex zf, zcasinf;
    zf = 1.0f + 2.0f * I;
    zcasinf = casinf(zf);

    long double complex zL, zcasinl;
    zL = (long double) 1.0 + (long double) 2.0 * I;
    zcasinl = casinl(zL);

    double zimag = cimag(zcasin);
    float zimagf = cimagf(zcasinf);
    long double zimagl = cimagl(zcasinl);
    if (zimag < 0) 
        printf("The arcsine of (%.4lf + %.4lfi) is (%.20lf - %.20lfi)\n", creal(z), cimag(z), creal(zcasin), fabs(zimag));
    else 
        printf("The arcsine of (%.4lf + %.4lfi) is (%.20lf + %.20lfi)\n", creal(z), cimag(z), creal(zcasin), zimag);       

    if (zimagf < 0) 
        printf("The arcsine of (%.4f + %.4fi) is (%.20f - %.20fi)\n", crealf(zf), cimagf(zf), crealf(zcasinf), fabsf(zimagf));
    else 
        printf("The arcsine of (%.4f + %.4fi) is (%.20f + %.20fi)\n", crealf(zf), cimagf(zf), crealf(zcasinf), zimagf);

    if (zimagl < 0) 
        printf("The arcsine of (%.4Lf + %.4Lfi) is (%.20Lf - %.20Lfi)", creall(zL), cimagl(zL), creall(zcasinl), fabsl(zimagl));
    else 
        printf("The arcsine of (%.4Lf + %.4Lfi) is (%.20Lf + %.20Lfi)", creall(zL), cimagl(zL), creall(zcasinl), zimagl);
    return 0;
}

7.3 运行结果

8. casinh，casinhf，casinhl

8.1 函数说明

函数声明 函数功能
double complex casinh (double complex z); 计算复数z的反双曲正弦（double complex）
float complex casinhf (float complex z); 计算复数z的反双曲正弦（float complex）
long double complex casinhl (long double complex z); 计算复数z的反双曲正弦（long double complex）

8.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <stdio.h>
#include <math.h>
#include <complex.h>

int main(void)
{
    double complex z, zcasinh;
    z = 1.0 + 2.0 * I; // I 代指 虚数单位 i
    zcasinh = casinh(z); // 反双曲正弦

    float complex zf, zcasinhf;
    zf = 1.0f + 2.0f * I;
    zcasinhf = casinhf(zf);

    long double complex zL, zcasinhl;
    zL = (long double) 1.0 + (long double) 2.0 * I;
    zcasinhl = casinhl(zL);

    double zimag = cimag(zcasinh);
    float zimagf = cimagf(zcasinhf);
    long double zimagl = cimagl(zcasinhl);
    if (zimag < 0) 
        printf("The inverse hyperbolic sine of (%.4lf + %.4lfi) is (%.20lf - %.20lfi)\n", creal(z), cimag(z), creal(zcasinh), fabs(zimag));
    else 
        printf("The inverse hyperbolic sine of (%.4lf + %.4lfi) is (%.20lf + %.20lfi)\n", creal(z), cimag(z), creal(zcasinh), zimag);       

    if (zimagf < 0) 
        printf("The inverse hyperbolic sine of (%.4f + %.4fi) is (%.20f - %.20fi)\n", crealf(zf), cimagf(zf), crealf(zcasinhf), fabsf(zimagf));
    else 
        printf("The inverse hyperbolic sine of (%.4f + %.4fi) is (%.20f + %.20fi)\n", crealf(zf), cimagf(zf), crealf(zcasinhf), zimagf);

    if (zimagl < 0) 
        printf("The inverse hyperbolic sine of (%.4Lf + %.4Lfi) is (%.20Lf - %.20Lfi)", creall(zL), cimagl(zL), creall(zcasinhl), fabsl(zimagl));
    else 
        printf("The inverse hyperbolic sine of (%.4Lf + %.4Lfi) is (%.20Lf + %.20Lfi)", creall(zL), cimagl(zL), creall(zcasinhl), zimagl);
    return 0;
}

8.3 运行结果

9. catan，catanf，catanl

9.1 函数说明

函数声明 函数功能
double complex catan (double complex z); 计算复数z的反正切（double complex）
float complex catanf (float complex z); 计算复数z的反正切（float complex）
long double complex catanl (long double complex z); 计算复数z的反正切（long double complex）

9.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <stdio.h>
#include <math.h>
#include <complex.h>

int main(void)
{
    double complex z, zcatan;
    z = 1.0 + 2.0 * I; // I 代指 虚数单位 i
    zcatan = catan(z); // 反正切

    float complex zf, zcatanf;
    zf = 1.0f + 2.0f * I;
    zcatanf = catanf(zf);

    long double complex zL, zcatanl;
    zL = (long double) 1.0 + (long double) 2.0 * I;
    zcatanl = catanl(zL);

    double zimag = cimag(zcatan);
    float zimagf = cimagf(zcatanf);
    long double zimagl = cimagl(zcatanl);
    if (zimag < 0) 
        printf("The arc tangent of (%.4lf + %.4lfi) is (%.20lf - %.20lfi)\n", creal(z), cimag(z), creal(zcatan), fabs(zimag));
    else 
        printf("The arc tangent of (%.4lf + %.4lfi) is (%.20lf + %.20lfi)\n", creal(z), cimag(z), creal(zcatan), zimag);       

    if (zimagf < 0) 
        printf("The arc tangent of (%.4f + %.4fi) is (%.20f - %.20fi)\n", crealf(zf), cimagf(zf), crealf(zcatanf), fabsf(zimagf));
    else 
        printf("The arc tangent of (%.4f + %.4fi) is (%.20f + %.20fi)\n", crealf(zf), cimagf(zf), crealf(zcatanf), zimagf);

    if (zimagl < 0) 
        printf("The arc tangent of (%.4Lf + %.4Lfi) is (%.20Lf - %.20Lfi)", creall(zL), cimagl(zL), creall(zcatanl), fabsl(zimagl));
    else 
        printf("The arc tangent of (%.4Lf + %.4Lfi) is (%.20Lf + %.20Lfi)", creall(zL), cimagl(zL), creall(zcatanl), zimagl);
    return 0;
}

9.3 运行结果

10. catanh，catanhf，catanhl

10.1 函数说明

函数声明 函数功能
double complex catanh (double complex z); 计算复数z的反双曲正切（double complex）
float complex catanhf (float complex z); 计算复数z的反双曲正切（float complex）
long double complex catanhl (long double complex z); 计算复数z的反双曲正切（long double complex）

10.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <stdio.h>
#include <math.h>
#include <complex.h>

int main(void)
{
    double complex z, zcatanh;
    z = 1.0 + 2.0 * I; // I 代指 虚数单位 i
    zcatanh = catanh(z); // 反双曲正切

    float complex zf, zcatanhf;
    zf = 1.0f + 2.0f * I;
    zcatanhf = catanhf(zf);

    long double complex zL, zcatanhl;
    zL = (long double) 1.0 + (long double) 2.0 * I;
    zcatanhl = catanhl(zL);

    double zimag = cimag(zcatanh);
    float zimagf = cimagf(zcatanhf);
    long double zimagl = cimagl(zcatanhl);
    if (zimag < 0) 
        printf("The inverse hyperbolic tangent of (%.4lf + %.4lfi) is (%.20lf - %.20lfi)\n", creal(z), cimag(z), creal(zcatanh), fabs(zimag));
    else 
        printf("The inverse hyperbolic tangent of (%.4lf + %.4lfi) is (%.20lf + %.20lfi)\n", creal(z), cimag(z), creal(zcatanh), zimag);       

    if (zimagf < 0) 
        printf("The inverse hyperbolic tangent of (%.4f + %.4fi) is (%.20f - %.20fi)\n", crealf(zf), cimagf(zf), crealf(zcatanhf), fabsf(zimagf));
    else 
        printf("The inverse hyperbolic tangent of (%.4f + %.4fi) is (%.20f + %.20fi)\n", crealf(zf), cimagf(zf), crealf(zcatanhf), zimagf);

    if (zimagl < 0) 
        printf("The inverse hyperbolic tangent of (%.4Lf + %.4Lfi) is (%.20Lf - %.20Lfi)", creall(zL), cimagl(zL), creall(zcatanhl), fabsl(zimagl));
    else 
        printf("The inverse hyperbolic tangent of (%.4Lf + %.4Lfi) is (%.20Lf + %.20Lfi)", creall(zL), cimagl(zL), creall(zcatanhl), zimagl);
    return 0;
}

10.3 运行结果

11. ccos，ccosf，ccosl

11.1 函数说明

函数声明 函数功能
double complex ccos (double complex z); 计算复数z的余弦（double complex）
float complex ccosf (float complex z); 计算复数z的余弦（float complex）
long double complex ccosl (long double complex z); 计算复数z的余弦（long double complex）

11.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <stdio.h>
#include <math.h>
#include <complex.h>

int main(void)
{
    double complex z, zccos;
    z = 1.0 + 2.0 * I; // I 代指 虚数单位 i
    zccos = ccos(z); // 余弦

    float complex zf, zccosf;
    zf = 1.0f + 2.0f * I;
    zccosf = ccosf(zf);

    long double complex zL, zccosl;
    zL = (long double) 1.0 + (long double) 2.0 * I;
    zccosl = ccosl(zL);

    double zimag = cimag(zccos);
    float zimagf = cimagf(zccosf);
    long double zimagl = cimagl(zccosl);
    if (zimag < 0) 
        printf("The cosine of (%.4lf + %.4lfi) is (%.20lf - %.20lfi)\n", creal(z), cimag(z), creal(zccos), fabs(zimag));
    else 
        printf("The cosine of (%.4lf + %.4lfi) is (%.20lf + %.20lfi)\n", creal(z), cimag(z), creal(zccos), zimag);       

    if (zimagf < 0) 
        printf("The cosine of (%.4f + %.4fi) is (%.20f - %.20fi)\n", crealf(zf), cimagf(zf), crealf(zccosf), fabsf(zimagf));
    else 
        printf("The cosine of (%.4f + %.4fi) is (%.20f + %.20fi)\n", crealf(zf), cimagf(zf), crealf(zccosf), zimagf);

    if (zimagl < 0) 
        printf("The cosine of (%.4Lf + %.4Lfi) is (%.20Lf - %.20Lfi)", creall(zL), cimagl(zL), creall(zccosl), fabsl(zimagl));
    else 
        printf("The cosine of (%.4Lf + %.4Lfi) is (%.20Lf + %.20Lfi)", creall(zL), cimagl(zL), creall(zccosl), zimagl);
    return 0;
}

11.3 运行结果

12. ccosh，ccoshf，ccoshl

12.1 函数说明

函数声明 函数功能
double complex ccosh (double complex z); 计算复数z的双曲余弦（double complex）
float complex ccoshf (float complex z); 计算复数z的双曲余弦（float complex）
long double complex ccoshl (long double complex z); 计算复数z的双曲余弦（long double complex）

12.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <stdio.h>
#include <math.h>
#include <complex.h>

int main(void)
{
    double complex z, zccosh;
    z = 1.0 + 2.0 * I; // I 代指 虚数单位 i
    zccosh = ccosh(z); // 双曲余弦

    float complex zf, zccoshf;
    zf = 1.0f + 2.0f * I;
    zccoshf = ccoshf(zf);

    long double complex zL, zccoshl;
    zL = (long double) 1.0 + (long double) 2.0 * I;
    zccoshl = ccoshl(zL);

    double zimag = cimag(zccosh);
    float zimagf = cimagf(zccoshf);
    long double zimagl = cimagl(zccoshl);
    if (zimag < 0) 
        printf("The hyperbolic cosine of (%.4lf + %.4lfi) is (%.20lf - %.20lfi)\n", creal(z), cimag(z), creal(zccosh), fabs(zimag));
    else 
        printf("The hyperbolic cosine of (%.4lf + %.4lfi) is (%.20lf + %.20lfi)\n", creal(z), cimag(z), creal(zccosh), zimag);       

    if (zimagf < 0) 
        printf("The hyperbolic cosine of (%.4f + %.4fi) is (%.20f - %.20fi)\n", crealf(zf), cimagf(zf), crealf(zccoshf), fabsf(zimagf));
    else 
        printf("The hyperbolic cosine of (%.4f + %.4fi) is (%.20f + %.20fi)\n", crealf(zf), cimagf(zf), crealf(zccoshf), zimagf);

    if (zimagl < 0) 
        printf("The hyperbolic cosine of (%.4Lf + %.4Lfi) is (%.20Lf - %.20Lfi)", creall(zL), cimagl(zL), creall(zccoshl), fabsl(zimagl));
    else 
        printf("The hyperbolic cosine of (%.4Lf + %.4Lfi) is (%.20Lf + %.20Lfi)", creall(zL), cimagl(zL), creall(zccoshl), zimagl);
    return 0;
}

12.3 运行结果

13. csin，csinf，csinl

13.1 函数说明

函数声明 函数功能
double complex csin (double complex z); 计算复数z的正弦（double complex）
float complex csinf (float complex z); 计算复数z的正弦（float complex）
long double complex csinl (long double complex z); 计算复数z的正弦（long double complex）

13.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <stdio.h>
#include <math.h>
#include <complex.h>

int main(void)
{
    double complex z, zcsin;
    z = 1.0 + 2.0 * I; // I 代指 虚数单位 i
    zcsin = csin(z); // 正弦

    float complex zf, zcsinf;
    zf = 1.0f + 2.0f * I;
    zcsinf = csinf(zf);

    long double complex zL, zcsinl;
    zL = (long double) 1.0 + (long double) 2.0 * I;
    zcsinl = csinl(zL);

    double zimag = cimag(zcsin);
    float zimagf = cimagf(zcsinf);
    long double zimagl = cimagl(zcsinl);
    if (zimag < 0) 
        printf("The sine of (%.4lf + %.4lfi) is (%.20lf - %.20lfi)\n", creal(z), cimag(z), creal(zcsin), fabs(zimag));
    else 
        printf("The sine of (%.4lf + %.4lfi) is (%.20lf + %.20lfi)\n", creal(z), cimag(z), creal(zcsin), zimag);       

    if (zimagf < 0) 
        printf("The sine of (%.4f + %.4fi) is (%.20f - %.20fi)\n", crealf(zf), cimagf(zf), crealf(zcsinf), fabsf(zimagf));
    else 
        printf("The sine of (%.4f + %.4fi) is (%.20f + %.20fi)\n", crealf(zf), cimagf(zf), crealf(zcsinf), zimagf);

    if (zimagl < 0) 
        printf("The sine of (%.4Lf + %.4Lfi) is (%.20Lf - %.20Lfi)", creall(zL), cimagl(zL), creall(zcsinl), fabsl(zimagl));
    else 
        printf("The sine of (%.4Lf + %.4Lfi) is (%.20Lf + %.20Lfi)", creall(zL), cimagl(zL), creall(zcsinl), zimagl);
    return 0;
}

13.3 运行结果

14. csinh，csinhf，csinhl

14.1 函数说明

函数声明 函数功能
double complex csinh (double complex z); 计算复数z的双曲正弦（double complex）
float complex csinhf (float complex z); 计算复数z的双曲正弦（float complex）
long double complex csinhl (long double complex z); 计算复数z的双曲正弦（long double complex）

14.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <stdio.h>
#include <math.h>
#include <complex.h>

int main(void)
{
    double complex z, zcsinh;
    z = 1.0 + 2.0 * I; // I 代指 虚数单位 i
    zcsinh = csinh(z); // 双曲正弦

    float complex zf, zcsinhf;
    zf = 1.0f + 2.0f * I;
    zcsinhf = csinhf(zf);

    long double complex zL, zcsinhl;
    zL = (long double) 1.0 + (long double) 2.0 * I;
    zcsinhl = csinhl(zL);

    double zimag = cimag(zcsinh);
    float zimagf = cimagf(zcsinhf);
    long double zimagl = cimagl(zcsinhl);
    if (zimag < 0) 
        printf("The hyperbolic sine of (%.4lf + %.4lfi) is (%.20lf - %.20lfi)\n", creal(z), cimag(z), creal(zcsinh), fabs(zimag));
    else 
        printf("The hyperbolic sine of (%.4lf + %.4lfi) is (%.20lf + %.20lfi)\n", creal(z), cimag(z), creal(zcsinh), zimag);       

    if (zimagf < 0) 
        printf("The hyperbolic sine of (%.4f + %.4fi) is (%.20f - %.20fi)\n", crealf(zf), cimagf(zf), crealf(zcsinhf), fabsf(zimagf));
    else 
        printf("The hyperbolic sine of (%.4f + %.4fi) is (%.20f + %.20fi)\n", crealf(zf), cimagf(zf), crealf(zcsinhf), zimagf);

    if (zimagl < 0) 
        printf("The hyperbolic sine of (%.4Lf + %.4Lfi) is (%.20Lf - %.20Lfi)", creall(zL), cimagl(zL), creall(zcsinhl), fabsl(zimagl));
    else 
        printf("The hyperbolic sine of (%.4Lf + %.4Lfi) is (%.20Lf + %.20Lfi)", creall(zL), cimagl(zL), creall(zcsinhl), zimagl);
    return 0;
}

14.3 运行结果

15. ctan，ctanf，ctanl

15.1 函数说明

函数声明 函数功能
double complex ctan (double complex z); 计算复数z的正切（double complex）
float complex ctanf (float complex z); 计算复数z的正切（float complex）
long double complex ctanl (long double complex z); 计算复数z的正切（long double complex）

15.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <stdio.h>
#include <math.h>
#include <complex.h>

int main(void)
{
    double complex z, zctan;
    z = 1.0 + 2.0 * I; // I 代指 虚数单位 i
    zctan = ctan(z); // 正切

    float complex zf, zctanf;
    zf = 1.0f + 2.0f * I;
    zctanf = ctanf(zf);

    long double complex zL, zctanl;
    zL = (long double) 1.0 + (long double) 2.0 * I;
    zctanl = ctanl(zL);

    double zimag = cimag(zctan);
    float zimagf = cimagf(zctanf);
    long double zimagl = cimagl(zctanl);
    if (zimag < 0) 
        printf("The tangent of (%.4lf + %.4lfi) is (%.20lf - %.20lfi)\n", creal(z), cimag(z), creal(zctan), fabs(zimag));
    else 
        printf("The tangent of (%.4lf + %.4lfi) is (%.20lf + %.20lfi)\n", creal(z), cimag(z), creal(zctan), zimag);       

    if (zimagf < 0) 
        printf("The tangent of (%.4f + %.4fi) is (%.20f - %.20fi)\n", crealf(zf), cimagf(zf), crealf(zctanf), fabsf(zimagf));
    else 
        printf("The tangent of (%.4f + %.4fi) is (%.20f + %.20fi)\n", crealf(zf), cimagf(zf), crealf(zctanf), zimagf);

    if (zimagl < 0) 
        printf("The tangent of (%.4Lf + %.4Lfi) is (%.20Lf - %.20Lfi)", creall(zL), cimagl(zL), creall(zctanl), fabsl(zimagl));
    else 
        printf("The tangent of (%.4Lf + %.4Lfi) is (%.20Lf + %.20Lfi)", creall(zL), cimagl(zL), creall(zctanl), zimagl);
    return 0;
}

15.3 运行结果

16. ctanh，ctanhf，ctanhl

16.1 函数说明

函数声明 函数功能
double complex ctanh (double complex z); 计算复数z的双曲正切（double complex）
float complex ctanhf (float complex z); 计算复数z的双曲正切（float complex）
long double complex ctanhl (long double complex z); 计算复数z的双曲正切（long double complex）

16.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <stdio.h>
#include <math.h>
#include <complex.h>

int main(void)
{
    double complex z, zctanh;
    z = 1.0 + 2.0 * I; // I 代指 虚数单位 i
    zctanh = ctanh(z); // 双曲正切

    float complex zf, zctanhf;
    zf = 1.0f + 2.0f * I;
    zctanhf = ctanhf(zf);

    long double complex zL, zctanhl;
    zL = (long double) 1.0 + (long double) 2.0 * I;
    zctanhl = ctanhl(zL);

    double zimag = cimag(zctanh);
    float zimagf = cimagf(zctanhf);
    long double zimagl = cimagl(zctanhl);
    if (zimag < 0) 
        printf("The inverse hyperbolic tangent of (%.4lf + %.4lfi) is (%.20lf - %.20lfi)\n", creal(z), cimag(z), creal(zctanh), fabs(zimag));
    else 
        printf("The inverse hyperbolic tangent of (%.4lf + %.4lfi) is (%.20lf + %.20lfi)\n", creal(z), cimag(z), creal(zctanh), zimag);       

    if (zimagf < 0) 
        printf("The inverse hyperbolic tangent of (%.4f + %.4fi) is (%.20f - %.20fi)\n", crealf(zf), cimagf(zf), crealf(zctanhf), fabsf(zimagf));
    else 
        printf("The inverse hyperbolic tangent of (%.4f + %.4fi) is (%.20f + %.20fi)\n", crealf(zf), cimagf(zf), crealf(zctanhf), zimagf);

    if (zimagl < 0) 
        printf("The inverse hyperbolic tangent of (%.4Lf + %.4Lfi) is (%.20Lf - %.20Lfi)", creall(zL), cimagl(zL), creall(zctanhl), fabsl(zimagl));
    else 
        printf("The inverse hyperbolic tangent of (%.4Lf + %.4Lfi) is (%.20Lf + %.20Lfi)", creall(zL), cimagl(zL), creall(zctanhl), zimagl);
    return 0;
}

16.3 运行结果

17. cexp，cexpf，cexpl

17.1 函数说明

函数声明 函数功能
double complex cexp (double complex z); 计算复数z的指数基数e（double complex）
float complex cexpf (float complex z); 计算复数z的指数基数e（float complex）
long double complex cexpl (long double complex z); 计算复数z的指数基数e（long double complex）

17.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <stdio.h>
#include <math.h>
#include <complex.h>

int main(void)
{
    double complex z, zcexp;
    z = 1.0 + 2.0 * I; // I 代指 虚数单位 i
    zcexp = cexp(z); // 指数基数e

    float complex zf, zcexpf;
    zf = 1.0f + 2.0f * I;
    zcexpf = cexpf(zf);

    long double complex zL, zcexpl;
    zL = (long double) 1.0 + (long double) 2.0 * I;
    zcexpl = cexpl(zL);

    double zimag = cimag(zcexp);
    float zimagf = cimagf(zcexpf);
    long double zimagl = cimagl(zcexpl);
    if (zimag < 0) 
        printf("The base-e exponential of (%.4lf + %.4lfi) is (%.20lf - %.20lfi)\n", creal(z), cimag(z), creal(zcexp), fabs(zimag));
    else 
        printf("The base-e exponential of (%.4lf + %.4lfi) is (%.20lf + %.20lfi)\n", creal(z), cimag(z), creal(zcexp), zimag);       

    if (zimagf < 0) 
        printf("The base-e exponential of (%.4f + %.4fi) is (%.20f - %.20fi)\n", crealf(zf), cimagf(zf), crealf(zcexpf), fabsf(zimagf));
    else 
        printf("The base-e exponential of (%.4f + %.4fi) is (%.20f + %.20fi)\n", crealf(zf), cimagf(zf), crealf(zcexpf), zimagf);

    if (zimagl < 0) 
        printf("The base-e exponential of (%.4Lf + %.4Lfi) is (%.20Lf - %.20Lfi)", creall(zL), cimagl(zL), creall(zcexpl), fabsl(zimagl));
    else 
        printf("The base-e exponential of (%.4Lf + %.4Lfi) is (%.20Lf + %.20Lfi)", creall(zL), cimagl(zL), creall(zcexpl), zimagl);
    return 0;
}

17.3 运行结果

18. clog，clogf，clogl

18.1 函数说明

函数声明 函数功能
double complex clog (double complex z); 计算复数z的自然对数（以e为底）（double complex）
float complex clogf (float complex z); 计算复数z的自然对数（以e为底）（float complex）
long double complex clogl (long double complex z); 计算复数z的自然对数（以e为底）（long double complex）

18.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <stdio.h>
#include <math.h>
#include <complex.h>

int main(void)
{
    double complex z, zclog;
    z = 1.0 + 2.0 * I; // I 代指 虚数单位 i
    zclog = clog(z); // 自然对数（以e为底）

    float complex zf, zclogf;
    zf = 1.0f + 2.0f * I;
    zclogf = clogf(zf);

    long double complex zL, zclogl;
    zL = (long double) 1.0 + (long double) 2.0 * I;
    zclogl = clogl(zL);

    double zimag = cimag(zclog);
    float zimagf = cimagf(zclogf);
    long double zimagl = cimagl(zclogl);
    if (zimag < 0) 
        printf("The natural (base-e) logarithm of (%.4lf + %.4lfi) is (%.20lf - %.20lfi)\n", creal(z), cimag(z), creal(zclog), fabs(zimag));
    else 
        printf("The natural (base-e) logarithm of (%.4lf + %.4lfi) is (%.20lf + %.20lfi)\n", creal(z), cimag(z), creal(zclog), zimag);       

    if (zimagf < 0) 
        printf("The natural (base-e) logarithm of (%.4f + %.4fi) is (%.20f - %.20fi)\n", crealf(zf), cimagf(zf), crealf(zclogf), fabsf(zimagf));
    else 
        printf("The natural (base-e) logarithm of (%.4f + %.4fi) is (%.20f + %.20fi)\n", crealf(zf), cimagf(zf), crealf(zclogf), zimagf);

    if (zimagl < 0) 
        printf("The natural (base-e) logarithm of (%.4Lf + %.4Lfi) is (%.20Lf - %.20Lfi)", creall(zL), cimagl(zL), creall(zclogl), fabsl(zimagl));
    else 
        printf("The natural (base-e) logarithm of (%.4Lf + %.4Lfi) is (%.20Lf + %.20Lfi)", creall(zL), cimagl(zL), creall(zclogl), zimagl);
    return 0;
}

18.3 运行结果

19. conj，conjf，conjl

19.1 函数说明

函数声明 函数功能
double complex conj (double complex z); 计算复数z的共轭（double complex）
float complex conjf (float complex z); 计算复数z的共轭（float complex）
long double complex conjl (long double complex z); 计算复数z的共轭（long double complex）

19.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <stdio.h>
#include <math.h>
#include <complex.h>

int main(void)
{
    double complex z, zconj;
    z = 1.0 + 2.0 * I; // I 代指 虚数单位 i
    zconj = conj(z); // 共轭

    float complex zf, zconjf;
    zf = 1.0f + 2.0f * I;
    zconjf = conjf(zf);

    long double complex zL, zconjl;
    zL = (long double) 1.0 + (long double) 2.0 * I;
    zconjl = conjl(zL);

    double zimag = cimag(zconj);
    float zimagf = cimagf(zconjf);
    long double zimagl = cimagl(zconjl);
    if (zimag < 0) 
        printf("The conjugate of (%.4lf + %.4lfi) is (%.4lf - %.4lfi)\n", creal(z), cimag(z), creal(zconj), fabs(zimag));
    else 
        printf("The conjugate of (%.4lf + %.4lfi) is (%.4lf + %.4lfi)\n", creal(z), cimag(z), creal(zconj), zimag);       

    if (zimagf < 0) 
        printf("The conjugate of (%.4f + %.4fi) is (%.4f - %.4fi)\n", crealf(zf), cimagf(zf), crealf(zconjf), fabsf(zimagf));
    else 
        printf("The conjugate of (%.4f + %.4fi) is (%.4f + %.4fi)\n", crealf(zf), cimagf(zf), crealf(zconjf), zimagf);

    if (zimagl < 0) 
        printf("The conjugate of (%.4Lf + %.4Lfi) is (%.4Lf - %.4Lfi)", creall(zL), cimagl(zL), creall(zconjl), fabsl(zimagl));
    else 
        printf("The conjugate of (%.4Lf + %.4Lfi) is (%.4Lf + %.4Lfi)", creall(zL), cimagl(zL), creall(zconjl), zimagl);
    return 0;
}

19.3 运行结果

20. cpow，cpowf，cpowl

20.1 函数说明

函数声明 函数功能
double complex cpow (double complex x, double complex y); 计算x的y次方值 （double complex）
float complex cpowf (float complex x, float complex y); 计算x的y次方值 （float complex）
long double complex cpowl (long double complex x, long double complex y); 计算x的y次方值 （double complex）

20.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#include <stdio.h>
#include <math.h>
#include <complex.h>

int main(void)
{
    double complex x, y, z;
    x = 1.0 + 2.0 * I; // I 代指 虚数单位 i
    y = 2.0 + 1.0 * I; 
    z = cpow(x, y); // x的y次方值

    float complex xf, yf, zf;
    xf = 1.0f + 2.0f * I;
    yf = 2.0f + 1.0f * I; 
    zf = cpowf(xf, yf);

    long double complex xL, yL, zL;
    xL = (long double) 1.0 + (long double) 2.0 * I;
    yL = (long double) 2.0 + (long double) 1.0 * I;
    zL = cpowl(xL, yL);

    double zimag = cimag(z);
    float zimagf = cimagf(zf);
    long double zimagl = cimagl(zL);
    if (zimag < 0) 
        printf("the value of (%.4lf + %.4lfi) raised to the (%.4lf + %.4lfi) power is (%.20lf - %.20lfi)\n", 
            creal(x), cimag(x), creal(y), cimag(y), creal(z), fabs(zimag));
    else 
        printf("the value of (%.4lf + %.4lfi) raised to the (%.4lf + %.4lfi) power is (%.20lf + %.20lfi)\n", 
            creal(x), cimag(x), creal(y), cimag(y), creal(z), zimag);       

    if (zimagf < 0) 
        printf("the value of (%.4f + %.4fi) raised to the (%.4f + %.4fi) power is (%.20f - %.20fi)\n", 
            crealf(xf), cimagf(xf), crealf(yf), cimagf(yf), crealf(zf), fabs(zimagf));
    else 
        printf("the value of (%.4f + %.4fi) raised to the (%.4f + %.4fi) power is (%.20f + %.20fi)\n", 
            crealf(xf), cimagf(xf), crealf(yf), cimagf(yf), crealf(zf), zimagf);
    if (zimagl < 0) 
        printf("the value of (%.4Lf + %.4Lfi) raised to the (%.4Lf + %.4Lfi) power is (%.20Lf - %.20Lfi)\n", 
            creall(xL), cimagl(xL), creall(yL), cimagl(yL), creall(zL), fabs(zimagl));
    else 
        printf("the value of (%.4Lf + %.4Lfi) raised to the (%.4Lf + %.4Lfi) power is (%.20Lf + %.20Lfi)\n", 
            creall(xL), cimagl(xL), creall(yL), cimagl(yL), creall(zL), zimagl);    
    return 0;
}

20.3 运行结果

21. cproj，cprojf，cprojl

21.1 函数说明

函数声明 函数功能
double complex cproj (double complex z); 计算复数z在黎曼球面上的投影（double complex）
float complex cprojf (float complex z); 计算复数z在黎曼球面上的投影（float complex）
long double complex cprojl (long double complex z); 计算复数z在黎曼球面上的投影（long double complex）

黎曼球面上的投影是一种将三维空间中的黎曼球面与二维复平面通过立体投影方式建立一一对应关系的映射。

21.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <stdio.h>
#include <math.h>
#include <complex.h>

int main(void)
{
    double complex z, zcproj;
    z = 1.0 + 2.0 * I; // I 代指 虚数单位 i
    zcproj = cproj(z); // 计算复数z在黎曼球面上的投影

    float complex zf, zcprojf;
    zf = NAN + INFINITY * I;
    zcprojf = cprojf(zf);

    long double complex zL, zcprojl;
    zL = INFINITY + (long double) 3.0 * I; 
    zcprojl = cprojl(zL); // 结果相当于  INFINITY + i*copysign(0.0, cimag(z)).

    double zimag = cimag(zcproj);
    float zimagf = cimagf(zcprojf);
    long double zimagl = cimagl(zcprojl);
    if (zimag < 0) 
        printf("The projection of the (%.4lf + %.4lf i) onto the Riemann sphere is (%.4lf - %.4lf i)\n", creal(z), cimag(z), creal(zcproj), fabs(zimag));
    else 
        printf("The projection of the (%.4lf + %.4lf i) onto the Riemann sphere is (%.4lf + %.4lf i)\n", creal(z), cimag(z), creal(zcproj), zimag);       

    if (zimagf < 0) 
        printf("The projection of the (%.4f + %.4f i) onto the Riemann sphere is (%.4f - %.4f i)\n", crealf(zf), cimagf(zf), crealf(zcprojf), fabsf(zimagf));
    else 
        printf("The projection of the (%.4f + %.4f i) onto the Riemann sphere is (%.4f + %.4f i)\n", crealf(zf), cimagf(zf), crealf(zcprojf), zimagf);

    if (zimagl < 0) 
        printf("The projection of the (%.4Lf + %.4Lf i) onto the Riemann sphere is (%.4Lf - %.4Lf i)", creall(zL), cimagl(zL), creall(zcprojl), fabsl(zimagl));
    else 
        printf("The projection of the (%.4Lf + %.4Lf i) onto the Riemann sphere is (%.4Lf + %.4Lf i)", creall(zL), cimagl(zL), creall(zcprojl), zimagl);
    return 0;
}

21.3 运行结果

22. csqrt，csqrtf，csqrtl

22.1 函数说明

函数声明 函数功能
double complex csqrt (double complex z); 计算复数z的平方根（double complex）
float complex csqrtf (float complex z); 计算复数z的平方根（float complex）
long double complex csqrtl (long double complex z); 计算复数z的平方根（long double complex）

22.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <stdio.h>
#include <math.h>
#include <complex.h>

int main(void)
{
    double complex z, zcsqrt;
    z = 9.0 + 9.0 * I; // I 代指 虚数单位 i
    zcsqrt = csqrt(z); // 平方根

    float complex zf, zcsqrtf;
    zf = 4.0f + 4.0f * I;
    zcsqrtf = csqrtf(zf);

    long double complex zL, zcsqrtl;
    zL = (long double) 16.0 + (long double) 16.0 * I;
    zcsqrtl = csqrtl(zL);

    double zimag = cimag(zcsqrt);
    float zimagf = cimagf(zcsqrtf);
    long double zimagl = cimagl(zcsqrtl);
    if (zimag < 0) 
        printf("The square root of (%.4lf + %.4lfi) is (%.20lf - %.20lfi)\n", creal(z), cimag(z), creal(zcsqrt), fabs(zimag));
    else 
        printf("The square root of (%.4lf + %.4lfi) is (%.20lf + %.20lfi)\n", creal(z), cimag(z), creal(zcsqrt), zimag);       

    if (zimagf < 0) 
        printf("The square root of (%.4f + %.4fi) is (%.20f - %.20fi)\n", crealf(zf), cimagf(zf), crealf(zcsqrtf), fabsf(zimagf));
    else 
        printf("The square root of (%.4f + %.4fi) is (%.20f + %.20fi)\n", crealf(zf), cimagf(zf), crealf(zcsqrtf), zimagf);

    if (zimagl < 0) 
        printf("The square root of (%.4Lf + %.4Lfi) is (%.20Lf - %.20Lfi)", creall(zL), cimagl(zL), creall(zcsqrtl), fabsl(zimagl));
    else 
        printf("The square root of (%.4Lf + %.4Lfi) is (%.20Lf + %.20Lfi)", creall(zL), cimagl(zL), creall(zcsqrtl), zimagl);
    return 0;
}

22.3 运行结果

参考

  1. 【MATH-标准C库】

C语言函数大全--b开头的函数

总览

函数声明 函数功能
void bar(int left, int top, int right, int bottom); 画一个二维条形图
void bar3d(int left, int top, int right, int bottom, int depth, int topflag); 画一个三维条形图
int bdos(int dosfun, unsigned dosdx, unsigned dosal); DOS系统调用
int bdosptr(int dosfun, void *argument, unsigned dosal); DOS系统调用
int bioscom(int cmd, char abyte, int port); 串行I/O通信
int biosdisk(int cmd, int drive, int head, int track, int sector, int nsects, void *buffer); 软硬盘I/O
int bioskey(int cmd); 直接使用BIOS服务的键盘接口
int biosmemory(void); 返回存储块大小，以K为单位
int biosprint(int cmd, int byte, int port); 直接使用BIOS服务的打印机I/O
long biostime(int cmd, long newtime); 读取或设置BIOS时间
int brk(void *endds); 用来改变分配给调用程序的数据段的空间数量
void *bsearch(const void *key, const void *base, size_t *nelem, size_t width, int(*fcmp)(const void *, const *)); 二分法搜索

1. bar

1.1 函数说明

函数声明 函数功能
void bar(int left, int top, int right, int bottom); 画一个二维条形图

关注点： 绘制二维条形图需要左上角和右下角的坐标。 left 指定左上角的 X 坐标，top 指定左上角的 Y 坐标，right 指定右下角的 X 坐标，bottom 指定右下角的 Y 坐标。 当前填充图案和填充颜色用于填充条形图。 要更改填充图案和填充颜色，请使用 setfillstyle。

1.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>

int main(void)
{
    /* request auto detection */
    int gdriver = DETECT, gmode, errorcode;
    int midx, midy, i;

    /* initialize graphics and local variables */
    initgraph(&gdriver, &gmode, "");

    /* read result of initialization */
    errorcode = graphresult();
    if (errorcode != grOk)  /* an error occurred */
    {
        printf("Graphics error: %s\n", grapherrormsg(errorcode));
        printf("Press any key to halt:");
        getch();
        exit(1); /* terminate with an error code */
    }

    midx = getmaxx() / 2;
    midy = getmaxy() / 2;

    /* loop through the fill patterns */
    for (i=SOLID_FILL; i<USER_FILL; i++)
    {
        /* set the fill style */
        setfillstyle(i, getmaxcolor());

        /* draw the bar */
        bar(midx-50, midy-50, midx+50, midy+50);

        getch();
    }

    /* clean up */
    closegraph();
    return 0;
}

1.3 运行结果

2. bar3d

2.1 函数说明

函数声明 函数功能
void bar3d(int left, int top, int right, int bottom, int depth, int topflag); 画一个三维条形图

关注点： 绘制三维条形图需要条形左上角和右下角的坐标。 left 指定左上角的 X 坐标，top 指定左上角的 Y 坐标，right 指定右下角的 X 坐标，bottom 指定右下角的 Y 坐标，depth 指定条的深度 以像素为单位，topflag 确定是否将 3 维顶部放置在条形图上（如果它不为零，则放置否则不放置）。 当前填充图案和填充颜色用于填充条形图。 要更改填充图案和填充颜色，请使用 setfillstyle。

2.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>

int main(void)
{
    /* request auto detection */
    int gdriver = DETECT, gmode, errorcode;
    int midx, midy, i;

    /* initialize graphics, local variables */
    initgraph(&gdriver, &gmode, "");

    /* read result of initialization */
    errorcode = graphresult();
    if (errorcode != grOk)  /* an error occurred */
    {
        printf("Graphics error: %s\n", grapherrormsg(errorcode));
        printf("Press any key to halt:");
        getch();
        exit(1); /* terminate with error code */
    }

    midx = getmaxx() / 2;
    midy = getmaxy() / 2;

    /* loop through the fill patterns */
    for (i=EMPTY_FILL; i<USER_FILL; i++)
    {
        /* set the fill style */
        setfillstyle(i, getmaxcolor());

        /* draw the 3-d bar */
        bar3d(midx-50, midy-50, midx+50, midy+50, 10, 1);

        getch();
    }

    /* clean up */
    closegraph();
    return 0;
}

2.3 运行结果

3. bdos

3.1 函数说明

函数声明 函数功能
int bdos(int dosfun, unsigned dosdx, unsigned dosal); DOS系统调用

参数介绍：

  • int dosfun： 指定了要调用的DOS功能号。功能号决定了bdos函数要执行的具体DOS操作。例如，功能号0x09用于在屏幕上显示字符串，功能号0x3C用于创建或打开文件。
  • unsigned dosdx ： 用于传递额外的参数或数据给DOS功能。具体用途取决于所调用的DOS功能号，例如，在功能号0x09（显示字符串）中，dosdx通常指向包含要显示字符串的内存地址。
  • unsigned dosal ： 用于传递额外的参数或数据给DOS功能。与dosdx一样，它的具体用途取决于所调用的DOS功能号。例如，在文件操作中，dosal 可能用于指定文件的访问模式（如只读、写入等）。

3.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include <dos.h>

/* Get current drive as 'A', 'B', ... */
char current_drive(void)
{
    char curdrive;

    /* Get current disk as 0, 1, ... */
    curdrive = bdos(0x19, 0, 0);
    return('A' + curdrive);
}

int main(void)
{
    printf("The current drive is %c:\n", current_drive());
    return 0;
}

4. bdosptr

4.1 函数说明

函数声明 函数功能
int bdosptr(int dosfun, void *argument, unsigned dosal); DOS系统调用

参数介绍：

  • int dosfun： 指定了要调用的DOS功能号。
  • void *argument ： 一个指向任意类型数据的指针，通常用于传递额外的参数或数据给DOS功能。如果 dosfun 对应的功能是文件读取，那么 argument 可能指向一个包含文件名、文件缓冲区地址、读取字节数等信息的数据结构。
  • unsigned dosal ： 用于提供与 argument 相关的一些辅助信息，比如参数的长度或者其他特定于 dosfun 所调用功能的计数信息。

4.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <string.h>
#include <stdio.h>
#include <dir.h>
#include <dos.h>
#include <errno.h>
#include <stdlib.h>

#define  BUFLEN  80

int main(void)
{
    char  buffer[BUFLEN];
    int   test;

    printf("Enter full pathname of a directory\n");
    gets(buffer);

    test = bdosptr(0x3B,buffer,0);
    if(test)
    {
        printf("DOS error message: %d\n", errno);
        /* See errno.h for error listings */
        exit (1);
    }

    getcwd(buffer, BUFLEN);
    printf("The current directory is: %s\n", buffer);

    return 0;
}

5. bioscom

5.1 函数说明

函数声明 函数功能
int bioscom(int cmd, char abyte, int port); 串行I/O通信

参数介绍：

  • int cmd： 指定了要执行的串行通信命令。常见的命令包括初始化串行端口、发送数据、接收数据、检查接收缓冲区是否有数据等。
  • char abyte ： 用于发送数据时指定要发送的字节。当执行发送数据的命令时，abyte 参数的值将被发送到指定的串行端口。
  • int port ： 指定了要使用的串行端口号。端口号通常是一个介于0到3之间的数字，对应于计算机上的COM1到COM4（或其他更高编号的端口，但这取决于计算机的硬件配置）。

5.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <bios.h>
#include <conio.h>

#define COM1       0
#define DATA_READY 0x100
#define TRUE       1
#define FALSE      0

#define SETTINGS ( 0x80 | 0x02 | 0x00 | 0x00)

int main(void)
{
    int in, out, status, DONE = FALSE;

    bioscom(0, SETTINGS, COM1);
    cprintf("... BIOSCOM [ESC] to exit ...\n");
    while (!DONE)
    {
        status = bioscom(3, 0, COM1);
        if (status & DATA_READY)
            if ((out = bioscom(2, 0, COM1) & 0x7F) != 0)
                putch(out);
        if (kbhit())
        {
            if ((in = getch()) == '\x1B')
                DONE = TRUE;
            bioscom(1, in, COM1);
        }
    }
    return 0;
}

6. biosdisk

6.1 函数说明

函数声明 函数功能
int biosdisk(int cmd, int drive, int head, int track, int sector, int nsects, void *buffer); 软硬盘I/O

参数介绍：

  • int cmd： 要执行的磁盘操作命令。常见的命令包括读取磁盘扇区（通常是0x02）、写入磁盘扇区（通常是0x03）、检查磁盘扇区是否存在（可能是0x08或0x10，具体取决于BIOS版本）等。
  • int drive ： 指定了要访问的磁盘驱动器号。在大多数情况下，驱动器号是通过位移来表示的，其中0x00表示第一个硬盘（通常是C:），0x80表示第一个软盘驱动器（通常是A:），以此类推。
  • int head ： 指定了要访问的磁头号。在传统的磁盘驱动器中，每个磁道（track）都由一个或多个磁头来读写数据。磁头号的范围通常是从0到某个最大值（取决于磁盘的几何结构）。
  • int track ： 指定了要访问的磁道号。磁道号定义了磁盘上的圆周路径，数据就存储在这些路径上。磁道号的范围也是根据磁盘的几何结构来确定的。
  • int sector ： 指定了要访问的扇区号。每个磁道都被划分为多个扇区，每个扇区包含固定数量的字节（通常是512字节）。扇区号的范围取决于每个磁道的扇区数。
  • int nsects ： 指定了要连续读取或写入的扇区数。该参数允许一次性读取或写入多个扇区，从而提高了磁盘操作的效率。
  • void *buffer ： 用于存储读取的数据或提供要写入的数据。缓冲区的大小应该足够容纳指定数量的扇区数据（每个扇区通常是512字节）。在读取操作中，BIOS会将数据从磁盘传输到这个缓冲区中；在写入操作中，BIOS会从这个缓冲区中读取数据并写入到磁盘上。

6.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <bios.h>
#include <stdio.h>

int main(void)
{
    int result;
    char buffer[512];

    printf("Testing to see if drive a: is ready\n");
    result = biosdisk(4,0,0,0,0,1,buffer);
    result &= 0x02;
    (result) ? (printf("Drive A: Ready\n")) : (printf("Drive A: Not Ready\n"));

    return 0;
}

7. bioskey

7.1 函数说明

函数声明 函数功能
int bioskey(int cmd); 直接使用BIOS服务的键盘接口

参数介绍：

  • int cmd： 指定要执行的键盘操作类型。
    • 0： 返回下一个在键盘键入的值【一个16位的二进制数】。函数将等待直到有键按下为止。当按下一个普通键时，低8位数存放该字符的ASCII码，高8位存放该键的扫描码。对于特殊键（如方向键、F1~F12等），低8位为0，高8位字节存放该键的扫描码。
    • 1： 检测是否有键按下。没有键按下时返回0。有键按下时返回按键码（任何按键码都不为0），但此时并不将检测到的按键码从键盘缓冲队列中清除。
    • 2： 返回Shift、Ctrl、Alt、ScrollLock、NumLock、CapsLock、Insert等控制键的状态。各键状态存放在返回值的低8位字节中。某位的值为1时，表示相应的键已被按过或相应的控制功能已打开；某位的值为0时，表示相应的键没被按过或相应的控制功能未打开。

7.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <stdio.h>
#include <bios.h>
#include <ctype.h>

#define RIGHT  0x01
#define LEFT   0x02
#define CTRL   0x04
#define ALT    0x08

int main(void)
{
    int key, modifiers;

    /* function 1 returns 0 until a key is pressed */
    while (bioskey(1) == 0);

    /* function 0 returns the key that is waiting */
    key = bioskey(0);

    /* use function 2 to determine if shift keys were used */
    modifiers = bioskey(2);
    if (modifiers)
    {
        printf("[");
        if (modifiers & RIGHT) printf("RIGHT");
        if (modifiers & LEFT)  printf("LEFT");
        if (modifiers & CTRL)  printf("CTRL");
        if (modifiers & ALT)   printf("ALT");
        printf("]");
    }
    /* print out the character read */
    if (isalnum(key & 0xFF))
        printf("'%c'\n", key);
    else
        printf("%#02x\n", key);
    return 0;
}

8. biosmemory

8.1 函数说明

函数声明 函数功能
int biosmemory(void); 返回存储块大小，以K为单位

8.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>
#include <bios.h>

int main(void)
{
    int memory_size;

    memory_size = biosmemory();  /* returns value up to 640K */
    printf("RAM size = %dK\n",memory_size);
    return 0;
}

9. biosprint

9.1 函数说明

函数声明 函数功能
int biosprint(int cmd, int byte, int port); 直接使用BIOS服务的打印机I/O

参数介绍：

  • int cmd： 指定要执行的打印机操作命令。
    • 0 ：向打印机输出一个字符。此时，byte 参数的值表示要输出的字符的 ASCII 码或汉字的内码。
    • 1 ：初始化打印机。这个命令通常用于设置打印机的初始状态或重置打印机。
    • 2 ：读取打印机的状态。函数返回值将表示当前打印机的状态，具体含义由返回值的位组合决定。
  • int byte ： 当 cmd 为 0 时，byte 参数的值表示要输出到打印机的字符的 ASCII 码或汉字的内码。当 cmd 为 1 或 2 时，byte 参数的值可能不被使用或具有特定的含义（取决于 BIOS 的实现和打印机的类型），但在大多数情况下，可以将其设置为 0 或一个不影响操作的任意值。
  • int port ： 指定打印机并行口的编号。
    • 0 ：LPT1（第一个并行打印端口）
    • 1 ：LPT2（第二个并行打印端口）
    • 2 ：LPT3（第三个并行打印端口）
    • 以此类推，具体取决于计算机的配置和 BIOS 的支持。

返回值：

  • 当 cmd 为 0 或 1 时，函数通常返回一个整数值，表示操作的结果或状态。返回值的具体含义可能因 BIOS 的实现和打印机的类型而异，但通常 0 表示成功，非 0 值表示错误或特定的状态信息。
  • 当 cmd 为 2 时，函数返回一个整数值，该值的低 8 位有效，用于表示当前打印机的状态。例如，0x01 表示设备超时，0x08 表示输入/输出错误，0x40 表示认可，0x80 表示打印机不忙等。

9.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <stdio.h>
#include <conio.h>
#include <bios.h>

int main(void)
{
    #define STATUS  2    /* printer status command */
    #define PORTNUM 0    /* port number for LPT1 */

    int status, abyte=0;

    printf("Please turn off your printer.  Press any key to continue\n");
    getch();
    status = biosprint(STATUS, abyte, PORTNUM);
    if (status & 0x01)
        printf("Device time out.\n");
    if (status & 0x08)
        printf("I/O error.\n");

    if (status & 0x10)
        printf("Selected.\n");
    if (status & 0x20)
        printf("Out of paper.\n");

    if (status & 0x40)
        printf("Acknowledge.\n");
    if (status & 0x80)
        printf("Not busy.\n");

    return 0;
}

10. biostime

10.1 函数说明

函数声明 函数功能
long biostime(int cmd, long newtime); 读取或设置BIOS时间

参数介绍：

  • int cmd： 指定要执行的操作类型。
    • 0 ：读取计时器的当前值。此时，newtime 参数将被忽略，函数将返回从午夜开始（00:00）到当前时刻的计时器值，该值以时钟滴答声为单位。
    • 1 ：设置计时器的新值。此时，newtime 参数的值将被用作新的计时器值。请注意，直接设置计时器值可能会影响系统的正常计时功能，因此应谨慎使用此操作。
  • int newtime ： 当 cmd 为 1 时，newtime 参数指定要设置的计时器新值。计时器值以时钟滴答声为单位。在大多数BIOS中，每秒的时钟滴答声频率约为18.2次（但具体值可能因计算机而异）。当 cmd 为 0 时，newtime 参数的值将被忽略。

10.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include <stdio.h>
#include <bios.h>
#include <time.h>
#include <conio.h>

int main(void)
{
    long bios_time;

    clrscr();
    cprintf("The number of clock ticks since midnight is:\r\n");
    cprintf("The number of seconds since midnight is:\r\n");
    cprintf("The number of minutes since midnight is:\r\n");
    cprintf("The number of hours since midnight is:\r\n");
    cprintf("\r\nPress any key to quit:");
    while(!kbhit())
    {
        bios_time = biostime(0, 0L);

        gotoxy(50, 1);
        cprintf("%lu", bios_time);

        gotoxy(50, 2);
        cprintf("%.4f", bios_time / CLK_TCK);

        gotoxy(50, 3);
        cprintf("%.4f", bios_time / CLK_TCK / 60);

        gotoxy(50, 4);
        cprintf("%.4f", bios_time / CLK_TCK / 3600);
    }
    return 0;
}

11. brk

11.1 函数说明

函数声明 函数功能
int brk(void *endds); 用来改变分配给调用程序的数据段的空间数量

参数介绍：

  • void *endds： 指定新的数据段结束地址。

该函数可以将进程的数据段结束地址移动到该地址处，从而实现动态内存分配。如果传递的地址比当前数据段结束地址高，则数据段会向上扩展（即增加内存空间）；如果传递的地址比当前数据段结束地址低，则数据段会向下收缩（即释放部分内存空间，但需要注意不要释放已在使用的内存，否则可能会导致程序崩溃）。

11.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
#include <alloc.h>

int main(void)
{
    char *ptr;

    printf("Changing allocation with brk()\n");
    ptr = malloc(1);
    printf("Before brk() call: %lu bytes free\n", coreleft());
    brk(ptr+1000);
    printf(" After brk() call: %lu bytes free\n", coreleft());
    return 0;
}

12. bsearch

12.1 函数说明

函数声明 函数功能
void *bsearch(const void *key, const void *base, size_t *nelem, size_t width, int(*fcmp)(const void *, const *)); 二分法搜索

参数介绍：

  • const void *key： 指向要搜索的元素的指针。key 指向的元素必须与 base 指向的数组中的元素具有相同的类型和大小。
  • const void *base ： 指向要搜索的数组的起始地址。数组中的元素必须已经按照某种顺序（通常是升序）排列好。
  • size_t *nelem ： 数组中元素的数量。
  • size_t width： 数组中每个元素的大小（以字节为单位）。
  • int(*fcmp)(const void *, const *) ： 指向比较函数的指针。比较函数的返回值如下：
    • 小于0 ：表示第一个元素小于第二个元素。
    • 等于0 ：表示两个元素相等。
    • 大于0 ：表示第一个元素大于第二个元素。

12.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <stdlib.h>
#include <stdio.h>

#define NELEMS(arr) (sizeof(arr) / sizeof(arr[0]))

int numarray[] = {1, 2, 3, 5, 6, 8, 9, 10, 12, 14};

int numeric (const int *p1, const int *p2)
{
    return(*p1 - *p2);
}

int lookup(int key)
{
    int *itemptr;

    /* The cast of (int(*)(const void *,const void*)) is needed to avoid a type mismatch error at compile time */
    itemptr = (int(*))bsearch(&key, numarray, NELEMS(numarray), sizeof(int), (int(*)(const void *,const void *))numeric);
    return (itemptr != NULL);
}

int main(void)
{
    int a;
    printf("Please input key: ");
    scanf("%d", &a);
    if (lookup(a))
        printf("%d is in the table.\n", a);
    else
        printf("%d isn't in the table.\n", a);
    return 0;
}

12.3 运行结果


参考

  1. [API Reference Document]
  2. [c语言中的 bar 函数]
  3. [c语言中的 bar3d 函数]

C语言函数大全--a开头的函数

总览

函数声明 函数功能
void abort(void); 异常终止一个进程
int abs(int i); 求整数的绝对值
int absread(int drive, int nsects, int sectno, void *buffer); 从drive指定的驱动器磁盘上，sectno指定的逻辑扇区号开始读取nsects个(最多64K个)扇区的内容，储存于buffer所指的缓冲区中。
int abswrite(int drive, int nsects, int sectno, void *buffer); 将指定内容写入磁盘上的指定扇区
int access(const char *filename, int amode); 确定文件的访问权限
double acos(double x); 反余弦函数
int allocmem(unsigned size, unsigned *seg); 分配DOS存储段
void arc(int x, int y, int stangle, int endangle, int radius); 画一弧线
char *asctime(const struct tm *tblock); 转换日期和时间为ASCII码
double asin(double x); 反正弦函数
void assert(int test); 测试一个条件并可能使程序终止
double atan(double x); 反正切函数
double atan2(double y, double x); 计算Y/X的反正切值
int atexit(atexit_t func); 注册终止函数
double atof(const char *nptr); 把字符串转换成浮点数
int atoi(const char *nptr); 把字符串转换成整型数
long atol(const char *nptr); 把字符串转换成长整型数

1. abort

1.1 函数说明

函数声明 函数功能
void abort(void); 异常终止一个进程

注意： abort() 函数用于终止当前程序的执行。当程序调用 abort() 函数时，它会立即退出，并生成一个错误信号，通知操作系统程序非正常终止。如果程序已经打开了一些文件或句柄，但尚未关闭它们，则这些资源可能无法被正确释放。

1.2 演示示例

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    printf("Calling abort()\n");
    abort();
    printf("already abort()"); // 这里永远也到不了
    return 0; 
}

1.3 运行结果

2. abs

2.1 函数说明

函数声明 函数功能
int abs(int i); 求整数的绝对值

2.2 演示示例

1
2
3
4
5
6
7
8
9
#include <stdio.h>
#include <math.h>

int main(void)
{
    int number = -666;
  	printf("number: %d  absolute value: %d\n", number, 	abs(number));
  	return 0;
}

2.3 运行结果

3. absread

3.1 函数说明

函数声明 函数功能
int absread(int drive, int nsects, int sectno, void *buffer); 从drive指定的驱动器磁盘上，sectno指定的逻辑扇区号开始读取nsects个(最多64K个)扇区的内容，储存于buffer所指的缓冲区中。

3.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <stdio.h>
#include <conio.h>
#include <process.h>
#include <dos.h>

int main(void)
{
  	int i, strt, ch_out, sector;
  	char buf[512];

  	printf("Insert a diskette into drive A and press any key\n");
  	getch();
  	sector = 0;
  	if (absread(0, 1, sector, &buf) != 0)
  	{
     	perror("Disk problem");
     	exit(1);
  	}
  	printf("Read OK\n");
  	strt = 3;
  	for (i=0; i<80; i++)
  	{
     	ch_out = buf[strt+i];
     	putchar(ch_out);
  	}
  	printf("\n");
  	return(0);
}

上述的代码实现了从 A 驱动器读取一个扇区的数据，并将其中一些字符输出到屏幕上。

  • 首先提示用户插入一个软盘到 A 驱动器中。
  • 然后读取 A 驱动器上第 0 个扇区的数据到缓冲区 buf 中。
  • 接着检查读取是否成功。如果不成功，输出错误信息并退出程序。
  • 最后将 buf 缓冲区中偏移量为 3 到偏移量为 82 的字符依次输出到屏幕上。

注意： 程序中使用了一些 DOS 特定的函数，比如 absread() 和 getch()，可能不适用于其他操作系统或编译器环境。

4. abswrite

4.1 函数说明

函数声明 函数功能
int abswrite(int drive, int nsects, int sectno, void *buffer); 将指定内容写入磁盘上的指定扇区

4.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include <dos.h>
#include <stdio.h>

unsigned char buff[512];

int main()
{
    int i;
    char c;
    printf("\nQuick Format 1.44MB\n");
    printf("Program by ChenQingyang.\n");
    printf("ALL DATA IN THE FLOPPY DISK WILL BE LOST!!\n");
    printf("\nInsert a diskette for drive A:\n");
    printf("and press ENTER when ready. . .");
    c=getchar();
    printf("\n\nCleaning FAT area. . .");
    buff[0]=0xf0;
    buff[1]=buff[2]=0xff;
    for (i=3;i<512;i++) 
        buff[i]=0;
    abswrite(0,1,1,buff);
    abswrite(0,1,10,buff);
    for (i=0;i<512;i++) 
        buff[i]=0;
    for (i=2;i<10;i++) 
        abswrite (0,1,i,buff);
    for (i=11;i<19;i++) 
        abswrite (0,1,i,buff);
    printf("\nCleaning ROOT area. . .");
    for (i=19;i<33;i++) 
        abswrite (0,1,i,buff);
    printf("\n\nQuickFormat Completed!\n");
}

上述代码是一个使用 DOS 命令格式化软盘的程序。它会提示用户输入软盘，然后清空软盘的FAT和根目录区域，并在完成后打印 “QuickFormat Completed!” 的信息。程序使用了 <dos.h> 和 <stdio.h> 头文件，其中包含了一些 DOS 和标准输入输出函数。

5. access

5.1 函数说明

函数声明 函数功能
int access(const char *filename, int amode); 确定文件的访问权限

5.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
#include <io.h>

int file_exists(char *filename);

int main(void)
{
    printf("Does students1.txt exist: %s\n",
    file_exists("students1.txt") ? "YES" : "NO");
    return 0;
}

int file_exists(char *filename)
{
    return (access(filename, 0) == 0);
}

5.3 运行结果


6. acos

6.1 函数说明

函数声明 函数功能
double acos(double x); 反余弦函数

6.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
#include <math.h>

int main(void)
{
    double result;
    double x = 0.5;

    result = acos(x); 
    printf("The arc cosine of %lf is %lf\n", x, result);
    return 0;
}

6.3 运行结果

7. allocmem

7.1 函数说明

函数声明 函数功能
int allocmem(unsigned size, unsigned *seg); 分配DOS存储段

7.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <dos.h>
#include <alloc.h>
#include <stdio.h>

int main(void)
{
    unsigned int size, segp;
    int stat;
    size = 64; /* (64 x 16) = 1024 bytes */
    stat = allocmem(size, &segp);
    if (stat == -1)
        printf("Allocated memory at segment: %x\n", segp);
    else
        printf("Failed: maximum number of paragraphs available is %u\n",stat);
    return 0;
}

在上述的示例代码，

  • 首先调用了 allocmem() 函数来分配内存，其中传递了两个参数：size 表示请求的内存大小（以段为单位），这里设置为 64 段；&segp 表示返回的内存段地址将存储在此变量中。
  • 如果成功分配内存，allocmem()函数将返回 -1，并打印出已分配内存的段地址；
  • 否则，它将返回最大可用段数，并打印出失败的消息。

8. arc

8.1 函数说明

函数声明 函数功能
void arc(int x, int y, int stangle, int endangle, int radius); 画一弧线

8.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>

int main(void)
{
    /* request auto detection */
    int gdriver = DETECT, gmode, errorcode;

    int midx, midy;
    int stangle = 45, endangle = 135;
    int radius = 100;

    /* initialize graphics and local variables */
    char ch[] = "";
    initgraph(&gdriver, &gmode, ch);

    /* read result of initialization */
    errorcode = graphresult();    /* an error occurred */
    if (errorcode != grOk)
    {
        printf("Graphics error: %s\n", grapherrormsg(errorcode));
        printf("Press any key to halt:");
        getch();
        exit(1);    /* terminate with an error code */
    }

    midx = getmaxx() / 2;
    midy = getmaxy() / 2;
    setcolor(getmaxcolor());

    /* draw arc */
    arc(midx, midy, stangle, endangle, radius);

    /* clean up */
    getch();
    closegraph();
    return 0;
}

8.3 运行结果

9. asctime

9.1 函数说明

函数声明 函数功能
char *asctime(const struct tm *tblock); 转换日期和时间为ASCII码

9.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <stdio.h>
#include <string.h>
#include <time.h>

int main(void)
{
    struct tm t;
    char str[80];

    /* sample loading of tm structure  */

    t.tm_sec    = 1;  /* Seconds */
    t.tm_min    = 30; /* Minutes */
    t.tm_hour   = 9;  /* Hour */
    t.tm_mday   = 22; /* Day of the Month  */
    t.tm_mon    = 11; /* Month */
    t.tm_year   = 56; /* Year - does not include century */
    t.tm_wday   = 4;  /* Day of the week  */
    t.tm_yday   = 0;  /* Does not show in asctime  */
    t.tm_isdst  = 0;  /* Is Daylight SavTime; does not show in asctime */

    /* converts structure to null terminated
    string */

    strcpy(str, asctime(&t));
    printf("%s\n", str);

    return 0;
}

9.3 运行结果

10. asin

10.1 函数说明

函数声明 函数功能
double asin(double x); 反正弦函数

10.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
#include <math.h>

int main(void)
{
    double result;
    double x = 0.5;

    result = asin(x);
    printf("The arc sin of %lf is %lf\n", x, result);
    return(0);
}

10.3 运行结果

11. assert

11.1 函数说明

函数声明 函数功能
void assert(int test); 测试一个条件并可能使程序终止

11.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>

struct ITEM {
   int key;
   int value;
};

/* add item to list, make sure list is not null */
void additem(struct ITEM *itemptr) {
    assert(itemptr != NULL);
   /* add item to list */
}

int main(void)
{
    additem(NULL);
    return 0;
}

11.3 运行结果

12. atan

12.1 函数说明

函数声明 函数功能
double atan(double x); 反正切函数

12.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
#include <math.h>

int main(void)
{
    double result;
    double x = 0.5;

    result = atan(x);
    printf("The arc tangent of %lf is %lf\n", x, result);
    return(0);
}

12.3 运行结果

13. atan2

13.1 函数说明

函数声明 函数功能
double atan2(double y, double x); 计算Y/X的反正切值

13.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
#include <math.h>

int main(void)
{
	double result;
	double x = 60.0, y = 30.0;

	result = atan2(y, x);
	printf("The arc tangent ratio of %lf is %lf\n", (y / x), result);
	return 0;
}

13.3 运行结果

14. atexit

14.1 函数说明

函数声明 函数功能
int atexit(atexit_t func); 注册终止函数

14.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
#include <stdlib.h>

void exit_fn1(void)
{
    printf("Exit function #1 called\n");
}

void exit_fn2(void)
{
    printf("Exit function #2 called\n");
}

int main(void)
{
    /* post exit function #1 */
    atexit(exit_fn1);
    /* post exit function #2 */
    atexit(exit_fn2);
    return 0;
}

14.3 运行结果

15. atof

15.1 函数说明

函数声明 函数功能
double atof(const char *nptr); 把字符串转换成浮点数

15.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdlib.h>
#include <stdio.h>

int main(void)
{
    float f;
    char *str = "1234.5678";

    f = atof(str);
    printf("string = %s float = %f\n", str, f);
    return 0;
}

15.3 运行结果

16. atoi

16.1 函数说明

函数声明 函数功能
int atoi(const char *nptr); 把字符串转换成整型数

16.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdlib.h>
#include <stdio.h>

int main(void)
{
    int n;
    char *str = "1234.5678";

    n = atoi(str);
    printf("string = %s integer = %d\n", str, n);
    return 0;
}

16.3 运行结果

17. atol

17.1 函数说明

函数声明 函数功能
long atol(const char *nptr); 把字符串转换成长整型数

17.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdlib.h>
#include <stdio.h>

int main(void)
{
    long l;
    char *lstr = "87654321";

    l = atol(lstr);
    printf("string = %s integer = %ld\n", lstr, l);
    return(0);
}

17.3 运行结果

参考

  1. [API Reference Document]

Spring Boot 项目介绍

引言

作为学习过 Java 的软件开发者，相信都知道 Spring 这一伟大的框架，它所拥有的强大功能之一就是可以集成各种开源软件。但随着互联网的高速发展，各种框架层出不穷，这就对系统架构的灵活性、扩展性、可伸缩性 和 高可用性都提出了新的要求。

flea-msg使用之JMS初识

1. JMS 基本概念

1.1 什么是 JMS ？

Java 消息服务【Java Message Service】，又简称 JMS，它是 Java 平台上有关面向消息中间件(MOM)的技术规范。