C库函数

内存处理

calloc

函数原型：void *calloc(size_ t n, size_t size)；
功 能： 在内存的动态存储区中分配n个长度为size的连续空间，函数返回一个指向分配起始地址的指针；如果分配不成功，返回NULL。
实现：http://blog.csdn.net/hzhzh007/article/details/6424638

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],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;
}