colben/fragment
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
colben
2021-08-29 00:02:47 +08:00
commit 01e8b33396
52 changed files with 4404 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
常用函数/ColbenFuns.c Normal file
View File

@@ -0,0 +1,32 @@
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <termios.h>
#include <unistd.h>
void gettoks(char *src,TOKS *toks,char *cut)
{
toks->count=0;
toks->tok=(char **)calloc(++(toks->count),sizeof(char *));
*(toks->tok)=strtok(src,cut);
while(NULL!=*(toks->tok+toks->count-1))
{
toks->tok=realloc(toks->tok,sizeof(char *)*(++(toks->count)));
*(toks->tok+toks->count-1)=strtok(NULL,cut);
}
(toks->count)--;
}
char getch( )
{
struct termios oldt, newt;
char ch;
tcgetattr( STDIN_FILENO, &oldt );
newt = oldt;
newt.c_lflag &= ~( ICANON | ECHO );
tcsetattr( STDIN_FILENO, TCSANOW, &newt );
ch = getchar();
tcsetattr( STDIN_FILENO, TCSANOW, &oldt );
return ch;
}

234
常用函数/gtk_functions.c Normal file
View File

@@ -0,0 +1,234 @@
//`pkg-config --cflags --libs gtk+-2.0` //编译标志
#include <gtk/gtk.h> //头文件
int main(int argc,char *argv[]) //主函数
{
gtk_init(&argc,&argv[]);
GtkWidget *window=gtk_window_new(GTK_WINDOW_TOPLEVEL); //有边框
GTK_WINDOW_POPUP //无边框
//控件操作
gtk_widget_show(window);
gtk_main();
return 0;
}
void gtk_window_set_title(GtkWindow *window,const gchar *title); //窗口标题
void gtk_widget_set_size_request(GtkWidget *widget,gint width,gint height); //窗口最小大小
void gtk_window_set_resizable(GtkWindow *window,gboolean resizable); //窗口伸缩
void gtk_window_set_position(GtkWindow *window,GtkWindowPosition position); //窗口位置
GTK_WIN_POS_NONE
GTK_WIN_POS_CENTER
GTK_WIN_POS_MOUSE
GTK_WIN_POS_CENTER_ALWAYS
GdkPixbuf *gdk_pixbuf_new_from_file(const gchar *filename,GError **error); //创建图片资源
NULL
GdkPixbuf *gdk_pixbuf_scale_simple(const GdkPixbuf *src,int dest_width,int dest_height,GdkInterpType interp_type); //设置图片大小
GDK_INTERP_BILINEAR
void g_object_unref(GtkObject *object); //释放资源
GtkWidget *gtk_image_new_from_pixbuf(GdkPixbuf *pixbuf); //通过资源创建图片控件
void gtk_image_set_from_pixbuf(GtkImage *image,GdkPixbuf *pixbuf); //设置图片控件图片
void gtk_image_clear(GtkImage *image); //清除图像控件里的图像数据
GtkWidget *gtk_button_new_with_lable(const gcahr *label); //创建带内容按钮
void gtk_button_set_label(GtkButton *button,const gchar *label); //设置按钮标签
const gchar *gtk_button_get_label(GtkButton *button); //获取按钮标签
void gtk_widget_set_sensitive(GtkWidget *widget,gboolean sensitive); //按钮使能
void gtk_button_set_image(GtkButton *button,GtkWidget *image); //设置按钮图片
void gtk_button_set_relief(GtkButton *button,GtkReliefStyle newstyle); //按钮透明度
GTK_RELIEF_NONE //按钮透明
void gtk_container_add(GtkContainer *container,GtkWidget *widget); //容器附加控件
gulong g_signal_connect(gpointer instance,const gchar *detailed_signal,GCallback c_handler,gpointer data); //信号连接回调
GtkWidget *gtk_hbox_new(gboolean homogeneous,gint spacing); //水平布局
GtkWidget *gtk_vbox_new(gboolean homogeneous,gint spacing); //垂直布局
GtkWidget *gtk_label_new(cost gchar *str); //创建标签
void gtk_label_set_text(GtkLabel *label,const gchar *str); //设置标签内容
const gchar *gtk_label_get_label(GtkLabel *label); //获取标签内容
GtkWidget *gtk_table_new(guint rows,guint columns,gboolean homogeneous); //表格布局
void gtk_table_attach_defaults(GtkTable *table,GtkWidget *widget,guint left_attach,guint right_attach,guint top_attach,guint bottom_attach); //表格布局附加控件
GtkWidget *gtk_fixed_new(); //固定布局
void gtk_fixed_put(GtkFixed *fixed,GtkWidget *widget,gint x,gint y); //固定布局附加控件
GtkWidget *gtk_entry_new(void); //行编辑
gtk_entry_set_visibility(GtkEntry *entry,gboolean visible); //行编辑显示
const gchar *gtk_entry_get_text(GtkEngry *entry); //获取行编辑内容
void gtk_entry_set_text(GtkEngry *entry,const gchar *text); //设置行编辑内容
"activate" //行编辑触发信号
GtkWidget *gtk_process_bar_new(); //进度条
void gtk_process_bar_set_fraction(GtkProgressBar *pbar,gdouble fraction); //设置进度条百分比
void gtk_process_bar_set_text(GtkProgressBar *pbar,gchar *text); //设置滑槽文本显示
void gtk_progress_bar_set_orientation(GtkProgressBar *pbar,GtkProgressBarOrientation orientation); //设置进度条移动方向
GTK_PROGRESS_LEFT_TO_RIGHT
GTK_PROGRESS_RIGHT_TO_LEFT
GTK_PROGRESS_BOTTOM_TO_TOP
GTK_PROGRESS_TOP_TO_BOTTOM
GtkWidget *gtk_scrolled_window_new(GtkAdjustment *hadjustment,GtkAdjustment *vadjustment); //滚动窗口
NULL NULL
void gtk_scolled_window_set_policy(GtkScolledWindow *scrolled_window,GtkPolicyTypehscrollbar_policy,GtkPolicyType vscrollbar_policy); //滚动条出现的方式
GTK_POLICY_AUTOMATIC
GTK_POLICY_ALWAYS
GTK_POLICY_NEVER
GtkWidget *gtk_clist_new_with_titles(gint columns,gchar *titles[]); //创建列表
void gtk_clist_set_column_width(GtkCList *clist,gint column,gint width); //设置列宽
void gtk_clist_set_column_justification(GtkCList *clist,gint column,GtkJustification justification); //对齐方式
GTK_JUSTIFY_LEFT
GTK_JUSTIFY_RIGHT
GTK_JUSTIFY_CENTER
GTK_JUSTIFY_CENTER
gint gtk_clist_append(GtkCList *clist,gchar *text[]); //列表添加行
void gtk_clist_clear(GtkCList *clist); //清空列表所有行
gint gtk_clist_get_text(GtkCList *clist,gint row,gint column,gchar **text); //获取某行某列内容
"select_row" //列表行出发信号
guint g_timeout_add(guint interval,GSourceFunc function,gpointer data); //创建定时器
gboolean g_source_remove(guint tag); //移除定时器
void gtk_widget_add_events(GtkWidget *widget,gint events); //控件捕获事件
GDK_BUTTON_PRESS_MASK
GDK_BUTTON_RELEASE_MASK
GDK_BUTTON_MOTION_MASK
GDK_KEY_PRESS_MASK
GDK_ENTER_NOTIFY_MASK
"button_press_event" //鼠标点击事件信号
"button_release_event" //鼠标释放事件信号
gboolean callback(GtkWidget *widget,GdkEventButton *event,gpointer data); //鼠标点击事件回调
event->x,event->y //获取点击坐标值
event->button //1左键，2中键，3右键
event->type //双击GDK_2BUTTON_PRESS
return TRUE;
"motion_notify_event" //鼠标移动事件信号
gboolean callback(GtkWidget *widget,GdkEventMotion *event,gpointer data); //鼠标移动事件回调
event->x,event->y //获取移动坐标值
return TRUE;
"key_press_event" //键盘按下事件的信号
"key_release_event" //键盘释放事件的信号
gboolean callback(GtkWidget *widget,GdkEventKey *event,gpointer data); //键盘按下事件回调
event->keyval //获取键值
return TRUE;
"expose_event" //曝光事件信号
gboolean callback(GtkWidget *widget,GdkEventExpose *event,gpointer data); //曝光事件回调
return FALSE;
#include <cairo.h> //Cairo绘图头文件
void gtk_widget_set_app_paintable(GtkWidgte *widget,gboolean app_paintable); //允许窗口绘图
cairo_t *gtk_cairo_create(GdkDrawable *drawable); //创建Cairo环境
drawable->window
void cairo_destroy(cairo_t *cr); //回收资源
void cairo_set_line_width(cairo_t *cr,double width); //设置线宽
void cairo_set_source_rgb(cairo_t *cr,double r,double g,double b); //设置颜色,r,g,b从0.0到1.0
void cairo_move_to(cairo_t *cr,double x,double y); //设置直线起点
void cairo_line_to(cairo_t *cr,double x,double y); //设置直线终点
void cairo_rectangle(cairo_t *cr,double x,double y,double width,double height); //设置矩形路径
void cairo_stroke(cairo_t *cr); //绘制cairo
void cairo_fill(cairo_t *cr); //填充cairo闭合路径
void cairo_select_font_face(cairo_t *cr,const char *family,cairo_font_slant_t slant,cairo_font_weight_t weight);
字体 倾斜 加粗
void cairo_set_font_size(cairo_t *cr,double size); //设置字体大小
void cairo_show_text(cairo_t *cr,const char *utf8); //显示字符串
gdk_cairo_set_source_pixbuf(cairo_t *cr,const GdkPixbuf *pixbuf,double pixbuf_x,double pixbuf_y); //设置画图图片
void cairo_paint(cairo_t *cr); //绘制图片
void gtk_widget_queue_draw(GtkWidget *widget); //刷新绘图区域
void gtk_thread_init(void) //gtk创建线程前调用/*{{{*/
{
if(FALSE == g_thread_supported())
{
g_thread_init(NULL);
}
gdk_threads_init();
}/*}}}*/
void *pthread_fun(void *data) //线程函数中操作界面需要封装/*{{{*/
{
gdk_threads_enter();
//一个或多个界面操作函数
gdk_threads_leave();
}/*}}}*/
/* 功能： 设置背景图
* widget: 主窗口
* w, h: 图片的大小
* path： 图片路径
*/
static void chang_background(GtkWidget *widget, int w, int h, const gchar *path)/*{{{*/
{
gtk_widget_set_app_paintable(widget, TRUE); //允许窗口可以绘图
gtk_widget_realize(widget);
/* 更改背景图时，图片会重叠
* 这时要手动调用下面的函数，让窗口绘图区域失效，产生窗口重绘制事件（即 expose 事件）。
*/
gtk_widget_queue_draw(widget);
GdkPixbuf *src_pixbuf = gdk_pixbuf_new_from_file(path, NULL); // 创建图片资源对象
// w, h是指定图片的宽度和高度
GdkPixbuf *dst_pixbuf = gdk_pixbuf_scale_simple(src_pixbuf, w, h, GDK_INTERP_BILINEAR);
GdkPixmap *pixmap = NULL;
/* 创建pixmap图像;
* NULL：不需要蒙版;
* 123： 0~255，透明到不透明
*/
gdk_pixbuf_render_pixmap_and_mask(dst_pixbuf, &pixmap, NULL, 128);
// 通过pixmap给widget设置一张背景图，最后一个参数必须为: FASLE
gdk_window_set_back_pixmap(widget->window, pixmap, FALSE);
// 释放资源
g_object_unref(src_pixbuf);
g_object_unref(dst_pixbuf);
g_object_unref(pixmap);
}/*}}}*/
/* 功能: 设置控件字体大小
* widget: 需要改变字体的控件
* size: 字体大小
* is_button: TRUE代表控件为按钮，FALSE为其它控件
*/
static void set_widget_font_size(GtkWidget *widget, int size, gboolean is_button)/*{{{*/
{
GtkWidget *labelChild;
PangoFontDescription *font;
gint fontSize = size;
font = pango_font_description_from_string("Sans"); //"Sans"字体名
pango_font_description_set_size(font, fontSize*PANGO_SCALE);//设置字体大小
if(is_button){
labelChild = gtk_bin_get_child(GTK_BIN(widget));//取出GtkButton里的label
}else{
labelChild = widget;
}
//设置label的字体，这样这个GtkButton上面显示的字体就变了
gtk_widget_modify_font(GTK_WIDGET(labelChild), font);
pango_font_description_free(font);
}/*}}}*/
// 给创建好的image重新设计一张图片
void load_image(GtkWidget *image, const char *file_path, const int w, const int h )/*{{{*/
{
gtk_image_clear( GTK_IMAGE(image) ); // 清除图像
GdkPixbuf *src_pixbuf = gdk_pixbuf_new_from_file(file_path, NULL); // 创建图片资源
GdkPixbuf *dest_pixbuf = gdk_pixbuf_scale_simple(src_pixbuf, w, h, GDK_INTERP_BILINEAR); // 指定大小
gtk_image_set_from_pixbuf(GTK_IMAGE(image), dest_pixbuf); // 图片控件重新设置一张图片(pixbuf)
g_object_unref(src_pixbuf); // 释放资源
g_object_unref(dest_pixbuf); // 释放资源
}/*}}}*/
/***********************************************
* 函数功能:设置窗口显示字体颜色
* 参数类型:widget:需要改变颜色的控件
color_buf:设置字体颜色，如"red"、"blue"
is_button:是否为button
* 返回类型:成功返回0，失败返回-1
* 维护记录:2013-12-18 by lihuibo
***********************************************/
int sungtk_widget_set_font_color(GtkWidget *widget, const char *color_buf, gboolean is_button)/*{{{*/
{
if(widget == NULL && color_buf==NULL)
return -1;
GdkColor color;
GtkWidget *labelChild = NULL;
sungtk_color_get(color_buf, &color);
if(is_button == TRUE){
labelChild = gtk_bin_get_child(GTK_BIN(widget));//取出GtkButton里的label
gtk_widget_modify_fg(labelChild, GTK_STATE_NORMAL, &color);
gtk_widget_modify_fg(labelChild, GTK_STATE_SELECTED, &color);
gtk_widget_modify_fg(labelChild, GTK_STATE_PRELIGHT, &color);
}else{
gtk_widget_modify_fg(widget, GTK_STATE_NORMAL, &color);
}
return 0;
}/*}}}*/

114
常用函数/netword_functions.c Normal file
View File

@@ -0,0 +1,114 @@
#include <arpa/inet.h> //字节序、地址转换头文件
uint32_t htonl(uint32_t hostint32); //32位主机字节序转换成网络字节序，成功返回网络字节序的值
uint16_t htons(uint16_t hostint16); //16位主机字节序转换成网络字节序，成功返回网络字节序的值
uint32_t ntohl(uint32_t netint32); //32位网络字节序转换成主机字节序，成功返回主机字节序的值
uint16_t ntohs(uint16_t netint16); //16位网络自己序转换成主机字节序，成功返回主机字节序的值
int inet_pton(int family,const char *strptr,void *addrptr); //点分十进制数串转换成32位无符号整数，成功返回1
const char *inet_ntop(int family,const void *addrptr,char *strptr,size_t len); //32位无符号整数转换成点分十进制数串，成功返回首地址，失败NULL
INET_ADDRSTRLEN 16
INET6_ADDRSTRLEN 16
#include <sys/socket.h> //套接字头文件
int socket(int family,int type, int protocol); //创建套接字，成功返套接字
AF_INET SOCK_DGRAM 0
AF_INET6 SOCK_STREAM IPPROTO_TCP
PF_PACKET SOCK_RAW IPPROTO_UDP
#include <netinet/in.h> //地址结构头文件
struct in_addr
{
in_addr_t s_addr; //4 byte
};
struct sockaddr_in //ipv4套接字地址结构，定义时使用
{
sa_family_t sin_family; //2 byte
in_port_t sin_port; //2byte
struct in_addr sin_addr; //4 byte
char sin_zero[8]; //8 byte
};
struct sockaddr //通用套接字地址结，接口函数调用时使用
{
sa_family_t sa_family; //2 byte
char sa_data[14]; //14 byte
};
//INADDR_ANY 本地通配地址，值为0
ssize_t sendto(int sockfd,const void *buf,size_t nbytes,int flags,const struct sockaddr *to,socklen_t addrlen); //发送UDP数据至to指定的ip，成功返回发送字节数，失败返回-1
0
int bind(int sockfd,const struct sockaddr *myaddr,socklen_t addrlen); //绑定本地协议地址和sockfd，成功返回0
ssize_t recvfrom(int sockfd,void *buf,size_t nbytes,int flags,struct sockaddr *from,socklen_t *addrlen); //接收UDP数据，保存至from指向的结构，成功返回接收到的字符数，失败-1
0
//TFTP:简单文件传送协议，基于UDP，无用户有效认证，数据传输模式有二进制模式octet和文本模式netascii
//69号端口等待客户端请求，临时端口与客户端通信，每个数据包变化从1开始，需客户端ACK确认，超时重发
//TCP客户端：知道“服务器”的ip、port，主动连接
#include <sys/socket.h> //TCP客户端头文件
int connect(int sockfd,const struct sockaddr *addr,socklen_t len); //主动连接服务器，成功返回0
ssize_t send(int sockfd,const void *buf,size_t nbytes,int flags); //发送数据，返回成功发送的字节数，不能发送0长度的数据包
ssize_t recv(int sockfd,void *buf,size_t nbytes,int flags); //接受网络数据，返回成功接收的字节数
//TCP服务器具备确定地址，明确是服务器，等待连接
int listen(int sockfd,int backlog); //套接字主动变被动，成功返回0
int accept(int sockfd,struct sockaddr *cliaddr,socklen_t *addrlen); //从已连接队列中取出一个，否则阻塞，返回已连接套接字
//关闭一个已连接套接字将导致另一端接收到一个0长度的数据包
//----------------------------------------------------------------------------
//多线程TCP服务器并发
#include <stdio.h>/*{{{*/
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <netinet/in.h>/*}}}*/
void *client_fun(void *arg) //与客户端交互线程
{
int connect_fd=(int)arg; //客户端套接字
close(connect_fd);
return NULL;
}
int main(int argc,char *argv[])
{
int sock_fd=socket(AF_INET,SOCK_STREAM,0); //创建sockfd/*{{{*/
if(0 > sock_fd)
{
perror("\nsocket>>>\n");
return -1;
}
struct sockaddr_in own_addr,client_addr; //服务器自身和客户端地址结构
bzero(&own_addr,sizeof(own_addr));
own_addr.sin_family=AF_INET;
own_addr.sin_port=htons(8000);
own_addr.sin_addr.s_addr=htonl(INADDR_ANY);
socklen_t own_addr_len=sizeof(own_addr); //地址结构长度
socklen_t client_addr_len=sizeof(client_addr);
if(0 != bind(sock_fd,(struct sockaddr *)&own_addr,own_addr_len)) //绑定
{
perror("\nbind>>>\n");
close(sock_fd);
return -2;
}
if(0 != listen(sock_fd,10)) //监听
{
perror("\nlisten>>>\n");
close(sock_fd);
return -3;
}/*}}}*/
while(1)
{
bzero(&client_addr,sizeof(client_addr));
int connect_fd=accept(sock_fd,(struct sockaddr *)&client_addr,&client_addr_len);
pthread_t tid;
pthread_create(&tid,NULL,(void *)client_fun,(void *)connect_fd);
pthread_detach(tid);
}
close(sock_fd); //关闭监听套接字
return 0;
}
//--------------------------------------------------------------------------------

BIN
常用函数/posix定义的取消点1.bmp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 746 KiB

BIN
常用函数/posix定义的取消点2.bmp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 2.2 MiB

67
常用函数/sql_functions.c Normal file
View File

@@ -0,0 +1,67 @@
//integer:带符号整形（最多64位）
//real:8字节浮点
//text:字符，无大小限制
//bolb:任意类型，无大小限制
//null:空值
//! sqlite3 *.db 创建或打开*.db文件
//! .quit或.exit 退出数据库
//create table 表名称 (列名称 数据类型,……); 创建表
//primary key 主键，每个表只能有一个，其列数据不可重复
//.tables 查看表
//.schema 查看表结构
//alter table 表名 add 列名 数据类型; 添加新列
//alter table 表名 rename to 新表名; 修改表名
//drop table 表名称; 删除表
//insert into 表名 values (列值……); 插入新行并赋值，字符串加‘’号
//insert into 表名 (列名……) values (列值……); 插入新行部分赋值
//update 表名 set 列……=值…… 匹配条件; 修改where匹配行的列值，空匹配所有
//delete from 表名 匹配条件; 删除匹配行
//select * from 表名 匹配条件;
//select 列名…… from 表名 匹配条件; 从表中选取数据
//.mode colum 左对齐列
//.headers on 列名显示
//where 列名 in (列值……) 在where子句中规定多个值
//where 列1=值1 and 列2=值2 and ... 多个条件与
//where 列1=值1 or 列2=值2 or ... 多个条件或
//where 列名 between A and B 选取A、B之间的数据范围
//where 列名 like 列值 数字相当于“=”，字符串可用“%”通配
//where 列名 not in/between/like ...
//where not 列1=值1 and/or 列2=值2 and/or ... 原结果集补集
//order by 列名 (desc) 根据指定列对结果集排序，用dest降序
//begin; 开始一个事务
//commit; 确认begin后的全部命令
//rollback; 取消begin后的所有操作
int sqlite3_open(char *db_name,sqlite3 **db); //打开数据库，成功返回SQLITE_OK
int sqlite3_close(sqlite3 *db); //关闭数据库，成功返回SQLITE_OK，链接时添加 -lpthread 和 -ldl两个库
int sqlite3_exec(sqlite3 *db,const char *sql,exechandler_t callback,void *arg,char **errmsg); //执行sql语句，若结果集不空，回调下面callback
typedef int (*exechandler_t)(void *para,int n_column,char **column_value,char **column_name);
int sqlite3_get_table(sqlite3 *db,const char *sql,char ***resultp,int *nrow,int *ncolumn,char **errmsg); //执行sql语句，结果集保存在resultp中
void sqlite3_free_table(char **resultp); //释放sqlite3_get_table分配的内存
//函数
//length() 返回字符串长度
//lower() 将字符串转换为小写
//upper() 将字符串转换为大写
//select 函数名(列名) from 表名;
//聚集函数
//avg() 返回某列的平均值
//count() 返回某列的行数
//max() 返回某列的最大值
//min() 返回某列的最小值
//sum() 返回某列值之和
//select 列名…… from 表名 group by 列名; 根据某一属性重新分组，出现在where子句之后
//select 函数名 (列名) …… from 表名 group by 列名 having 函数名 (列名) 限制值; 查看满足having条件的分组
//主键惟一标识一行，对用户无意义，常用语索引，勿更新，无动态变化数据，由计算机自动生成
//unique 用法同主键，保证一个列中数据惟一，可以有多个，可以修改和更新
//create table 表名 (列名 数据类型 check (判断语句)); 保证某列数据满足一定条件
//select 列名…… from 表…… where 判断语句; 用“.”分隔表名和列名
//create view 视图名 as 语句; 创建视图
//drop view 视图名; 删除视图
//create trigger 触发器名 before/after insert/update/delete on 表名
//begin 语句; end;
//datetime('now') 获取当前系统时间
//.tables 查看触发器
//drop trigger 触发器名; 删除触发器
//create index 索引名 on 表名(列名); //创建索引
//.indices 查看索引
//drop index 索引名； 删除索引

205
常用函数/sys_functions.c Normal file
View File

@@ -0,0 +1,205 @@
//#######################################################################
FILE *fopen(const char *path, const char *mode); //打开文件，失败返回NULL
//参数说明：
//参数path字符串包含欲打开的文件路径及文件名，参数mode字符串则代表着流形态。
//mode有下列几种形态字符串:
//r 以只读方式打开文件，该文件必须存在。
//r+ 以可读写方式打开文件，该文件必须存在。
//rb+ 读写打开一个二进制文件，允许读写数据，文件必须存在。
//rw+ 读写打开一个文本文件，允许读和写。
//w 打开只写文件，若文件存在则文件长度清为0，即该文件内容会消失。若文件不存在则建立该文件。
//w+ 打开可读写文件，若文件存在则文件长度清为零，即该文件内容会消失。若文件不存在则建立该文件。
//a 以附加的方式打开只写文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，即文件原先的内容会被保留。（EOF符保留）
//a+ 以附加方式打开可读写的文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾后，即文件原先的内容会被保留。 （原来的EOF符不保留）
//wb 只写打开或新建一个二进制文件；只允许写数据。
//wb+ 读写打开或建立一个二进制文件，允许读和写。
//ab+ 读写打开一个二进制文件，允许读或在文件末追加数据。
//at+ 打开一个叫string的文件，a表示append,就是说写入处理的时候是接着原来文件已有内容写入，不是从头写入覆盖掉，t表示打开文件的类型是文本文件，+号表示对文件既可以读也可以写。
//上述的形态字符串都可以再加一个b字符，如rb、w+b或ab+等组合，加入b 字符用来告诉函数库以二进制模式打开文件。如果不加b，表示默认加了t，即rt,wt,其中t表示以文本模式打开文件。由fopen()所建立的新文件会具有S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH(0666)权限，此文件权限也会参考umask值。
//有些C编译系统可能不完全提供所有这些功能，有的C版本不用"r+","w+","a+",而用"rw","wr","ar"等，读者注意所用系统的规定。
int fclose(FILE *stream); //关闭一个文件流，成功返回0, 失败返回EOF
int feof(FILE *stream); //文件结束返回非0
int fseek(FILE *stream, long offset, int fromwhere); //文件位置指针偏移，成功返回0
//0文件头，1当前，2文件尾
long ftell(FILE *stream); //返回文件位置指针当前位置
int fgetc(FILE *stream); //结尾或出错返回EOF
int fputc(int n, FILE *fp); //失败返回EOF
char *fgets(char *buf, int bufsize, FILE *stream); //出错返回NULL
int fputs(const char *str, FILE *fp); //向文件写入字符串，失败返回EOF
size_t fread(void *buffer, size_t size, size_t count, FILE *stream); //读取文件中count*size个字节，成功返回读取到的元素个数(count)，否则返回0
size_t fwrite(const void *buffer, size_t size, size_t count, FILE *stream); //返回实际写入的数据块数目
int fscanf(FILE *stream, const char *format, [argument...]);
int fprintf(FILE *stream, const char *format, [argument...]);
//#######################################################################
#define STDIN_FILENO 0 //标准输入
#define STDOUT_FILENO 1 //标准输出
#define STDERR_FILENO 2 //标准错误
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h> //open、close头文件
int open(const char *pathname,int flags); //文件存在
int open(const char *pathname,int flags,mode_t mode); //文件不存在
//成功返回fd，失败返回-1
int close (int fd); //关闭文件，成功返回0,失败返回-1
#include <unistd.h> //write,read,remove头文件
ssize_t write(int fd,const void *addr,size_t count); //写文件，成功返回写入字节个数，失败返回-1
ssize_t read(int fd,void *addr,size_t count); //读文件，成功返回读出字节个数，失败返回-1
int remove(const char *pathname); //删除文件,成功返回0,失败返回-1
#include <sys/types.h>
#include <unistd.h> //进程函数头文件
pid_t getpid(); //获取本进程号
pid_t getppid(); //获取父进程号
pid_t getpgid(); //获取进程组号
pid_t fork(); //在已有进程中创建子进程
//成功，子进程返回0,父进程返回子进程ID；失败，返回-1
unsigned int sleep(unsigned int sec); //进程挂起指定秒数
//成功返回0,中断返回剩余秒数
#include <sys/wait.h> //wait、waitpid头文件
pid_t wait(int *status); //等待子进程结束回收其资源
//成功返回子进程号，失败返回-1
WIFEXITED(status); //子进程正常终止取出字段值非零
WEXITSTATUS(status) //返回保存在status变量8~16位的子进程退出状态（正常退出才可使用）
pid_t waitpid(pid_t pid,int *status,int options); //等待子进程结束回收其资源
//成功返回子进程号，失败返回-1
#include <stdlib.h> //exit头文件
void exit(int value); //结束进程执行
#include <unistd.h> //_exit头文件，value低八位有效
void _exit(int value); //结束进程执行，value低八位有效
#include <stdlib.h> //atexit头文件
int atexit(void (*function)(void)); //注册进程结束前调用的函数
pid_t vfork(); //创建子进程，出错返回-1
#include <unistd.h> //exec函数组头文件
int execl(const char *pathname,const char *arg0,...,NULL);
int execlp(const char *filename,const char *arg0,...,NULL);
int execle(const char *pathname,const char *arg0,...,NULL,char *const envp[]);
int execv(const char *pathname,char *const argv[]);
int execvp(const char *filename,char *const argv[]);
int execve(const char *pathname,char *const argv[],char *const envp[]);
//exec函数组成功无返回，失败返回-1
#include <stdlib.h> //system头文件
int system(const char *command); //调用系统命令，command空时返回非0,失败返回127或-1
//Ctrl+c产生中断信号:SIGINT
//Ctrl+\产生中断信号:SIGQUIT
//Ctrl+z产生中断信号:SIGSTOP
//SIGKILL和SIGSTOP的处理方式不可更改
#include <sys/types.h>
#include <signal.h> //kill头文件
int kill(pid_t pid,int signum); //给进程发送信号，成功返回0,失败返回-1
#include <unistd.h> //alarm头文件
unsigned int alarm(unsigned int seconds); //seconds秒后发出SIGALRM信号，默认终止
#include <signal.h> //raise头文件
int raise(int signum); //给进程发送信号，成功返回0,失败返回-1
#include <stdlib.h> //abort头文件
void abort(); //默认向进程发送SIGABRT信号，默认退出
//终止前刷新缓冲区，关闭文件描述符
#include <unistd.h> //pause头文件
int pause(); //挂起进程直至捕捉到信号，成功返回-1
#include <signal.h> //signal头文件
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum,sighandler_t handler); //注册信号处理函数
SIG_IGN //忽略信号
SIG_DFL //执行默认动作
自定义
#include <signal.h> //信号集头文件
int sigemptyset(sigset_t *set); //初始化一个空信号集，成功返回0,失败返回-1
int sigfillset(sigset_t *set); //初始化为所有信号的集合，成功返回0,失败返回-1
int sigismember(const sigset_t *set,int signum); //查询signum是否在set中，在返回1,不在返回0,错误返回-1
int sigaddset(sigset_t *set,int signum); //加signum到set中，成功返回0,失败返回-1
int sigdelset(sigset_t *set,int signum); //从set中删除signum，成功返回0,失败返回-1
int sigprocmask(int how,const sigset_t *set,sigset_t *oldset); //编辑阻塞集，成功返回0,失败返回-1
SIG_BLOCK //添加set集合
SIG_UNBLOCK //删除set集合
SIG_SETMASK //设置为set集合
#include <unistd.h> //管道头文件
int pipe(int fd[2]); //创建pipe，成功返回0,失败返回-1
void fcntl(fd,F_SETFL,0); //设置文件阻塞
O_NONBLOCK //设置文件非阻塞
int dup(int oldfd); //成功返回新文件描述符，失败返回-1
int dup2(int oldfd,int newfd); //强制分配并返回newfd，失败返回-1
//close_on_exec 标志决定文件描述符在执行exec之后是否可用
int flags;
flags=fcntl(fd,F_GETFD); //获得标志
flags|=FD_CLOEXEC; //打开标志位
flags&=~FD_CLOEXEC; //关闭标志位
fcntl(fd,F_SETFD,flags); //设置标志
#include <sys/types.h>
#include <sys/stat.h> //mkfifo头文件
int mkfifo(const char *pathname,mode_t mode); //创建fifo，成功返回0,文件已存在返回-1
//不指定NONBLOCK
//open只读打开FIFO，阻塞至某进程为写打开FIFO
//open只写打开FIFO，阻塞至某进程为读打开FIFO
//open以只读只写打开FIFO，调用read阻塞
//通信中写退出，read不阻塞，写恢复，read阻塞
//通信中读退出，写进程也退出
//缓冲区满时write阻塞
//open以可读可写打开FIFO，open不阻塞，read阻塞，缓冲区满时write阻塞
#include <sys/types.h>
#include <sys/ipc.h> //ftok头文件
key_t ftok(const char *pathname, int proj_id); //获取IPC键值，成功返回key，失败返回-1
#include <sys/msg.h> //msgget头文件
int msgget(key_t,int msgflg); //创建消息队列,成功返回消息队列标识符，失败返回-1
typedef struct
{
long mtype;
char mtext[100];
}MSG; //消息格式
int msgsnd(int msgid,const void *msgp,size_t msgsz,int msgflg); //添加消息到队列，成功返回0,失败返回-1
ssize_t msgrcv(int msgid,void *msgp,size_t msgsz,long msgtyp,int msgflg); //接收消息，成功返回读取消息的长度，失败返回-1
int msgctl(int msgid,int cmd,struct msgid_ds *buf); //控制消息队列属性，成功返回0,失败返回-1
IPC_RMID
#include <sys/ipc.h>
#include <sys/types.h>
#include <sys/shm.h> //共享内存头文件
int shmget(key_t key,size_t size,int shmflg); //创建或打开共享内存，成功返回共享内存标识符，失败返回-1
void *shmat(int shmid,const void *shmaddr,int shmflg); //映射，成功返回映射地址，失败返回-1
NULL 0
int shmdt(const void *shmaddr); //分离共享内存，成功返回0,失败返回-1
int shmctl(int shmid,int cmd,struct shmid_ds *buf); //共享内存控制，成功返回0,失败返回-1
IPC_RMID //删除
void *shmat(int shmid,const void *shmaddr,int shmflg); //映射，成功返回映射地址，失败返回-1
#include <pthread.h> //线程头文件，编译加参数 -lpthread
int pthread_create(pthread_t *thread,const thread_attr_t *attr,void *(*start_routine)(void *),void *arg); //创建线程
NULL
int pthread_join(pthread_t thread,void **retval); //等子进程结束回收资源，成功返回0,失败返回非0,有阻塞
int pthread_detach(pthread_t thread); //独立线程，终止时系统回收资源，成功返回0,失败返回非0
//不终止进程的前提下终止线程
//1 线程从执行函数中返回
//2 线程调用pthread_exit
//3 被其他线程取消
void pthread_exit(void *retval); //退出线程
int pthread_cancel(pthread_t thread); //发送取消线程信号，成功返回0,失败返回出错编号，无阻塞
pthread_setcancelstate(int state,int *old_state); //设置线程是否可被取消，默认是
PTHREAD_CANCEL_DISABLE //不可取消
PTHREAD_CANCEL_ENABEL //可以取消
//出现取消点的函数见posix*.bmp
void pthread_setcanceltype(int type,int *oldtype); //立即终止线程
PTHREAD_CANCEL_ASYNCHRONOUS //立即取消
PTHREAD_CANCEL_DEFERRED //不立即取消
void pthread_cleanup_push(void (*routine)(void *),void *arg); //注册线程清理函数
void pthread_cleanup_pop(int execute); //删除清理函数，0==execute?不清理：清理
//调用清理函数
//1 调用pthread_exit退出线程
//2 相应其他线程取消要求
//3 非零execute调用pthread_cleanup_pop
int pthread_mutex_init(pthread_mutex_t *mutex,const pthread_mutexattr_t *arrt); //初始化互斥锁，成功返回0,失败返回非0
NULL //默认属性
int pthread_mutex_lock(pthread_mutex_t *mutex); //上锁，阻塞至解锁，成功返回0,失败返回非0
int pthread_mutex_trylock(pthread_mutex_t *mutex); //上锁，否则立即返回，成功返回0,失败返回非0，非阻塞
int pthread_mutex_unlock(pthread_mutex_t *mutex); //解锁，成功返回0,失败非0
int pthread_mutex_destroy(pthread_mutex_t *mutex); //销毁锁，成功返回0,失败返回非0
#include <semaphore.h> //信号量头文件
int sem_init(sem_t *sem,int pshared,unsigned int value); //创建初始化信号量，成功返回0,失败返回-1
//pshared==0?线程：进程
//信号初始值
int sem_wait(sem_t *sem); //信号量值减1,小于0阻塞，成功返回0,失败返回-1
int sem_trywait(sem_t *sem); //同上，不阻塞
int sem_post(sem_t *sem); //信号值加1等待唤醒，阻塞，成功返回0,失败返回-1
int sem_getvalue(sem_t *sem,int *sval); //sval保存sem标识，成功返回0,失败返回-1
int sem_destroy(sem_t *sem); //删除信号量，成功返回0,失败返回-1
//进程间通信一般用有名信号量
#include <fcntl.h>
#include <sys/stat.h>
#include <semaphore.h> //有名信号量头文件
sem_t *sem_open(const char *name,int oflag,mode_t mode,unsigned int value); //创建信号量，成功返回信号量地址，失败返回SEM_FAILED
int sem_close(sem_t *sem); //关闭有名信号量，成功返回0,失败返回-1
int sem_unlink(const char *name); //删除有名信号量文件，成功返回0,失败返回-1