C语言_一些库函数使用stdio.h/string.h/math.h/time.h/ctype.h/stdlib.h/conio.h

  本次来分享C语言一些库函数的使用，主要是都是常用的函数，是博主以前的学习笔记，大家有兴趣可以自己翻翻练练，多熟悉熟悉，话不多说，开始上菜：

此博主在CSDN发布的文章目录：我的CSDN目录，作为博主在CSDN上发布的文章类型导读

1.stdio.h

1.1.printf输出函数

1.1.1.原型

  其原型：int printf( const char *format, … );//输出到屏幕

  转义字符的输出：
  ’ 单引号
  " 双引号
  \ 反斜杠
  \0 空字符
  \a 响铃
  \b 后退
  \f 走纸
  \n 换行
  \r 回车
  \t 水平制表符
  \v 垂直制表符
  \xnnn 表示十六进制数(nnn)

  printf格式输出：
  %d或%i：十进制输入/输出
  %u：无符号十进制输入/输出
  %c：输入/输出单个字符串
  %s：输入/输出字符串
  %f：输入/输出实型
  %o：输入/输出八进制
  %x或%X： 输入输出十六进制

1.1.2.示例1：转义字符

  printf( “This\nis\na\ntest\n\nShe said, “How are you?”\n” );:
  输出：
  This
  is
  a
  test

  She said, “How are you?”

1.1.3.示例2：printf(“%s\n”,”I love”);

  printf(“%s\n”,”I love”);

  输出：
  I love

1.1.4.示例3：%

  printf(“%%\n”);
  输出：
  %

1.1.5.示例4：格式

#include<stdio.h>
int main()
{
	int a=10000;
	float b=778.909f;//float定义有小数时记得加f，否则容易被警告
	printf("%6d看\n",a);//6d表示保留6位有效数字，不足6位在开头补空格
	printf("%-6d看\n",a);//-6d表示保留6位有效数字，不足6位在最后补空格

	printf("%3f\n",b);//float实型规定有效小位数是6位，若没有设定，则全部输出 

	printf("%.3f\n",b);//.3表示保留小数点后3位有效数字定义

	printf("%-6c",' ');//表示输出6个空格
}

1.2.scanf输入函数

1.2.1.原型

  原型：int scanf(const cahr * restrict format…)//从键盘输入
  scanf格式输入：（自动换行）
  l 用于输入长整型数据（%ld、%lo、%lx、%lu）以及double型的数据（%lf、%le）
  h 用于输入短整型数据（%hd、%ho、%hx）
  n 指定输入数据所占宽度
  * 表示指定的输入项在读入后不赋值给相应的变量

1.2.2.示例1：用scanf输入double数据

//用scanf输入double数据，圆的面积
#include <stdio.h>
#include <math.h>
#define PI 3.1415926
int main()
{
	double iResult=0;
	double i;
	printf("请输入圆的半径：");
	scanf("%lf",&i);//此处需要加字母l，用%lf的形式才能存储double数据，%f只是存储float的
	iResult=pow(i,2)*PI;
	printf("圆的面积为：%1f",iResult);
	/*double i;
	double j=2;
	i=pow(j,5);
	printf("%.1f",i);*/
}

1.2.3.示例2：各种类型输入输入

//scanf的各种类型输入
#include <stdio.h>
int main ()
{
	long iLong;
	short iShort;//short占两个字节，最大数值32767
	int iNumber1=1,iNumber2=2;
	char cChar[10];
	printf("请输入长整型数据：");
	scanf("%ld",&iLong);
	printf("短的：");
	scanf("%hd",&iShort);

	printf("输入序号：");
	scanf("%d*%d",&iNumber1,&iNumber2);//iNumber并未被执行输入，还是原值2；即*号后面的输入省略

	printf("输入字符串:");
	scanf("%3s",cChar);

	printf("%ld\n",iLong);
	printf("%hd\n",iShort);
	printf("%d\n",iNumber1);
	printf("%d\n",iNumber2);
	printf("%s\n",cChar);
	return 0;
}

1.2.4.示例3：字符串输入

//用scanf函数输入字符串，接收空格或回车为字符串结束标志，接收回车表示输入完毕

#include<stdio.h>
int main()
{
	char b[5];
	char b1[5];
	scanf("%s %s",b,b1);//接收空格或回车为字符串结束标志，接收回车表示输入完毕
	printf("%s\n%s\n",b,b1);
}

#include<stdio.h>
#pragma warning(disable:4996)
int main()
{
	char b[5];
	char b1[5];
	char b2;
	scanf("%s %s %c",b,b1,&b2);//接收空格或回车为字符串结束标志，接收回车表示输入完毕
	printf("%s\n%s\n%c\n",b,b1,b2);
}

1.3.getchar字符输入

1.3.1.原型

  原型：int __cdecl getchar(void);

  getchar：从键盘输入字符。 （自动换行）
  char c；
  c=getchar（）；//不能这样定义getchar（c）；

1.3.2.示例1：

#include<stdio.h>
int main()
{
	char c;
	c=getchar();//引用getchar输入字符
	putchar(c);
	putchar('\n');
}

1.4.putcahr字符输出

1.4.1.原型

  原型：int __cdecl putchar(_In_ int _Ch);

  putchar：输出字符到屏幕。 （不自动换行）
  int c=‘a’；
  putchar（c）；//也可以putchar（“中文”）；或putchar（‘y’）；

1.4.2.示例1：

//putchar运用
#if 1
#include <stdio.h>
int main()
{
	char cChar=‘a’；
	putchar（cChar）；
	putchar('h');
	putchar('e');
	putchar('l');
	putchar('l');
	putchar('o');}
#endif

1.5.gets字符串输入

1.5.1.原型：

  原型：char*_cdecl gets(char* _Buffer);
  gets：从键盘输入字符串。（自动换行）
  char a[10];
  gets（a）；//不能char c；gets（c）；或不能char *c=“aaaa”；gets（c）；

  gets接收空格为一个字符，直到接收回车作为输入结束，
  多个字符串输入时，连续输入回车，回车也表示一个字符串，其长度为0，可以用strlen函数判断。
  字符数组实际长度的为字符数组中的元素加1

1.5.2.示例1：

#include <stdio.h>
#include <string.h>
int main()
{
	char f[10],*c="i love you!";//如果f用指针
	int a=1,*e=&a;
	char s[]="asd";//字符的长度为4
	char s1[6]="asd";//字符的长度为6
	printf("%d\n",*e);
	a=2;
	printf("%d\n",*e);
	//gets(c);//程序运行到此处会中止，因为更改了指针里的常量，所以注释此行
	gets(f);
	puts(f);//puts支持puts（“中文输入”）；
	puts("i love you!");
	puts("i\0love\0you");//因为\0表示字符结束，所以只打印i
	puts(c);
	c="i\0love\0you!";
	puts(c);//只打印i，因为\0表示字符结束
	printf("%d",sizeof(s1));// sizeof(s1)为6

}

1.6.puts字符串输出

1.6.1.原型：

  原型：int _cdecl gets(const char* _Str);

  puts：输出字符串到屏幕。（自动换行）
  char *c=“asassa”；
  puts（c）；或puts（“中文”）；或puts（“英文”）；

1.6.2.示例1：

#include <stdio.h>
int main()
{
	char f[10],*c="i love you!";//如果f用指针
	int a=1,*e=&a;
	printf("%d\n",*e);
	a=2;
	printf("%d\n",*e);
	//gets(f);程序运行到此处会中止，因为更改了指针里的常量，所以注释此行
	puts(f);//puts支持puts（“中文输入”）；
	puts("i love you!");
	puts("i\0love\0you");
	puts(c);
	c="i\0love\0you!";
	puts(c);
}

1.7.fflush清除当前缓存区内的输入

1.7.1.原型：

   int __cdecl fflush(_Inout_opt_ FILE * _File);

1.7.2.示例1：

//用在循环中，以防输入多了，第二次scanf("%d",&n);的n自动赋值
int main()
{
	int n;
	tab.len=0;
	while (1)
	{
		system("cls");
		menu();
		printf("请输入选项(0-6):");
		scanf("%d",&n);
		fflush(stdin);
		switch (n)
		{
		case 0:
			//save_s();
			printf("保存成功！\n");
			break;
		case 1:
			system("cls");
			//creat_s();
			break;
		case 2:
			system("cls");
			//add_s();
			break;
		case 3:
			system("cls");
			//show_s();
			break;
		case 4:
			break;
		case 5:
			break;
		case 6:
			break;
		default:
			printf("***********************输入错误********************\n");
			printf("**********************请重新输入*******************\n");
			break;
		}
		system("pause");
	}
}

1.8.sprintf将第二个参数后的参数以第二个参数规定的形式赋给第一个参数

1.8.1.原型：

  int sprintf( char *buffer, const char *format, … );
  功能：sprintf()函数和printf()类似, 只是把输出发送到buffer(缓冲区)中.返回值是写入的字符数量.

  示例1：

void main()
{
	int i = 0, j = 0;
	char **p2 = NULL;
	int num = 5;
	p2 = (char **)malloc(sizeof(char *) * num);

	for (i=0; i<num; i++)
	{
		p2[i] = (char *)malloc(sizeof(char)  * 100  ); //char buf[100];
		sprintf(p2[i], "%d%d%d", i+1, i+1, i+1);//将i+1赋给p2[i][i],例p[0][0]、p[0][1]、p[0][2]3个元素相同都是1
	}
	for (i=0;i<5;i++)
	{
		for(j=0;j<5;j++)
		{
			printf("%c ",p2[i][j]);
		}
		printf("\n");
	}
}

2.string.h

2.1.字符串操作函数

2.2.strcpy字符串整体复制

2.2.1.原型

  char *strcpy( char *to, const char *from );

  功能：复制字符串from 中的字符到字符串to，包括空值结束符。返回值为指针to。
  from会覆盖掉通中原有的字符串，且自动加上\0
  strcpy_s(str,strlen(str1) + 1,str1);

2.3.strcat字符串连接

2.3.1.原型

  strcat（目的字符数组名，源字符数组名）

  功能：把源字符数组的字符串连接到目的字符数组中字符串的后面，并删去目的字符数组中原有的结束标志“\0”。
  在目的字符数组最后加上\0

2.3.2.示例1：

//strct字符串连接
#include<stdio.h>
#include<string.h>

int main()
{
	char str1[30],str2[30];
	printf("输入目的字符串:\n");
	gets(str1); 										/*输入目的字符*/
	printf("输入源字符串:\n");
	gets(str2); 										/*输入源字符串*/

	printf("输出目的字符串:\n");
	puts(str1); 										/*输出目的字符*/
	printf("输出源字符串:\n");
	puts(str2); 										/*输出源字符串*/
	strcat(str1,str2); 									/*调用strcat函数进行字符串连接*/
	printf("调用strcat函数进行字符串连接:\n");
	printf("字符串连接之后的目的字符串:\n");
	puts(str1); 										/*输出连接后的目的字符串*/

	return 0;											/*程序结束*/
}

2.3.3.示例2

int main()
{
	char name[20];
	char *title;
	printf( "Enter your name: " );
	scanf( "%s", name );
	title = strcat( name, " the Great" );
	printf( "Hello, %s\n", title );
	return 0;

}

2.4.strcmp字符串比较

2.4.1.原型

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

  strcmp（字符数组名1，字符数组名2）
  功能：将一个字符串与另一个字符串从首字母开始，按照ASCII码的顺序进行逐个比较。
  字符串1=字符串2 ，返回值为0；
  字符串1>字符串2 ，返回值为正数；
  字符串1<字符串2 ，返回值为负数；

2.5.strupr和strlwr字符串大小写转换

2.5.1.原型

  char * __cdecl strupr(Inout_z char * _Str);
  char * __cdecl strlwr(Inout_z char * _Str);

  strupr（字符串）；
  功能：将字符串中小写字母变成大写字母，其它字母不变。

  strlwr（字符串）；
  功能：将字符串中大写字母变成小写字母，其它字母不变。

2.5.2.示例1：

#include <stdio.h>
#include <string.h>
int main()
{
	char a[10]="asdasd";
	char b[10]="ASDDF";
	strupr(a);//将a中的字符全部变成了大写字母
	strlwr(b);//将b中字符全部变成了小写字母
	puts(a);
	puts(b);
	return 0;
}

2.6.strlen计算字符长度

2.6.1.原型

  size_t strlen( char *str );//不包括‘\0’

  功能：函数返回字符串str 的长度( 即空值结束符之前字符数目、不包括‘\0’)。

2.7.strchr指向str 中ch（字符） 首次出现的位置

2.7.1.原型

  char *strchr( const char *str, int ch );

  功能：函数返回一个指向str 中ch 首次出现的位置，当没有在str 中找ch到返回NULL。请看示例。

2.7.2.示例1：

#include <stdio.h>
#include <string.h>
int main()
{
	char a[2][10]={"sdasd","hk"};
	char b[10]="ASDDF";
	char *a1,c='d';
	char *p=a[0];
	a1=strchr(p,c);//从d开始输出dasd，a1就指向dasd
	printf("%s\n",a1);
	puts(a[0]);
	puts(b);
	return 0;
}

2.8.strcoll

2.8.1.原型

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

  功能：比较字符串str1 和 str2, 很象strcmp. 但是, strcoll() 使用在目前环境中由setlocale()设定的次序进行比较。

2.9.strcspn

2.9.1.1.原型

  size_t strcspn( const char *str1, const char *str2 );

   功能：函数返回str1 开头连续n个字符都不含字符串str2内字符的字符数。

2.10.strerror

2.10.1.原型

  char *strerror( int num );
  功能：函数返回一个被定义的与某错误代码相关的错误信息。

2.11.strncat将字符串str2中至多count个字符连接到字符串str1中

2.11.1.原型

  char *strncat( char *str1, const char *str2, size_t count );

  功能：将字符串from 中至多count个字符连接到字符串to中，追加空值结束符。返回处理完成的字符串。

2.11.2.示例1：

void inverse(char *p)
{
	if (p==NULL)//递归结束的异常条件
	{
		return ;
	}
	if (*p=='\0')
	{
		return ;
	}
	inverse(p+1);//并没有执行打印，是让字符串的每一个地址入栈
	//printf("%c",*p);
	//strcat(g_buf,p);
	strncat(g_buf,p,1);//每次向g_buf中连接一个p所指向的字符
}


int main()
{
	char buf[]="abcdefg";
	memset(g_buf,0,sizeof(g_buf));
	inverse(buf);
	printf("g_buf:%s\n",g_buf);
	return 0;
}

2.12.strncmp比较字符串str1 和 str2中至多count个字符

2.12.1.原型

  int strncmp( const char *str1, const char *str2, size_t count );
  功能：比较字符串str1 和 str2中至多count个字符。返回值如下：

  返回值         解释
  less than 0     str1 is less than str2
  equal to 0      str1 is equal to str2
  greater than 0    str1 is greater than str2

  如果参数中任一字符串长度小于count, 那么当比较到第一个空值结束符时，就结束处理。

  

2.13.strncpy将form字符串中的count个字符复制到to字符串中

2.13.1.原型

  char *strncpy( char *to, const char *from, size_t count );

  功能：将字符串from 中至多count个字符复制到字符串to中。如果字符串from 的长度小于count，其余部分用’\0’填补。返回处理完成的字符串。

2.13.2.示例1：

int main()
{
	//求非空格的长度
	char *p="    abcdddddd      ";
	char p1[128];
	int ncount=0;
	int i,j;
	i=0;
	j=strlen(p)-1;

	while (isspace(p[i])&&p[i]!='\0')
	{
		i++;
	}
	while (isspace(p[j])&&p[j]!='\0')
	{
		j--;

	}
	ncount=j-i+1;
	strncpy(p1,p+i,ncount);//从p的第p+i个字节开始复制ncount个字节到p1的内存空间里
	p1[ncount]='\0';

	printf("ncount:%d\n",j-i+1);
	printf("p1:%s\n",p1);

	return 0;

}

2.14.char *strpbrk( const char *str1, const char *str2 );

  功能：函数返回一个指针，它指向字符串str2中任意字符在字符串str1 首次出现的位置，如果不存在返回NULL。

2.15.strrchr指向字符ch 在字符串str末次出现的位置

2.15.1.原型

  char *strrchr( const char *str, int ch );
  功能：函数返回一个指针，它指向字符ch 在字符串str末次出现的位置，如果匹配失败，返回NULL。

2.15.2.strspn

  size_t strspn( const char *str1, const char *str2 );

  功能：函数返回字符串str1中第一个不包含于字符串str2的字符的索引。

2.16.strstr找到字符串2在字符串1中首次出现的位置

2.16.1.原型

  原型：char *strstr( const char *str1, const char *str2 );

  功能：函数返回一个指针，它指向字符串str2 首次出现于字符串str1中的位置，如果没有找到，返回NULL。

2.16.2.示例1：

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

int _strstr(char *q,char *str)
{
	char *aform1=q;
	char *aform=aform1,*strto=str;
	int ncount1=0;
	int i=1;
	int icount=0;
	while (aform=strstr(aform,strto))
	{
		ncount1++;
		icount=strlen(aform1)-strlen(aform);
		printf("第%d次出现的位置为：%d\n",i++,icount+1);
		aform=aform+strlen(strto);
		if (aform=='\0')
		{
			break;
		}
	}
	return ncount1;

}
void main()
{
	//strstr(str, str2)
	int ncount = 0;
	int icount=0;
	int i=1;
	//初始化 让p指针达到查找的条件
	char *p="abcd",*p1 = "11abcd111122abcd3333322abcd3333322qqqabcd";  
	ncount=_strstr(p1,p);
	printf("ncount:%d \n", ncount);
	system("pause"); 
	return ;
}

2.17.strtod

  double strtod( const char *start, char **end );

   功能：函数返回带符号的字符串start所表示的浮点型数。字符串end 指向所表示的浮点型数之后的部分。如果溢出发生，返回HUGE_VAL或 -HUGE_VAL。

2.18.strtok

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

  功能：函数返回字符串str1中紧接“标记”的部分的指针, 字符串str2是作为标记的分隔符。如果分隔标记没有找到，函数返回NULL。为了将字符串转换成标记，第一次调用str1 指向作为标记的分隔符。之后所以的调用str1 都应为NULL。

  例如:

char str[] = "now # is the time for all # good men to come to the # aid of their country";
    char delims[] = "#";
    char *result = NULL;
     result = strtok( str, delims );
    while( result != NULL ) {
        printf( "result is \"%s\"\n", result );
         result = strtok( NULL, delims );
}

  以上代码的运行结果是：
   result is “now "
   result is " is the time for all "
   result is " good men to come to the "
   result is " aid of their country”

2.19.strxfrm

  size_t strxfrm( char *str1, const char *str2, size_t num );
  功能：函数将字符串str2 的前num 个字符存储到字符串str1中。如果strcoll() 处理字符串str1 和旧的字符串str2, 返回值和strcmp()的处理结果一样。

2.20.字符串处理函数

2.20.1.memchr

  void *memchr( const void *buffer, int ch, size_t count );

  功能：函数在buffer指向的数组的count个字符的字符串里查找ch 首次出现的位置。返回一个指针，指向ch 在字符串中首次出现的位置, 如果ch 没有在字符串中找到，返回NULL。

  例如:

    char names[] = "Alan Bob Chris X Dave";
    if( memchr(names,'X',strlen(names)) == NULL )
      printf( "Didn't find an X\n" );
    else
      printf( "Found an X\n" );

2.20.2.memcmp函数比较buffer1 和 buffer2的前count 个字符

  int memcmp( const void *buffer1, const void *buffer2, size_t count );

  功能：函数比较buffer1 和 buffer2的前count 个字符。返回值如下:
  Value      解释
  less than 0    buffer1 is less than buffer2
  equal to 0   buffer1 is equal to buffer2
  greater than 0   buffer1 is greater than buffer2

2.20.3.memcpy函数从from中复制count 个字符到to中，并返回to指针

  void *memcpy( void *to, const void *from, size_t count );

  功能：函数从from中复制count 个字符到to中，并返回to指针。 如果to 和 from 重叠，则函数行为不确定。

2.20.4.memset初始化某数组为0

  void *memset( void *buffer, int ch, size_t count );
  功能: 函数拷贝ch 到buffer 从头开始的count 个字符里, 并返回buffer指针。 memset() 可以应用在将一段内存初始化为某个值。
  例如：
  memset( the_array, ‘\0’, sizeof(the_array) );

  这是将一个数组的所以分量设置成零的很便捷的方法。
  memset（array，0，sizeof（array））;s
  将字符数组array的所有元素初始化为0

2.20.5.memmove函数

  void *memmove( void *to, const void *from, size_t count );
  功能: 与mencpy相同，不同的是当to 和 from 重叠，函数正常仍能工作。

3.math.h

3.1.sqrt开平方

3.1.1.原型

  long double sqrt(long double)
   float sqrt(float)
   double sqrt(double)
  sqrt（a）；//a的开平方

3.2.pow多少次方

3.2.1.原型

  long double pow(long double,int)
  float pow(float,int)
  double pow(double,int)
  double pow（double a，int x）；//a的x次方

3.3.double exp( double arg );

  功能： 函数返回参数returns e (2.7182818) 的arg次幂。

3.4.double log( double num );

  功能： 函数返回参数num的自然对数。如果num为负,产生域错误；如果num 为零，产生范围错误。

3.5.double log10( double num );

  功能： 函数返回参数num以10为底的对数。如果num为负,产生域错误；如果num 为零，产生范围错误。

3.6.绝对值函数

3.6.1.abs整型绝对值

  int abs（int a）;//a的绝对值

3.6.2.fabs浮点型绝对值

  double fabs（double a）;//a的绝对值

3.6.3.labs长整型绝对值

  原型：long labs(long n);

//使用绝对值函数
#include<stdio.h>
#include<math.h>
int main()
{
	int iAbsoluteNumber;						/*定义整数*/
	int iNumber = -12;							/*定义整数，为其赋值为-12*/
	long lResult;								/*定义长整型*/
	long lNumber = -1234567890L; 				/*定义长整型，为其赋值为-1234567890*/
	double fFloatResult;							/*定义浮点型*/
	double fNumber = -123.1; 					/*定义浮点型，为其赋值为-1234.0*/
	
	iAbsoluteNumber=abs(iNumber);				/*将iNumber的绝对值赋给iAbsoluteNumber变量*/
	lResult= labs(lNumber);						/*将lNumber的绝对值赋给iResult变量*/
	fFloatResult= fabs(fNumber);				/*将fNumber的绝对值赋给fResult变量*/
	/*输出原来的数字，然后将得到的绝对值进行输出*/
	printf("the original number is: %d, the absolute is: %d\n",iNumber,iAbsoluteNumber);
	printf("the original number is: %ld, the absolute is: %ld\n",lNumber,lResult);
	printf("the original number is: %lf, the absolute is: %lf\n",fNumber,fFloatResult);
	return 0;
}

3.7.三角函数

3.7.1.sin正弦函数

  double sin(double x);
  例：
  double x;
  double f=0.5;
  x=sin(f);

3.7.2.cos余弦函数

  double cos(double x);
  例：
  double x;
  double f=0.5;
  x=sin(f);

3.7.3.tan正切函数

  double tan(double x);
  例：
  double x;
  double f=0.5;
  x=sin(f);

//使用三角函数
#include<stdio.h>
#include<math.h>		/*包含头文件math.h*/

int main()
{
	double fResultSin;	/*用来保存正弦值*/
	double fResultCos;	/*用来保存余弦值*/
	double fResultTan;	/*用来保存正切值*/
	double fXsin =0.5;	
	double fXcos = 0.5; 
	double fXtan = 0.5;

	fResultSin = sin(fXsin);	/*调用正弦函数*/
	fResultCos = cos(fXcos);	/*调用余弦函数*/
	fResultTan = tan(fXtan);	/*调用正切函数*/
		/*输出运算结果*/
	printf("The sin of %lf is %lf\n", fXsin, fResultSin); 
	printf("The cos of %lf is %lf\n", fXcos, fResultCos);
	printf("The tan of %lf is %lf\n", fXtan, fResultTan); 
	return 0;
}

3.8.取整函数

3.8.1.double ceil( double num );

  功能： 函数返回参数不小于num 的最小整数。
  例如,
   y = 6.04;
   x = ceil( y );
  x为7.0.

3.8.2.double floor( double arg );

  功能： 函数返回参数不大于arg的最大整数。
  例如：
   y = 6.04;
   x = floor( y );
  x的值为6.0.

3.9.其它函数

3.9.1.div_t div( int numerator, int denominator );

  功能： 函数返回参数numerator / denominator的商和余数。结构类型div_t定义在stdlib.h中:

   int quot; // 商数
   int rem; // 余数
  例, 以下代码显示x/y的商和余数:

   div_t temp;
   temp = div( x, y );
   printf( “%d divided by %d yields %d with a remainder of %d\n”, x, y, temp.quot, temp.rem );

3.9.2.double fmod( double x, double y );

  功能： 函数返回参数x/y的余数。

3.9.3.double frexp( double num, int *exp );

  功能： 函数将参数num 分成两部分： 0.5 和1之间的尾数（由函数返回）并返回指数exp。转换成如下的科学计数法形式：

   num = mantissa * (2 ^ exp)

3.9.4.double ldexp( double num, int exp );

  功能： 函数返回参数num * (2 ^ exp)。如果发生溢出返回HUGE_VAL。

3.9.5.ldiv_t ldiv( long numerator, long denominator );

  功能： 函数返回参数numerator / denominator的商和余数。结构类型 ldiv_t 定义在stdlib.h中：

  long quot; // 商数

  long rem; // 余数

  

3.9.6.double modf( double num, double *i );

  功能： 函数将参数num 分割为整数和小数，返回小数部分并将整数部分赋给i。

4.time.h

4.1.获取时间相关时间计算函数

4.1.1.time_t time( time_t *time );

  功能： 函数返回当前时间，如果发生错误返回零。如果给定参数time ，那么当前时间存储到参数time中。

4.1.1.1.示例1：

#include <stdio.h>
#include <time.h>
int main()
{
	time_t timep;
	struct tm *p;
	time (&timep);
	p=gmtime(&timep);
	printf("%d\n",p->tm_sec);//获取秒
	printf("%d\n",p->tm_min);//获取分钟
	printf("%d\n",8+p->tm_hour);//获取小时
	printf("%d\n",p->tm_mday);//获取天
	printf("%d\n",1+p->tm_mon);//获取月
	printf("%d\n",1900+p->tm_year);//获取年
}

4.1.2.clock_t clock( void );

  功能：函数返回自程序开始运行的处理器时间，如果无可用信息，返回-1。 转换返回值以秒记, 返回值除以CLOCKS_PER_SECOND. (注: 如果编译器是POSIX兼容的, CLOCKS_PER_SECOND定义为1000000.)
  CLK_TCK:宏定义1000
  start_insert = clock(); //CPU时间，毫秒计算
  selectSort(selectar,M);
  end_insert = clock();
  printf(“\n\n插入排序所用时间：%lf秒?\n”,(double)(end_insert-start_insert)/CLK_TCK);

4.1.3.double difftime( time_t time2, time_t time1 );

  功能：函数返回时间参数time2和time1之差的秒数表示。

4.1.4.struct tm *gmtime( const time_t *time );

  功能：函数返回给定的统一世界时间（通常是格林威治时间），如果系统不支持统一世界时间系统返回NULL。 警告!

4.1.5.struct tm *localtime( const time_t *time );

  功能：函数返回本地日历时间。警告！

4.1.6.time_t mktime( struct tm *time );

  功能：函数转换参数time 类型的本地时间至日历时间，并返回结果。如果发生错误，返回－1。

4.2.转换为可阅读的字符串函数

4.2.1.char *asctime( const struct tm *ptr );

  功能： 函数将ptr所指向的时间结构转换成下列字符串：

  day month date hours:minutes:seconds year\n\0
  例如:
  Mon Jun 26 12:03:53 2000

4.2.2.char *ctime( const time_t *time );

  功能：函数转换参数time为本地时间格式：
  day month date hours:minutes:seconds year\n\0
  ctime() 等同 asctime( localtime( tp ) );

4.2.3.size_t strftime( char *str, size_t maxsize, const char *fmt, struct tm *time );

  功能：函数按照参数fmt所设定格式将time类型的参数格式化为日期时间信息，然后存储在字符串str中（至多maxsize 个字符）。用于设定时间不同类型的代码为：

  代码   含义
  %a   星期的缩略形式
  %A   星期的完整形式
  %b   月份的缩略形式
  %B   月份的完整形式
  %c   月份的缩略形式
  %d   月中的第几天(1-31)
  %H   小时, 24小时格式 (0-23)
  %I   小时, 12小时格式 (1-12)
  %j    年中的第几天(1-366)
  %m   月份 (1-12). Note: 某些版本的Microsoft Visual C++ 可能使用取值范围0-11.
  %M   分钟(0-59)
  %p   本地时间的上午或下午（AM or PM）
  %S   秒钟(0-59)
  %U   年中的第几周，星期天是一周的第一天
  %w   星期几的数字表示(0-6, 星期天=0)
  %W    一年中的第几周，星期天是一周的第一天
  %x    标准日期字符串
  %X    标准时间字符串
  %y    年(0-99)
  %Y    用CCYY表示的年（如：2004）
  %Z    时区名
  %%    百分号

  函数strftime()返回值为处理结果字符串str中字符的个数，如果发生错误返回零。

//使用时间函数
#include <stdio.h>
#include <time.h>
int main()
{
	int command[4] = {0,1,2,3};			/*定义一个数组*/
	int num;
	struct tm *sysTime;
	printf("如需帮助可输入数字0！\n");				/*输出字符串*/
	printf("请输入命令符：\n");						/*输出字符串*/

	while (1)
	{
		scanf("%d", &num);							/*获得输入数字*/
		/*判断用于输入的字符*/
		if (command[0] == num)						/*如果输入数字0	*/				
		{
			/*输出帮助信息*/
			printf("输入数字1显示系统日期, 输入数字2显示系统时间, 输出字母3退出系统!\n");
		}
		else if (command[1] == num)					/*如果是命令数字1*/
		{
			time_t nowTime;
			time(&nowTime);							/*获取系统日期*/
			sysTime= localtime(&nowTime);			/*转换为系统日期*/
			printf("系统日期：%d-%d-%d \n",1900 + sysTime->tm_year,sysTime->tm_mon + 1
					,sysTime->tm_mday);				/*输出信息*/
		}
		else if (command[2] == num)					//如果是命令数字2*/
		{
			time_t nowTime;
			time(&nowTime);							/*获取系统时间*/
			sysTime = localtime(&nowTime);			/*转换为系统时间*/
			printf("系统时间：%d:%d:%d \n",sysTime->tm_hour ,sysTime->tm_min 
					,sysTime->tm_sec);				/*输出信息*/
		}
		else if (command[3] == num)
		{
			return 0;								/*退出系统*/
		}
		printf("请输入命令符：\n");					/*输出字符串*/
	}

	return 0;										/*程序结束*/
}

5.ctype.h

5.1.字符测试

5.1.1.isalpha检测字母函数

  int isalpha（int ch）；
  功能：如果参数ch是字母，则返回非0。
  例如：
   char c;
   scanf( “%c”, &c );
   if( isalpha© )
   printf( “You entered a letter of the alphabet\n” );

5.1.2.isdigit检测数字函数

  int isdigit（int ch）；

  功能：如果参数是0到9之间的数字字符，函数返回非零值，否则返回零值.

  例如：
   char c;
   scanf( “%c”, &c );
   if( isdigit© )
   printf( “You entered the digit %c\n”, c );

5.1.3.isalnum检测字母或数字

  int isalnum（int ch）；
  功能：如果参数ch是字母或者数字，则返回非0，否则返回0。

//使用字符函数判断输入字符
#include<stdio.h>
#include<ctype.h>
void SwitchShow(char c);
int main()
{
	char cCharPut;		/*定义字符变量，用来接收输入的字符*/
	char cCharTemp;		/*定义字符变量，用来接收回车的*/
	printf("First enter:");			/*消息提示，第一次输入字符*/
	scanf( "%c", &cCharPut);		/*输入字符*/			
	SwitchShow(cCharPut);			/*调用函数进行判断*/
	cCharTemp=getchar();			/*接收回车*/
	printf("Second enter:");		/*消息提示，进行第二次输入字符*/
	scanf( "%c", &cCharPut);		/*输入字符*/
	SwitchShow(cCharPut);			/*调用函数判断输入的字符*/
	cCharTemp=getchar();			/*接收回车 */
	printf("Third enter:");			/*消息提示，进行第三次输入字符*/
	scanf( "%c", &cCharPut);		/*输入字符*/
	SwitchShow(cCharPut);			/*调用函数判断输入的字符*/
	return 0;						/*程序结束*/
}
void SwitchShow(char cChar)
{
	if(isalpha(cChar))			/*判断是否是字母*/
	{
		printf("You entered a letter of the alphabet %c\n",cChar);
	}

	if(isdigit(cChar))			/*判断是否是数字*/
	{
		printf("You entered the digit %c\n", cChar);
	}
	
	if(isalnum(cChar))			/*判断是否是字母或者是数字*/
	{
		printf("You entered the alphanumeric character %c\n", cChar);
	}

	else						/*当字符既不是字母也不是数字时*/
	{
		printf("You entered the character is not alphabet or digit :%c\n", cChar);
	}
}

5.1.4.int iscntrl( int ch );

  功能：如果参数是控制字符（0和0x1F之间的字符，或者等于0x7F）函数返回非零值，否则返回零值。

5.1.5.int isgraph( int ch );

  功能：如果参数是除空格外的可打印字符（可见的字符），函数返回非零值，否则返回零值。

5.1.6.int islower( int ch );

  功能：如果参数是小写字母字符，函数返回非零值，否则返回零值。

5.1.7.int isprint( int ch );

   功能：如果参数是可打印字符（包括空格），函数返回非零值，否则返回零值。

5.1.8.int ispunct( int ch );

  功能：如果参数是除字母，数字和空格外可打印字符，函数返回非零值，否则返回零值。

5.1.9.int isspace( int ch );

  功能：如果参数是空格类字符（即：单空格，制表符，垂直制表符，满页符，回车符，新行符），函数返回非零值，否则返回零值。

5.1.10.int isupper( int ch );

  功能：如果参数是大写字母字符，函数返回非零值，否则返回零值。

5.1.11.int isxdigit( int ch );

  功能：如果参数是十六进制数字字符（即：A-F, a-f, 0-9），函数返回非零值，否则返回零值。

5.2.大小写转换函数

5.2.1.int tolower( int ch );

  功能：函数字符ch的小写形式。

5.2.2.int toupper( int ch );

  功能：函数字符ch的大写形式。

5.2.3.isspace检测字符串中的空格

5.2.3.1.原型

  原型：int isspace( int ch );

  功能：功能：如果参数是空格类字符（即：单空格，制表符，垂直制表符，满页符，回车符，新行符），函数返回非零值，否则返回零值。

5.2.3.2.示例1：

int main()
{
	//求非空格的长度
	char *p="    abcdddddd      ";
	int ncount=0;
	int i,j;
	i=0;
	j=strlen(p)-1;

	while (isspace(p[i])&&p[i]!='\0')
	{
		i++;
	}
	while (isspace(p[j])&&p[j]!='\0')
	{
		j--;

	}



	printf("ncount:%d\n",j-i+1);


	return 0;

}

6.stdlib.h

6.1.存储函数

6.1.1.malloc函数

  函数原型：void *malloc（unsigned int size）；
  例：int *plnt； plnt=（int*）malloc（sizeof（int））；为plnt 分配一块size大小的整型存储空间
  malloc函数会返回一个指针，该指针指向分配的内存空间，当分配空间错误时，返回NULL。
  例：

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

int main()
{
	int* iIntMalloc=(int*)malloc(sizeof(int));	/*分配空间*/
	*iIntMalloc=100;		/*使用该空间保存数据*/
	printf("%d\n",*iIntMalloc);	/*输出数据*/
	return 0;
}

6.1.2.calloc函数

  函数原型：void *calloc（unsigned n，unsigned size）；
  例：int* pArray； pArray=（int*）calloc（3，sizeof（int））；为pArray分配三个为size大小的连续内存空间数组。
  calloc函数会返回一个指针，该指针指向动态分配的连续内存空间地址，当分配空间错误时，返回NULL。

//使用calloc函数分配空间
#include <stdlib.h>
#include<stdio.h>
int main()
{
	int* pArray;		/*定义指针*/
	int i;				/*循环控制变量*/
	pArray=(int*)calloc(3,sizeof(int));	/*数组内存*/

	for(i=1;i<4;i++)	/*使用循环对数组进行赋值*/
	{
		*pArray=10*i;	/*赋值*/
		printf("NO%d is: %d\n",i,*pArray);	/*显示结果*/
		pArray+=1;		/*移动指针到数组到下一个元素*/
	}
	return 0;
}

6.1.3.realloc函数

  函数原型：void *realloc（void *ptr，size_t size）；
  例：fDouble=（double*）malloc（sizeof（double））； ilnt=realloc（fDouble，sizeof（int））；改变fDoule指向的空间的大小，其大小设置为整型，然后将改变后的内存空间的地址返回赋值给ilnt整型指针。

//使用realloc函数重新分配内存
#include<stdio.h>
#include <stdlib.h>
int main()
{

	double *fDouble;		/*定义实型指针*/
	int* iInt;				/*定义整型指针*/
	fDouble=(double*)malloc(sizeof(double));/*使用malloc为分配实型空间*/
	printf("%d\n",sizeof(*fDouble));	/*输出空间的大小*/
	iInt=realloc(fDouble,sizeof(int));	/*使用realloc改变分配空间大小*/
	printf("%d\n",sizeof(*iInt));	
	return 0;
}

6.1.4.free函数

  函数原型：void free（void *ptr）；功能，释放ptr没有使用完的内存空间。

//使用free函数释放内存空间
#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* pInt;	/*整型指针*/
	pInt=(int*)malloc(sizeof(pInt));	/*分配空间整型空间*/
	*pInt=100;					/*赋值*/
	printf("%d\n",*pInt);		/*将值进行输出*/
	free(pInt);					/*释放该内存空间*/
	printf("%d\n",*pInt);		/*将值进行输出*/
	return 0;
}

6.2.文件函数

6.2.1.fopen文件的打开

  一般形式为：
  FILE *fp；
  fopen（文件名，使用文件方式）；
  功能：打开成功，返回一个指向FILE类型的指针，否则返回NULL。
  通常打开失败原因：
  ①指定的盘符或路径不存在
  ②文件名中含有无效字符
  ③以r模式打开一个不存在的文件

  使用方式：
  文件使用方式 含义
  r/rb：（只读） 打开文本文件/二进制文件 只读数据
  w/wb：（只写） 打开或建立文本文件/二进制文件 只写数据
  a/ab：（追加） 打开文本文件/二进制文件 文件末写数据
  r+/rb+：（读写） 打开文本文件/二进制文件 读和写
  w+/wb+：（读写） 打开或建立文本文件/二进制文件 读和写
  a+/ab+：（读写） 打开文本文件/二进制文件 文件末读和写数据

6.2.2.fclose文件的关闭

  一般形式为：
  fclose（文件指针）；
  功能：返回值为0，否则返回EOF。

6.2.3.fputc函数

  fputc（字符串，文件指针）；
  功能：是把一个字符写的文件指针指向的文件中去。
  例：

#include <stdio.h>
void main()
{
    FILE *fp;										/*定义一个指向FILE类型结构体的指针变量*/
    char ch;										/*定义变量为字符型*/
    if ((fp = fopen("E:\\exp01.txt", "w")) == NULL)			/*检查是否能打开文件，以只写方式打开指定文件*/
    {
        printf("cannot open file\n");//不能打开程序
        exit(0);//正常退出程序
    }
    ch = getchar();									/*fgetc函数带回一个字符赋给ch*/
    while (ch != '#')									/*当输入"#"时结束循环*/
    {
        fputc(ch, fp);								/*将读入的字符写到磁盘文件上去*/
        ch = getchar();								/*fgetc函数继续带回一个字符赋给ch*/
}
/*二进制文件用
while（！feof（fp））
{
ch=fgetc（fp）；
} 如果文件结束，feof（fp）值为1，否则为0，也适用文本文件的结束*/
    fclose(fp);										/*关闭文件*/
}

6.2.4.fgetc函数

  ch=fgetc（文件指针）；
  功能：该函数作用是从文件指针指定的文件读出一个字符串给ch，，该文件必须是以读或读写方式打开，文件结束返回EOF。

//图片文件合成器
#if 1
#include <stdio.h>
#include <stdlib.h>
int main()
{
	FILE *f_pic,*f_file,*f_finsh;
	char ch,pic_name[20],file_name[20],finsh_name[20];
	printf("请输入需要合成的图片和文件的名称：\n");
	printf("图片名为：");
	scanf("%s",pic_name);
	printf("文件名为：");
	scanf("%s",file_name);
	printf("生成名为：");
	scanf("%s",finsh_name);

	if ((f_pic=fopen(pic_name,"rb"))==NULL)		//以二进制只读方式打开
	{
		printf("cannot open the file %s!",pic_name);
		exit(0);
	}
	if ((f_file=fopen(file_name,"rb"))==NULL)	//以二进制只读方式打开
	{
		printf("cannot open the file %s!",file_name);
		exit(0);
	}
	if ((f_finsh=fopen(finsh_name,"wb"))==NULL)	//以二进制只写方式打开
	{
		printf("cannot open the file %s!",finsh_name);
		exit(0);
	}

	while(!(feof(f_pic)))
	{
		ch=fgetc(f_pic);
		fputc(ch,f_finsh);
	}
	fclose(f_pic);

	while(!(feof(f_file)))
	{
		ch=fgetc(f_file);
		fputc(ch,f_finsh);
	}
	printf("成功执行！");
	fclose(f_file);
	system("pause");
}
#endif

6.2.5.fputs（字符串，文件指针）；

  功能：向指定的文件写入一个字符串。

6.2.6.fgets（字符数组名，n，文件指针）；

  功能：从指定文件中读一个字符串到字符数组中，n表示所得到的字符串中的字符个数（包含\0）

6.2.7.fprintf（文件类型指针，格式字符串，输出列表）；

  功能：例：fprintf（fp，“%d”，i）；作用是将整型变量i的值以%d的格式写入到fp指定的文件中。

6.2.8.fscanf（文件类型指针，格式字符串，输入列表）；

  功能：例：fprintf（fp，“%d”，i）；作用是将fp指向的文件读出i的值。

6.2.9.fread（buffer，size，count，fp）；

  功能：是从fp指向的文件中读入count次，每次读size字节，读入的信息存在buffer地址中。

6.2.10.fwrite（buffer，size，count，fp）；

  功能：是将buffer地址开始的信息输出count次，每次写size字节到fp指向的文件中。
  buffer：一个指针，要读入或要读出数据的地址；
  size：要读写的字节数；
  count：要读的次数；
  fp：文件类型指针。

6.2.11.fseek（文件类型指针，位移量，起始点）

  功能：移动fp文件内部位置指针，例：fseek（fp，-20L，1）；表示将位置指针从当前位置后退20个字节。

6.2.12.int rewind（文件类型指针）；

  功能：使位置指针重新返回文件的开头。

6.2.13.long ftell（文件类型指针）；

  功能：得到流式文件中当前的位置，用相对于文件开头的位移量来表示。

6.2.14.feof(fp)

  为0不结束，不为0结束。
  feof(fp)==0一般用这个

6.3.字符串转换函数

6.3.1.double atof( const char *str );

  功能:将字符串str转换成一个双精度数值并返回结果。 参数str 必须以有效数字开头,但是允许以“E”或“e”除外的任意非数字字符结尾。

  例如：

   x = atof( “42.0is_the_answer” );

  x的值为42.0.

6.3.2.int atoi( const char *str );

  功能：将字符串str转换成一个整数并返回结果。参数str 以数字开头，当函数从str 中读到非数字字符则结束转换并将结果返回。

  例如，

   i = atoi( “512.035” );

  i 的值为 512.

6.3.3.long atol( const char *str );

  功能：将字符串转换成长整型数并返回结果。函数会扫描参数str字符串，跳过前面的空格字符，直到遇上数字或正负符号才开始做转换，而再遇到非数字或字符串结束时才结束转换，并将结果返回。

  例如，

   x = atol( “1024.0001” );

  x的值为1024L.

6.3.4.double strtod( const char *start, char **end );

  功能：函数返回带符号的字符串start所表示的浮点型数。字符串end 指向所表示的浮点型数之后的部分。如果溢出发生，返回HUGE_VAL或 -HUGE_VAL。

6.3.5.long strtol( const char *start, char **end, int base );

  功能：函数返回带符号的字符串start所表示的长整型数。参数base代表采用的进制方式。指针end 指向start所表示的整型数之后的部分。如果返回值无法用长整型表示，函数则返回LONG_MAX或LONG_MIN. 错误发生时，返回零。

6.3.6.unsigned long strtoul( const char *start, char **end, int base );

  功能：函数基本等同 strtol(), 不同的是，它不仅可以返回长整型数，而且可以返回无符号的长整型数。

6.3.7.int rand( void );

  rand（）；生成一个随机数。
  rand（）%100；产生0-99以内的随机数
  rand（）%100+1；产生1-100以内的随机数
  rand()%1000/10.0；随机产生100以内实型数
  功能： 函数返回一个在零到RAND_MAX 之间的伪随机整数。

  例如：

  srand( time(NULL) ); for( i = 0; i < 10; i++ ) printf( “Random number #%d: %d\n”, i, rand() );

6.3.8.void srand( unsigned seed );

  功能： 设置rand()随机序列种子。对于给定的种子seed, rand()会反复产生特定的随机序列。 srand( time(NULL) ); for( i = 0; i < 10; i++ ) printf( “Random number #%d: %d\n”, i, rand() );

  

6.4.系统函数

6.4.1.system执行命令函数

  system( const char *command );

  功能： 函数返回给定的命令字符串command 进行系统调用。如果命令执行正确通常返回零值。如果command 为 NULL, system()将尝试是否有可用的命令解释器。 如果有返回非零值，否则返回零值。
  system（“cls”）;//清屏
  system（“pause”）;//暂停程序运行

6.4.2.getenv函数

  char *getenv( const char *name );

  功能： 函数返回环境变量name的值，非常依赖执行情况。如果无对应的环境变量name返回NULL。

6.4.3.exit程序正常退出函数

  void exit( int exit_code );

  功能：终止程序的执行。参数exit_code 传递给返回值，通常零值表示正常结束，非零值表示应错误返回。

  

6.5.搜索和排序函数

6.5.1.qsort函数

  void qsort( void *buf, size_t num, size_t size, int (*compare)(const void *, const void *) );

  功能： 对buf 指向的数据(包含num 项,每项的大小为size)进行快速排序。如果函数compare 的第一个参数小于第二个参数，返回负值；如果等于返回零值；如果大于返回正值。函数对buf 指向的数据按升序排序。

6.5.2.bsearch函数

  void *bsearch( const void *key, const void *buf, size_t num, size_t size, int (*compare)(const void *, const void *) );

  功能： 函数用折半查找法在从数组元素buf[0]到buf[num-1] 匹配参数key。如果函数compare 的第一个参数小于第二个参数，返回负值；如果等于返回零值；如果大于返回正值。数组buf 中的元素应以升序排列。函数bsearch()的返回值是指向匹配项，如果没有发现匹配项，返回NULL。

6.5.3.atexit函数

  int atexit( void (*func)(void) );

  功能： 当程序终止执行时，函数调用函数指针func所指向的函数。可以执行多重调用(至少32个)，这些函数以其注册的倒序执行。执行成功返回零值，失败则返回非零值。

7.stdarg.h

  用于支持可变参数，定义了va_list这个结构：

1、type va_arg( va_list argptr, type );

2、void va_end( va_list argptr );

3、void va_start( va_list argptr, last_parm );

  功能： 宏va_arg()用于给函数传递可变长度的参数列表。

  首先，必须调用va_start() 传递有效的参数列表，va_list和函数强制的第一个参数。第一个参数代表将要传递的参数的个数。

  其次，调用va_arg()传递参数列表va_list 和将被返回的参数的类型。va_arg()的返回值是当前的参数。

  再次，对所有的参数重复调用va_arg()

  最后，调用va_end()传递va_list对完成后的清除是必须的。

  For example:

   int sum( int, … );

   int main( void ) {

   int answer = sum( 4, 4, 3, 2, 1 );

   printf( “The answer is %d\n”, answer );

   return( 0 );

   }

   int sum( int num, … ) {

   int answer = 0;

   va_list argptr;

   va_start( argptr, num );

   for( ; num > 0; num-- )

   answer += va_arg( argptr, int );

   va_end( argptr );

   return( answer );

   }

  这段代码显示10,他们是4+3+2+1。

8.signal.h

8.1.void ( signal( int signal, void ( func) (int)) ) (int);

  功能： 当函数收到参数signal所表示的信号，参数func 所指向的函数即被调用。func 可以被定制为信号句柄或以下的宏(定义在signal.h中):

  宏 解释

  SIG_DFL 默认信号处理

  SIG_IGN 忽略信号

  signal()返回先前为信号定义的函数地址，当错误发生返回SIG_ERR。

8.2.int raise( int signal );

  功能： 函数对程序发送指定的信号signal. 一些信号:
  信号      含义
  SIGABRT   终止错误
  SIGFPE     浮点错误
  SIGILL     无效指令
  SIGINT     用户输入
  SIGSEGV   非法内存存取
  SIGTERM   终止程序

  返回零值为成功，非零为失败。

9.assert.h

9.1.void assert( int exp );

  功能： 宏assert()用于错误检测。如果表达式的结果为零，宏写错误信息到STDERR并退出程序执行。如果宏NDEBUG已经定义，宏assert()将被忽略。

10.setjmp.h

10.1.int setjmp( jmp_buf envbuf );

  功能： 函数将系统栈保存于envbuf中，以供以后调用longjmp()。当第一次调用setjmp(),它的返回值为零。之后调用longjmp(),longjmp()的第二个参数即为setjmp()的返回值。是否有点疑问？请参阅longjmp().

10.2.void longjmp( jmp_buf envbuf, int status );

  功能： 函数使程序从前次对setjmp()的调用处继续执行。参数envbuf一般通过调用setjmp()设定。参数status 为setjmp()的返回值，用来指示不同地点longjmp()的执行. status 不能设定为零

11.conio.h

11.1._kbhit检查当前是否有键盘输入，有返回非0，没有返回0

  int __cdecl _kbhit (void);

11.2.getch接收用户输入的字符

  函数功能：这是一个不回显函数，当用户按下某个字符时，函数自动读取，无需按回车

  int __cdecl _getch(void);

  以上就是本次的分享了，希望对大家有所帮助，欢迎关注博主一起学习更多的新知识！