C库函数

内存处理

calloc

函数原型：void *calloc(size_ t n, size_t size)；

功 能： 在内存的动态存储区中分配n个长度为size的连续空间，函数返回一个指向分配起始地址的指针；如果分配不成功，返回NULL。

实现：/article/9628393.html

realloc

函数原型：extern void *realloc(void *mem_address, unsigned int newsize);

指针名=（数据类型*）realloc（要改变内存大小的指针名，新的大小）

先判断当前的指针是否有足够的连续空间，

如果有，扩大mem_address指向的地址，并且将mem_address返回，

如果空间不够，先按照newsize指定的大小分配空间，将原有数据从头到尾拷贝到新分配的内存区域，而后释放原来mem_address所指内存区域（注意：原来指针是自动释放，不需要使用free），同时返回新分配的内存区域的首地址。即重新分配存储器块的地址。

返回值：如果重新分配成功则返回指向被分配内存的指针，否则返回空指针NULL。

int *pn = (int*)malloc(5*sizeof(int));

for(i=0;i<5;i++)
pn[i]=i;

pn = (int*)realloc(pn,10*sizeof(int));

memset

函数原型：void *memset(void *s, int ch, size_t n);

功能：将s中前n个字节 （typedef unsigned int size_t ）用 ch 替换并返回 s 。

int a[5];
memset(a,1,20);
for(int i=0;i<5;i++)
cout<<a[i]<<" ";
cout<<endl;

输出为：16843009 16843009 16843009 16843009 16843009

memset函数也是以字节为单位进行赋值的。那么memset(a,1,20);的意思就是把20个字节的地址赋值成1，而int型是4个字节大小，因此一个整形为：0x01 01 01 01 = 16843009

assert

函数原型：void assert( int expression );

功能： expression 如果为假（即为0），那么它先向stderr打印一条出错信息，然后通过调用 abort 来终止程序运行。

头文件：#include

字符处理

strcspn

函数原型： size_t strcspn(const char *s1,const char *s2);

功能：顺序在字符串s1中搜寻与s2中字符的第一个相同字符，包括结束符NULL，返回这个字符在S1中第一次出现的位置。

#include <stdio.h>
//#include <syslib.h>
#include <string.h>

int main(void)
{
char *s="Golwden Global View";
char *r="onew";
int n;
clrscr();
n=strcspn(s,"\n\r\f\t\v");
printf("The first char both in s1 and s2 is: %c  %d\n",s
,n);
//getchar();
return 0;
}

n = 19;

strchr

函数原型：extern char *strchr(const char *s,char c)

功能：查找字符串s中首次出现字符c的位置

memchr

原型：extern void *memchr(const void *buf, int ch, size_t count);

功能：从buf所指内存区域的前count个字节查找字符ch。

说明：当第一次遇到字符ch时停止查找。如果成功，返回指向字符ch的指针；否则返回NULL。

用法：#include

memchr(buffer, 0, SIZE) - buffer;  //得到缓冲区字符串长度，为一个有符号类型
strlen(buffer);  //为无符号类型

strtok

原型：char *strtok(char s[], const char *delim);

功能：分解字符串为一组字符串。s为要分解的字符串，delim为分隔符字符串。首次调用时，s指向要分解的字符串，之后再次调用要把s设成NULL。strtok函数会破坏被分解字符串的完整，调用前和调用后的s已经不一样了。

#include<string.h>
#include<stdio.h>
int main(void)
{
char input[16]="abc,d";
char*p;
p=strtok(input,",");
if(p)
printf("%s\n",p);
p=strtok(NULL,",");
if(p)
printf("%s\n",p);
return0;
}

函数第一次调用需设置两个参数。第一次分割的结果，返回串中第一个 ‘,’ 之前的字符串,也就是上面的程序

第一次输出abc。

第二次调用该函数strtok(NULL,”,”),第一个参数设置为NULL。结果返回分割依据后面的字串，即

第二次输出d。

strtok是一个线程不安全的函数，因为它使用了静态分配的空间来存储被分割的字符串位置

线程安全的函数叫strtok_r,ca

strncmp

int strncmp(char *str1, char *str2, int maxlen);

数学函数

pow/pow10

函数原型：double pow（double x, double y），double pow10（int p）

功能： 指数函数(x的y次方) ，(10的p次方)

floor

double floor( double arg );

向下取整

floor(3.14) = 3.0

floor(9.999999) = 9.0

floor(-3.14) = -4.0

floor(-9.999999) = -10

输入输出

getchar

从stdio流中读字符，相当于getc(stdin），它从标准输入里读取下一个字符。返回类型为int型，返回值为用户输入的ASCⅡ码，出错返回-1。

while((ch = getchar()) != EOF)

putchar

函数原型：int putchar(int ch);

向终端输出一个字符。其格式为putchar(c)，其中c可以是被单引号（英文状态下）引起来的一个字符，可以是介于0~127之间的一个十进制整型数（包含0和127），也可以是事先用char定义好的一个字符型变量。

fopen

函数原型：FILE * fopen(const char * path,const char * mode);

mode:

rb+ 读写打开一个二进制文件，允许读写数据，文件必须存在。

wb+ 读写打开或建立一个二进制文件，允许读和写。

ab+ 读写打开一个二进制文件，允许读或在文件末追加数据。

所有带r的，都是文件必须存在的。

所有带w的，写时清零。

fgetc

原型：int fgetc(FILE *stream);

返回值：返回读到的字符

功能：从文件指针stream指向的文件中读取一个字符，读取一个字节后，光标位置后移一个字节。

* fgets

原型：char *fgets(char *buf, int n, FILE *stream);

功能：从文件结构体指针stream中读取数据，读取n- 1个字符，读取每次读取一行

当一行的字符数小于n-1时，会将’\n’换行符读入，大于n时不会读入换行符。如果缓冲区的字符数达到n- 1时停止读取，任何情况下一个NULL字符将加到buf末尾，使它成为一个字符串。

返回值：返回它的第一个参数buf（指向缓冲区的指针）

1. 当n<=0 时返回NULL，即空指针。

2. 当n=1 时，返回空串”“.

3. 如果读入成功，则返回缓冲区的地址。

4. 如果读入错误或遇到文件结尾(EOF)，则返回NULL.

参考：C语言文件操作之fgets（）

gets从标准输入设备读字符串函数。可以无限读取，不会判断上限，以回车结束读取，所以程序员应该确保buffer的空间足够大，以便在执行读操作时不发生溢出。

fgets(s, sizeof(s), stdin); //代替gets

例：

while(fgets(buffer,BUFFER_SIZE,fp) != NULL)
{
sscanf()  处理
}

http://baike.baidu.com/view/656654.htm

fputc

原型：int fputc (int c, File *fp)

返回值：在正常调用情况下，函数返回写入文件的字符的ASCII码值，出错时，返回EOF（-1）

功能：将字符ch写到文件指针fp所指向的文件的当前写指针的位置，当正确写入一个字符或一个字节的数据后，文件内部写指针会自动后移一个字节的位置。

fputs

原型：char *fputs(char const *buf,FILE *stream);

返回值：成功写入一个字符串后，文件的位置指针会自动后移，函数返回为一个非负整数；否则返回EOF

功能：向指定的文件写入一个字符串（不自动写入字符串结束标记符‘\0’）

fwrite

原型：size_ t fwrite(const void* buffer, size_ t size, size_t count, FILE* stream);

返回值：返回实际写入的数据块数目

功能：向文件写入一个数据块。以二进制形式对文件进行操作，不局限于文本文件

char a[10] = "abcdefgh";
int len = strlen(a);
int num = 0;
num = fwrite(a,sizeof(char),len+1,fp);  //需要多一个字符，将存储NULL字符，不然再调用fread时后面会出现乱码

fread

原型：size_ t fread ( void *buffer, size_ t size, size_t count, FILE *stream) ;

返回值：如果调用成功返回实际读取到的元素个数，如果不成功或读到文件末尾返回 0。

功能：从一个文件流中读数据，最多读取count个元素，每个元素size字节

fscanf

原型：int fscanf(FILE*stream,constchar *format,[argument…]);

返回值：整型，成功读入的参数的个数

功能：从一个流中执行格式化输入，即从一个流中格式化读入到后面的参数中，fscanf遇到空格和换行时结束，注意空格时也结束。这与fgets有区别，fgets遇到空格不结束。

使用方法：fscanf(fp , “%s %d %lf” , a , &b , &c); //读入到a,b,c中

sscanf

原型：int sscanf(const char *buffer,const char *format,[argument ]…);

返回值：成功则返回参数数目，失败则返回-1，错误原因存于errno中。

功能：从一个字符串中读进与指定格式相符的数据。

s=”12:34:56”;

sscanf(s,”%02d:%02d:%02d”,&hh,&mm,&ss);

取指定长度的字符串

http://baike.baidu.com/view/1364018.htm

scanf

使用方法： scanf(“%d”,&a) == 1，当无法再次读取a时返回0

fprintf

函数原型：int fprintf(FILE*stream,constchar *format,[argument])

返回值：正确调用时返回输出的字符数,发生错误时返回一个负值.

功能：格式化输出到一个流/文件中

使用方法：fprintf(stream,”%d\n”,i);

sprintf

函数原型：int sprintf( char *buffer, const char *format, [ argument] … );

返回值：字符串长度（strlen）

功能：把格式化的数据写入某个字符串缓冲区中（buffer）

使用方法：fprintf(stream,”%d\n”,i);

snprintf(tmp, sizeof(tmp), “%d.%d.%d.%d.”, p[0],p[1],p[2],p[3]);

时间函数

time

函数原型：time_t time(time_t * timer)

功能: 获取当前的系统时间，返回的结果是一个time_ t类型(或者返回timer指向的内容)，其实就是一个大整数，其值表示从CUT（Coordinated Universal Time）时间1970年1月1日00:00:00到当前时刻的秒数。然后调用localtime将time_t所表示的CUT时间转换为本地时间（我们是+8区，比CUT多8个小时）并转成struct tm类型，该类型的各数据成员分别表示年月日时分秒。

头文件：time.h

struct tm * tmp = localtime（&time(NULL)）;

ctime

函数原型：char *ctime(const time_t *time); time_t -> string

功 能: 把日期和时间转换为字符串，字符串的格式为：Sun Jul 4 04 04:02:48 1976\n\0

头文件:include

#ifndef __TIME_T
#define __TIME_T     /* 避免重复定义 time_t */
typedef long     time_t;    /* 时间值time_t 为长整型的别名*/
#endif

tm结构

struct tm
{
int tm_sec;
int tm_min;
int tm_hour;
int tm_mday;
int tm_mon;
int tm_year;
int tm_wday;
int tm_yday;
int tm_isdst;
};

asctime

函数原型：char* asctime (const struct tm * timeptr) struct tm -> string

char *ctime(const time_t *time);

功 能: 把timeptr指向的tm结构体中储存的时间转换为字符串字符串格式返回.

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

输出为：Thu Dec 22 09:30:01 1956

time_t biggest = 0x7FFFFFFF;
printf("%s",asctime(gmtime(&biggest)));

#include <time.h>
#include <stdio.h>

int main(void)
{
struct tm *p_tm;
time_t l_time_t;

l_time_t = time(NULL);

p_tm = localtime(&l_time_t);

printf("%s\n",asctime(p_tm));

printf("%s\n",ctime(&l_time_t));
return 0;
}

localtime

函数原型：struct tm *localtime(const time_t *clock); time_t -> struct tm

功 能：把从1970-1-1零点零分到当前时间系统所偏移的秒数时间转换为本地时间（经过时区变换）。而gmtime函数转换后的时间没有经过时区变换，是UTC时间。将一个time_t值转换为一个tm结构，方便访问日期。

返回值：返回指向tm 结构体的指针.tm结构体是time.h中定义的用于分别存储时间的各个量(年月日等)的结构体.

gmtime

函数原型：struct tm *gmtime(const time_t *time); time_t -> struct tm

功 能：把日期和时间转换为格林威治(GMT)时间,将参数time 所指的time_t 结构中的信息转换成真实世界所使用的时间日期表示方法，然后将结果由结构tm返回。将一个time _t值转换为一个tm结构，方便访问日期。

mktime

函数原型：time_t mktime(struct tm * timeptr); struct tm -> time_t

功 能：将参数timeptr所指的tm结构数据转换成从公元1970年1月1日0时0分0 秒算起至今的UTC时间所经过的秒数(即time_t类型的时间)。

difftime

功 能:返回两个time_t型变量之间的时间间隔，即计算两个时刻之间的时间差，转换为秒，返回一个double类型。

用 法: double difftime(time_t time2, time_t time1);

头文件：time.h

qsort 快速排序

功 能： 使用快速排序例程进行排序

头文件：stdlib.h

用 法： void qsort(void * base, int num_elem, int size_elem, int (fcmp)(const void ,const void *));

参数： 1 待排序数组首地址

2 数组中待排序元素数量

3 各元素的占用空间大小

4 指向函数的指针，用于确定排序的顺序

int comp(const void *a,const void *b)
{
return *(int*)a - *(int*)b;  //由小到大排序
}

//比较字符大小 从小到大
int cmp_char(const void *a,const void *b)
{
return *(char *)a - *(char *)b;
}

//比较字符串大小 从小到大
int cmp_string(const void *a,const void *b)
{
return strcmp((char *)a,(char *)b);
}

char word[2000][10]；
qsort(word,len,10,cmp_string);  //排序word[0 ~ len-1]个字符串

bsearch

函数原型：void bsearch(const void *key, const void *base, size_t nelem, size_t width, int(*fcmp)(const void , const *));

语法:

头文件：#include

网络

##inet_ntop

将“二进制整数” －> “点分十进制”

##inet_pton

随机数生成

rand函数在产生随机数前，需要系统提供的生成伪随机数序列的种子，rand根据这个种子的值产生一系列随机数。如果系统提供的种子没有变化，每次调用rand函数生成的伪随机数序列都是一样的。

srand(unsigned seed)通过参数seed改变系统提供的种子值，从而可以使得每次调用rand函数生成的伪随机数序列不同，从而实现真正意义上的“随机”。

通常可以利用系统时间来改变系统的种子值，即srand(time(NULL))，可以为rand函数提供不同的种子值，进而产生不同的随机数序列

srand((unsigned)time(NULL));   /*播种子，只需在整个程序中调用一次*/

for(i = 0; i < MAX; i++)
{
number[i] = rand() % 100;  /*产生100以内的随机整数*/
}

取意范围随机整数的公式：

rand()%(max-min+1) +min // 随机区间[min,max]

rand()%len + min; //len为区间的长度

随机区间[5,18]

=rand()%(18-5+1) +5

=rand()%14+5

//生成随机字符串
#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;

#define SIZE_CHAR 32
const char CCH[] = "_0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_";

int main()
{
srand((unsigned)time(NULL));
unsigned int sz = sizeof(CCH)/sizeof(CCH[0]);
int id;

char rd[SIZE_CHAR+1];
rd[SIZE_CHAR] = '\0';

for(int i=0; i<SIZE_CHAR; ++i)
{
//生成0~sz-1范围的数
id = rand()%sz;
cout<<"rand: "<<id<<endl;
rd[i] = CCH[id];
}
cout<<rd<<endl;
}

#include <iostream>
#include <string>
#include <cstdlib>
#include <ctime>

using namespace std;

#define SIZE_CHAR 32
const string g_sm("_0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_");
int main()
{
srand((unsigned)time(NULL));
unsigned int sz = sizeof(CCH)/sizeof(CCH[0]);

string s;

for(int i=0; i<SIZE_CHAR; ++i)
{
//生成0~sz-1范围的数
id = rand()%sz;
s += g_sm[id];   //此处用+=链接
//s[i] = g_sm[id];   //错误
cout<<s[i]<<endl;
}

cout<<s<<endl;
}