
平台论坛博客文库

› 论坛 › 程序设计 › C/C++ › 本人写的一个完整C范型容器（纯MACRO实现）。

12 3 4 5 6 / 6 页下一页

本人写的一个完整C范型容器（纯MACRO实现）。 [复制链接]

emacsnw

小富即安

论坛徽章:: 0

电梯直达

1楼 [收藏(0)] [报告]

发表于 2006-05-23 04:44 |只看该作者 |倒序浏览

首先要申明的是，此容器宏包成型与C++ STL之前，由于我长期在C下面从事编程，因此自己写了这么一个包。我贴在论坛仅供大家参考之用，绝无一点让大家舍弃STL之意思。再次强调，由于此宏包由纯MACRO实现，绝无依赖任何类库，因此适用与一切C或C++程序。

这个容器类的功能几乎涵盖了STL里面对应vector, stack, queue等一切功能，支持动态调整大小，支持很多算法：binary search, sort, parallel sort （这个功能我觉得非常有用，为了实现这个功能，我自己改写了非递归的quick sort算法--在sort系列函数中使用）。

不多说了，下面分别贴 README，gvec.h，test.c。

文库|博客

emacsnw

小富即安

论坛徽章:: 0

2楼 [报告]

发表于 2006-05-23 04:46 |只看该作者

README:

License: BSD license, new version.
You can use any BSD licensed codes freely. In addition, you do not have to make your codes open-source (as required in GPL) if you used BSD licensed codes. You can freely redistribute your codes even for commercial purposes, as long as you mention all the BSD licensed codes you used.

/*
* gvec.h
* General Vector Macros
*
* VECTOR DECLARATION
* Predeclared vector structs:
* vec(int), vec(double), vec(char), vec(float)
* vec2(int), vec2(double), vec2(char), vec2(float)
* Or declare your own vector. For instance to declare a vector of
* typedef struct type_t mytype: VEC_DECLARE(mytype)
* Then declare the nested (two dimensional) vector for type_t if
* you need: VEC_DECLARE(vec(mytype))
* To declare variables for a vector type:
* vec(int) vi,vi2;
* vec2(int) vvi;
* vec2(double) vvd,vvd2;
* vec(mytype) vt;
*
* VECTOR INITIALIZATION
* Before you can use a VEC_ type variable, you must first initialize:
* vec_init(int,vi);
* vec_initc(int,vi2,vi);
* vec2_initn(int,vvi,20,vi);
*
* SUPPORTED VECTOR OPERATION MACROS, ALL THE FOLLOWING MACROS HAVE THE
* CORRESPONDING vec2_ VERSION THAT WORKS FOR NESTED VECTORS
*
* INITIALIZATION AND DESTRUCTION
* vec_init(type,v) //initialize v as an empty vector
* vec_inita(type,v,a,n) //initialize from array a with n elements
* vec2_inita(type,v,a,m,n) //the two dimensional (m by n) version
* vec_initc(type,v,y) //copy-constructor like initialization (v = y)
* vec_initn(type,v,n,y) //initialize with n duplications of y
* vec_clear(type,v) //clear v, and you can immediately use it again
* vec_free(type,v) //free memory; call vec_init* to use it again
* STATCK/QUEUE OPERATIONS
* vec_push(type,v,y) //push y into v's back-end
* vec_pushback(type,v,y) //ditto
* vec_pushfront(type,v,y) //push y into v's front-end
* vec_pop(type,v,y) //pop v's back-end into y
* vec_popback(type,v,y) //ditto
* vec_popfront(type,v,y) // pop v's front-end into y
* vec_deque(type,v,y) //same as vec_popfront
* vec_enque(type,v,y) //same as vec_pushback
* vec_length(type,v) //return v's # of elements
* vec_empty(type,v) //return 1 iff v is empty
* vec_back(type,v,y) //get back-end element into y; don't pop it
* vec_front(type,v,y) //get front-end element into y; don't pop it
* vec_top(type,v) //get the back-end elements; you can modify it directly
* ALGORITHMS/OPERATIONS
* vec_sort(type,v,_op_) //quick-sort: ascending (_op_=<) or descending (_op_=>) orders
* vec_sortp(type,v,typeu,u,_op_) //parallel sort v and u (sort v, adjust u accordingly)
* vec_sortc(type,v,cmpr) //quick-sort using a comparison function cmpr
* vec_sortpc(type,v,typeu,u,cmpr) //parallel sort v and u, using cmpr
* vec_bsearch(type,v,y,ret) //binary search in (sorted) v for y, put index in ret
* vec_find(type,v,y,ret) //search in v for y, put index in ret, ret=-1 if not found
* vec_setlength(type,v,l,y) //set length of v to l, pad with element y if necessary
* vec_reducelength(type,v,by) //reduce length of v by the given ammount
* vec_append(type,des,src) //append another vector src to the end of des
* vec_del(type,v,idx) //delete the idx-th element, result not in original ordering
* vec_insert(type,v,y,idx) //insert into v the element y at index idx
* vec_remove(type,v,idx) //delete the idx-th element, keep everything else in order
* vec_replace(type,v,a,b) //replace all occurrences of a's with b's
* vec_reverse(type,v) //reverse all elements in v
* MISCELLANEOUS
* vec_printf(type,v,fmt) //print out v using format fmt (" %d", ",%f" for instances)
* vec_save(type,v,fmt) //ditto
* vec_scanf(type,v,fmt) //read v from stdin using format fmt
* vec_load(type,v,fmt) //ditto
* vec_swap(type,des,src) //swap two vectors des and src
* vec_cpy(type,des,src) //copy src to des
* vec_equal(type,v,u,ret) //ret=1 iff v and u have the same elements for all indices
*/

复制代码

[ 本帖最后由 emacsnw 于 2006-5-30 07:47 编辑 ]

实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？

emacsnw

小富即安

论坛徽章:: 0

3楼 [报告]

发表于 2006-05-23 04:49 |只看该作者

gvec.h （由于系统最多每贴20000字节，因此分两贴发）

/*
* Copyright (c) 2006, emacsnw <emacsnw@gmail.com>
* All rights reserved.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _GVEC_H_
#define _GVEC_H_
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#define VEC_DECLARE(type)\
struct _VEC_##type{\
int vsize,asize;\
type *x;\
};\
typedef struct _VEC_##type VEC_##type
#define vec(type) VEC_##type
#define vec2(type) VEC_VEC_##type
VEC_DECLARE(int);
VEC_DECLARE(double);
VEC_DECLARE(char);
VEC_DECLARE(float);
VEC_DECLARE(VEC_int);
VEC_DECLARE(VEC_double);
VEC_DECLARE(VEC_char);
VEC_DECLARE(VEC_float);
#define _swap(type,a,b)\
do{\
type _sw_tmp;\
_sw_tmp = a,a = b,b = _sw_tmp;\
}while(0)
#define vec_append(type,des,src)\
do{\
int _ap_i,_ap_m = src.vsize;\
for(_ap_i = 0;_ap_i<_ap_m;++_ap_i)\
vec_push(type,des,src.x[_ap_i]);\
}while(0)
#define vec2_append(type,des,src)\
do{\
int _ap__i,_ap__m = src.vsize;\
for(_ap__i = 0;_ap__i<_ap__m;++_ap__i)\
vec2_push(type,des,src.x[_ap__i]);\
}while(0)
#define vec_back(type,v,y) y = vec_top(type,v)
#define vec2_back(type,v,y) vec_cpy(type,y,vec2_top(type,v))
#define _vec_bsearch(v,y,ret)\
do{\
int _bs_l = 0,_bs_r = v.vsize,_bs_m;\
while(_bs_l<_bs_r){\
_bs_m = (_bs_l+_bs_r)>>1;\
if(v.x[_bs_m]<y) _bs_l = _bs_m+1;\
else if(v.x[_bs_m]>y) _bs_r = _bs_m;\
else{\
ret = _bs_m;\
break;\
}\
}\
ret = _bs_l;\
}while(0)
#define vec_bsearch(type,v,y,ret) _vec_bsearch(v,y,ret)
#define vec_clear(type,v)\
do{\
vec_free(type,v);\
vec_init(type,v);\
}while(0)
#define vec2_clear(type,v)\
do{\
vec2_free(type,v);\
vec2_init(type,v);\
}while(0)
#define vec_cpy(type,des,src)\
do{\
vec_free(type,des);\
vec_initc(type,des,src);\
}while(0)
#define vec2_cpy(type,des,src)\
do{\
vec2_free(type,des);\
vec2_initc(type,des,src);\
}while(0)
#define vec_del(type,v,idx)\
do{\
v.x[idx] = v.x[v.vsize-1];\
vec_reducelength(type,v,1);\
}while(0)
#define vec2_del(type,v,idx)\
do{\
vec_cpy(type,v.x[idx],v.x[v.vsize-1]);\
vec2_reducelength(type,v,1);\
}while(0)
#define vec_deque(type,v,y) vec_popfront(type,v,y)
#define vec2_deque(type,v,y) vec2_popfront(type,v,y)
#define _vec_empty(v) (v.vsize==0)
#define vec_empty(type,v) _vec_empty(v)
#define _vec2_empty(v) _vec_empty(v)
#define vec2_empty(type,v) _vec2_empty(v)
#define vec_enque(type,v,y) vec_pushback(type,v,y)
#define vec2_enque(type,v,y) vec2_pushback(type,v,y)
#define vec_equal(type,v,u,ret)\
do{\
int _eq_i,_eq_m = v.vsize;\
ret = 0;\
if(_eq_m!=u.vsize) break;\
for(_eq_i = 0;_eq_i<_eq_m;++_eq_i)\
if(v.x[_eq_i]!=u.x[_eq_i]) break;\
if(_eq_i==_eq_m) ret = 1;\
}while(0)
#define vec2_equal(type,v,u,ret)\
do{\
int _eq__i,_eq__ret,_eq__m = v.vsize;\
ret = 0;\
if(_eq__m!=u.vsize) break;\
for(_eq__i = 0;_eq__i<_eq__m;++_eq__i){\
vec_equal(type,v.x[_eq__i],u.x[_eq__i],_eq__ret);\
if(_eq__ret==0) break;\
}\
if(_eq__i==_eq__m) ret = 1;\
}while(0)
#define _vec_find(v,y,ret)\
do{\
int _fi_i,_fi_m = v.vsize;\
ret = -1;\
for(_fi_i = 0;_fi_i<_fi_m;++_fi_i)\
if(v.x[_fi_i]==y){\
ret = _fi_i;\
break;\
}\
}while(0)
#define vec_find(type,v,y,ret) _vec_find(v,y,ret)
#define vec2_find(type,v,y,ret)\
do{\
int _fi__i,_fi__ret,_fi__m = v.vsize;\
ret = -1;\
for(_fi__i = 0;_fi__i<_fi__m;++_fi__i){\
vec_equal(type,v.x[_fi__i],y,_fi__ret);\
if(_fi__ret){\
ret = _fi__i;\
break;\
}\
}\
}while(0)
#define _vec_free(v)\
do{\
if(v.asize) free(v.x);\
v.vsize = v.asize = 0;\
}while(0)
#define vec_free(type,v) _vec_free(v)
#define _vec2_free(v)\
do{\
int _fr__i,_fr__m = v.vsize;\
for(_fr__i = 0;_fr__i<_fr__m;++_fr__i)\
_vec_free(v.x[_fr__i]);\
if(v.asize) free(v.x);\
v.vsize = v.asize = 0;\
}while(0)
#define vec2_free(type,v) _vec2_free(v)
#define vec_front(type,v,y)\
do{\
if(!vec_empty(type,v)) y = v.x[0];\
}while(0)
#define vec2_front(type,v,y)\
do{\
if(!vec2_empty(type,v)) vec_cpy(type,y,v.x[0]);\
}while(0)
#define vec_init(type,v)\
do{\
v.vsize = 0,v.asize = 10;\
v.x = (type *)malloc(v.asize*sizeof(type));\
assert(v.x);\
}while(0)
#define vec2_init(type,v)\
do{\
v.vsize = 0,v.asize = 10;\
v.x = (VEC_##type *)malloc(v.asize*sizeof(VEC_##type));\
assert(v.x);\
}while(0)
#define vec_inita(type,v,a,n)\
do{\
int _ca_i,_ca_m = (n);\
v.vsize = _ca_m;\
if(_ca_m==0) v.asize = 10;\
else v.asize = _ca_m;\
v.x = (type *)malloc(v.asize*sizeof(type));\
assert(v.x);\
for(_ca_i = 0;_ca_i<_ca_m;++_ca_i) v.x[_ca_i] = a[_ca_i];\
}while(0)
#define vec2_inita(type,v,a,m,n)\
do{\
int _ca__i,_ca__m = (m),_ca__n = (n);\
v.vsize = _ca__m;\
if(_ca__m==0) v.asize = 10;\
else v.asize = _ca__m;\
v.x = (VEC_##type *)malloc(v.asize*sizeof(VEC_##type));\
assert(v.x);\
for(_ca__i = 0;_ca__i<_ca__m;++_ca__i)\
vec_inita(type,v.x[_ca__i],a[_ca__i],_ca__n);\
}while(0)
#define vec_initc(type,v,y)\
do{\
int _ci_i,_ci_m = y.vsize;\
v.vsize = _ci_m;\
if(_ci_m==0) v.asize = 10;\
else v.asize = _ci_m;\
v.x = (type *)malloc(v.asize*sizeof(type));\
assert(v.x);\
for(_ci_i = 0;_ci_i<_ci_m;++_ci_i) v.x[_ci_i] = y.x[_ci_i];\
}while(0)
#define vec2_initc(type,v,y)\
do{\
int _ci__i,_ci__m = y.vsize;\
v.vsize = _ci__m;\
if(_ci__m==0) v.asize = 10;\
else v.asize = _ci__m;\
v.x = (VEC_##type *)malloc(v.asize*sizeof(VEC_##type));\
assert(v.x);\
for(_ci__i = 0;_ci__i<_ci__m;++_ci__i)\
vec_initc(type,v.x[_ci__i],y.x[_ci__i]);\
}while(0)
#define vec_initn(type,v,n,y)\
do{\
int _ni_i;\
v.vsize = v.asize = (n);\
v.x = (type *)malloc((n)*sizeof(type));\
assert(v.x);\
for(_ni_i = 0;_ni_i<(n);++_i) v.x[_ni_i] = (y);\
}while(0)
#define vec2_initn(type,v,n,y)\
do{\
int _ni__i;\
v.vsize = v.asize = (n);\
v.x = (VEC_##type *)malloc((n)*sizeof(VEC_##type));\
assert(v.x);\
for(_ni__i = 0;_ni__i<(n);++_ni__i)\
vec_initc(type,v.x[_ni__i],y);\
}while(0)
#define vec_insert(type,v,y,idx)\
do{\
int _in_i,_in_m = v.vsize,_in_idx = (idx);\
if(_in_idx>_in_m) _in_idx = _in_m;\
vec_push(type,v,y);\
for(_in_i = _in_m;_in_i>_in_idx;--_in_i)\
_swap(type,v.x[_in_i],v.x[_in_i-1]);\
}while(0)
#define vec2_insert(type,v,y,idx)\
do{\
int _in__i,_in__m = v.vsize,_in__idx = (idx);\
if(_in__idx>_in__m) _in__idx = _in__m;\
vec2_push(type,v,y);\
for(_in__i = _in__m;_in__i>_in__idx;--_in__i)\
vec_swap(type,v.x[_in__i],v.x[_in__i-1]);\
}while(0)
#define _vec_length(v) v.vsize
#define vec_length(type,v) _vec_length(v)
#define _vec2_length(v) _vec_length(v)
#define vec2_length(type,v) _vec2_length(v)
#define vec_load(type,v,fmt) vec_scanf(type,v,fmt)
#define vec2_load(type,v,fmt) vec2_scanf(type,v,fmt)
#define vec_pop(type,v,y)\
do{\
if(!vec_empty(type,v)){\
y = vec_top(type,v);\
vec_reducelength(type,v,1);\
}\
}while(0)
#define vec2_pop(type,v,y)\
do{\
if(!vec2_empty(type,v)){\
y = vec2_top(type,v);\
vec2_reducelength(type,v,1);\
}\
}while(0)
#define vec_popback(type,v,y) vec_pop(type,v,y)
#define vec2_popback(type,v,y) vec2_pop(type,v,y)
#define vec_popfront(type,v,y)\
do{\
if(!vec_empty(type,v)){\
vec_front(type,v,y);\
vec_remove(type,v,0);\
}\
}while(0)
#define vec2_popfront(type,v,y)\
do{\
if(!vec2_empty(type,v)){\
vec2_front(type,v,y);\
vec2_remove(type,v,0);\
}\
}while(0)
#define _vec_printf(v,fmt)\
do{\
int _pr_i,_pr_m = v.vsize;\
printf("%d",_pr_m);\
for(_pr_i = 0;_pr_i<_pr_m;++_pr_i) printf(fmt,v.x[_pr_i]);\
printf("\n");\
}while(0)
#define vec_printf(type,v,fmt) _vec_printf(v,fmt)
#define _vec2_printf(v,fmt)\
do{\
int _pr__i,_pr__m = v.vsize;\
printf("%d\n",_pr__m);\
for(_pr__i = 0;_pr__i<_pr__m;++_pr__i)\
_vec_printf(v.x[_pr__i],fmt);\
}while(0)
#define vec2_printf(type,v,fmt) _vec2_printf(v,fmt)
#define vec_push(type,v,y)\
do{\
int _pu_i,_pu_nasize,_pu_m = v.vsize;\
type *_pu_nx;\
if(_pu_m<v.asize){\
v.x[_pu_m] = y;\
v.vsize++;\
}else{\
_pu_nasize = v.asize * 2;\
_pu_nx = (type *)malloc(_pu_nasize*sizeof(type));\
assert(_pu_nx);\
for(_pu_i = 0;_pu_i<_pu_m;++_pu_i)\
_pu_nx[_pu_i] = v.x[_pu_i];\
_pu_nx[_pu_m] = y;\
free(v.x);\
v.x = _pu_nx;\
v.vsize = _pu_m+1;\
v.asize = _pu_nasize;\
}\
}while(0)
#define vec2_push(type,v,y)\
do{\
int _pu__i,_pu__nasize,_pu__m = v.vsize;\
VEC_##type *_pu__nx;\
if(_pu__m<v.asize){\
vec_initc(type,v.x[_pu__m],y);\
v.vsize++;\
}else{\
_pu__nasize = v.asize * 2;\
_pu__nx = (VEC_##type *)malloc(_pu__nasize*sizeof(VEC_##type));\
assert(_pu__nx);\
for(_pu__i = 0;_pu__i<_pu__m;++_pu__i)\
vec_initc(type,_pu__nx[_pu__i],v.x[_pu__i]);\
vec_initc(type,_pu__nx[_pu__m],y);\
vec2_free(type,v);\
v.x = _pu__nx;\
v.vsize = _pu__m+1;\
v.asize = _pu__nasize;\
}\
}while(0)
#define vec_pushback(type,v,y) vec_push(type,v,y)
#define vec2_pushback(type,v,y) vec2_push(type,v,y)
#define vec_pushfront(type,v,y) vec_insert(type,v,y,0)
#define vec2_pushfront(type,v,y) vec2_insert(type,v,y,0)
#define vec_reducelength(type,v,by)\
do{\
int _re_i,_re_nasize,_re_m = v.vsize-(by);\
type *_re_nx;\
if((by)==0) break;\
if(_re_m<=v.asize/2){\
for(_re_nasize = v.asize;_re_nasize/2>=_re_m && \
_re_nasize>3;_re_nasize /= 2);\
_re_nx = (type *)malloc(_re_nasize*sizeof(type));\
assert(_re_nx);\
for(_re_i = 0;_re_i<_re_m;++_re_i)\
_re_nx[_re_i] = v.x[_re_i];\
free(v.x);\
v.x = _re_nx;\
v.asize = _re_nasize;\
}\
v.vsize = _re_m;\
}while(0)
#define vec2_reducelength(type,v,by)\
do{\
int _re__i,_re__nasize,_re__m = v.vsize-(by);\
VEC_##type *_re__nx;\
if((by)==0) break;\
if(_re__m>v.asize/2){\
for(_re__i = _re__m;_re__i<v.vsize;++_re__i)\
vec_free(type,v.x[_re__i]);\
v.vsize = _re__m;\
}else{\
for(_re__nasize = v.asize;_re__nasize/2>=_re__m && \
_re__nasize>3;_re__nasize /= 2);\
_re__nx = (VEC_##type *)malloc(_re__nasize*sizeof(VEC_##type));\
assert(_re__nx);\
for(_re__i = 0;_re__i<_re__m;++_re__i)\
vec_initc(type,_re__nx[_re__i],v.x[_re__i]);\
vec2_free(type,v);\
v.x = _re__nx;\
v.vsize = _re__m;\
v.asize = _re__nasize;\
}\
}while(0)
#define vec_remove(type,v,idx)\
do{\
int _rm_i,_rm_m = v.vsize;\
for(_rm_i = idx;_rm_i<_rm_m-1;++_rm_i)\
v.x[_rm_i] = v.x[_rm_i+1];\
vec_reducelength(type,v,1);\
}while(0)
#define vec2_remove(type,v,idx)\
do{\
int _rm__i,_rm__m = v.vsize;\
for(_rm__i = idx;_rm__i<_rm__m-1;++_rm__i)\
vec_cpy(type,v.x[_rm__i],v.x[_rm__i+1]);\
vec2_reducelength(type,v,1);\
}while(0)
#define vec_replace(type,v,a,b)\
do{\
int _rp_i,_rp_m = v.vsize;\
for(_rp_i = 0;_rp_i<_rp_m;++_rp_i)\
if(v.x[_rp_i]==(a)) v.x[_rp_i] = (b);\
}while(0)
#define vec2_replace(type,v,a,b)\
do{\
int _rp__i,_rp__ret,_rp__m = v.vsize;\
for(_rp__i = 0;_rp__i<_rp__m;++_rp__i){\
vec_equal(type,v.x[_rp__i],a,_rp__ret);\
if(_rp__ret) vec_cpy(type,v.x[_rp__i],b);\
}\
}while(0)
#define vec_reverse(type,v)\
do{\
int _rv_i,_rv_m = v.vsize,_rv_mid = _rv_m/2;\
if(_rv_m<=1) break;\
for(_rv_i = 0;_rv_i<_rv_mid;++_rv_i)\
_swap(type,v.x[_rv_i],v.x[_rv_m-_rv_i-1]);\
}while(0)
#define vec2_reverse(type,v)\
do{\
int _rv__i,_rv__m = v.vsize,_rv__mid = _rv__m/2;\
if(_rv__m<=1) break;\
for(_rv__i = 0;_rv__i<_rv__mid;++_rv__i)\
vec_swap(type,v.x[_rv__i],v.x[_rv__m-_rv__i-1]);\
}while(0)
#define vec_save(type,v,fmt) vec_printf(type,v,fmt)
#define vec2_save(type,v,fmt) vec2_printf(type,v,fmt)
#define vec_scanf(type,v,fmt)\
do{\
int _sc_i,_sc_m;\
type _sc_y;\
vec_clear(type,v);\
scanf("%d",&_sc_m);\
for(_sc_i = 0;_sc_i<_sc_m;++_sc_i){\
scanf(fmt,&_sc_y);\
vec_push(type,v,_sc_y);\
}\
}while(0)
#define vec2_scanf(type,v,fmt)\
do{\
int _sc__i,_sc__m;\
VEC_##type _sc__y;\
vec2_clear(type,v);\
scanf("%d",&_sc__m);\
for(_sc__i = 0;_sc__i<_sc__m;++_sc__i){\
vec_init(type,_sc__y);\
vec_scanf(type,_sc__y,fmt);\
vec2_push(type,v,_sc__y);\
vec_free(type,_sc__y);\
}\
}while(0);
#define vec_setlength(type,v,l,y)\
do{\
int _se_i,_se_nasize,_se_m = v.vsize;\
type *_se_nx;\
if((l)<=_se_m) vec_reducelength(type,v,_se_m-(l));\
else if((l)<=v.asize){\
for(_se_i = _se_m;_se_i<(l);++_se_i) v.x[_se_i] = y;\
v.vsize = (l);\
}else{\
for(_se_nasize = v.asize;_se_nasize<(l);_se_nasize *= 2);\
_se_nx = (type *)malloc(_se_nasize*sizeof(type));\
assert(_se_nx);\
for(_se_i = 0;_se_i<_se_m;++_se_i)\
_se_nx[_se_i] = v.x[_se_i];\
for(_se_i = _se_m;_se_i<(l);++_se_i) _se_nx[_se_i] = y;\
free(v.x);\
v.vsize = (l);\
v.asize = _se_nasize;\
v.x = _se_nx;\
}\
}while(0)
#define vec2_setlength(type,v,l,y)\
do{\
int _se__i,_se__nasize,_se__m = v.vsize;\
VEC_##type *_se__nx;\
if((l)<=_se__m) vec2_reducelength(type,v,_se__m-(l));\
else if((l)<=v.asize){\
for(_se__i = _se__m;_se__i<(l);++_se__i)\
vec_initc(type,v.x[_se__i],y);\
v.vsize = (l);\
}else{\
for(_se__nasize = v.asize;_se__nasize<(l);_se__nasize *= 2);\
_se__nx = (VEC_##type *)malloc(_se__nasize*sizeof(VEC_##type));\
assert(_se__nx);\
for(_se__i = 0;_se__i<_se__m;++_se__i)\
vec_initc(type,_se__nx[_se__i],v.x[_se__i]);\
for(_se__i = _se__m;_se__i<(l);++_se__i)\
vec_initc(type,_se__nx[_se__i],y);\
vec2_free(type,v);\
v.vsize = (l);\
v.asize = _se__nasize;\
v.x = _se__nx;\
}\
}while(0)

复制代码

[ 本帖最后由 emacsnw 于 2006-5-30 08:23 编辑 ]

emacsnw

小富即安

论坛徽章:: 0

4楼 [报告]

发表于 2006-05-23 04:50 |只看该作者

gvec.h (part 2)

#define vec_sort(type,v,_op_)\
do{\
int _so_i,_so_ir = v.vsize-1,_so_j,_so_k,_so_l = 0;\
int _so_istack[50],_so_jstack = -1;\
type _so_a;\
for(;;){\
if(_so_ir-_so_l<7){\
for(_so_j = _so_l+1;_so_j<=_so_ir;++_so_j){\
_so_a = v.x[_so_j];\
for(_so_i = _so_j-1;_so_i>=_so_l;--_so_i){\
if(!(_so_a _op_ v.x[_so_i])) break;\
v.x[_so_i+1] = v.x[_so_i];\
}\
v.x[_so_i+1] = _so_a;\
}\
if(_so_jstack==-1) break;\
_so_ir = _so_istack[_so_jstack];\
_so_l = _so_istack[_so_jstack-1];\
_so_jstack -= 2;\
}else{\
_so_k = (_so_l+_so_ir)>>1;\
_swap(type,v.x[_so_k],v.x[_so_l+1]);\
if(v.x[_so_ir] _op_ v.x[_so_l])\
_swap(type,v.x[_so_l],v.x[_so_ir]);\
if(v.x[_so_ir] _op_ v.x[_so_l+1])\
_swap(type,v.x[_so_l+1],v.x[_so_ir]);\
if(v.x[_so_l+1] _op_ v.x[_so_l])\
_swap(type,v.x[_so_l],v.x[_so_l+1]);\
_so_i = _so_l+1,_so_j = _so_ir;\
_so_a = v.x[_so_l+1];\
for(;;){\
do ++_so_i; while(v.x[_so_i] _op_ _so_a);\
do --_so_j; while(_so_a _op_ v.x[_so_j]);\
if(_so_j<_so_i) break;\
_swap(type,v.x[_so_i],v.x[_so_j]);\
}\
v.x[_so_l+1] = v.x[_so_j];\
v.x[_so_j] = _so_a;\
_so_jstack += 2;\
if(_so_ir-_so_i+1>=_so_j-_so_l){\
_so_istack[_so_jstack] = _so_ir;\
_so_istack[_so_jstack-1] = _so_i;\
_so_ir = _so_j-1;\
}else{\
_so_istack[_so_jstack] = _so_j-1;\
_so_istack[_so_jstack-1] = _so_l;\
_so_l = _so_i;\
}\
}\
}\
}while(0)
#define vec_sortp(type,v,typeu,u,_op_)\
do{\
int _so_i,_so_ir = v.vsize-1,_so_j,_so_k,_so_l = 0;\
int _so_istack[50],_so_jstack = -1;\
type _so_a;\
typeu _so_b;\
for(;;){\
if(_so_ir-_so_l<7){\
for(_so_j = _so_l+1;_so_j<=_so_ir;++_so_j){\
_so_a = v.x[_so_j];\
_so_b = u.x[_so_j];\
for(_so_i = _so_j-1;_so_i>=_so_l;--_so_i){\
if(!(_so_a _op_ v.x[_so_i])) break;\
v.x[_so_i+1] = v.x[_so_i];\
u.x[_so_i+1] = u.x[_so_i];\
}\
v.x[_so_i+1] = _so_a;\
u.x[_so_i+1] = _so_b;\
}\
if(_so_jstack==-1) break;\
_so_ir = _so_istack[_so_jstack];\
_so_l = _so_istack[_so_jstack-1];\
_so_jstack -= 2;\
}else{\
_so_k = (_so_l+_so_ir)>>1;\
_swap(type,v.x[_so_k],v.x[_so_l+1]);\
_swap(typeu,u.x[_so_k],u.x[_so_l+1]);\
if(v.x[_so_ir] _op_ v.x[_so_l]){\
_swap(type,v.x[_so_l],v.x[_so_ir]);\
_swap(typeu,u.x[_so_l],u.x[_so_ir]);\
}\
if(v.x[_so_ir] _op_ v.x[_so_l+1]){\
_swap(type,v.x[_so_l+1],v.x[_so_ir]);\
_swap(typeu,u.x[_so_l+1],u.x[_so_ir]);\
}\
if(v.x[_so_l+1] _op_ v.x[_so_l]){\
_swap(type,v.x[_so_l],v.x[_so_l+1]);\
_swap(typeu,u.x[_so_l],u.x[_so_l+1]);\
}\
_so_i = _so_l+1,_so_j = _so_ir;\
_so_a = v.x[_so_l+1];\
_so_b = u.x[_so_l+1];\
for(;;){\
do ++_so_i; while(v.x[_so_i] _op_ _so_a);\
do --_so_j; while(_so_a _op_ v.x[_so_j]);\
if(_so_j<_so_i) break;\
_swap(type,v.x[_so_i],v.x[_so_j]);\
_swap(typeu,u.x[_so_i],u.x[_so_j]);\
}\
v.x[_so_l+1] = v.x[_so_j];\
v.x[_so_j] = _so_a;\
u.x[_so_l+1] = u.x[_so_j];\
u.x[_so_j] = _so_b;\
_so_jstack += 2;\
if(_so_ir-_so_i+1>=_so_j-_so_l){\
_so_istack[_so_jstack] = _so_ir;\
_so_istack[_so_jstack-1] = _so_i;\
_so_ir = _so_j-1;\
}else{\
_so_istack[_so_jstack] = _so_j-1;\
_so_istack[_so_jstack-1] = _so_l;\
_so_l = _so_i;\
}\
}\
}\
}while(0)
#define vec_sortc(type,v,cmpr)\
do{\
int _so_i,_so_ir = v.vsize-1,_so_j,_so_k,_so_l = 0;\
int _so_istack[50],_so_jstack = -1;\
type _so_a;\
for(;;){\
if(_so_ir-_so_l<7){\
for(_so_j = _so_l+1;_so_j<=_so_ir;++_so_j){\
_so_a = v.x[_so_j];\
for(_so_i = _so_j-1;_so_i>=_so_l;--_so_i){\
if(cmpr(&_so_a,&(v.x[_so_i]))>0) break;\
v.x[_so_i+1] = v.x[_so_i];\
}\
v.x[_so_i+1] = _so_a;\
}\
if(_so_jstack==-1) break;\
_so_ir = _so_istack[_so_jstack];\
_so_l = _so_istack[_so_jstack-1];\
_so_jstack -= 2;\
}else{\
_so_k = (_so_l+_so_ir)>>1;\
_swap(type,v.x[_so_k],v.x[_so_l+1]);\
if(cmpr(&(v.x[_so_ir]),&(v.x[_so_l]))<=0)\
_swap(type,v.x[_so_l],v.x[_so_ir]);\
if(cmpr(&(v.x[_so_ir]),&(v.x[_so_l+1]))<=0)\
_swap(type,v.x[_so_l+1],v.x[_so_ir]);\
if(cmpr(&(v.x[_so_l+1]),&(v.x[_so_l]))<=0)\
_swap(type,v.x[_so_l],v.x[_so_l+1]);\
_so_i = _so_l+1,_so_j = _so_ir;\
_so_a = v.x[_so_l+1];\
for(;;){\
do ++_so_i; while(cmpr(&(v.x[_so_i]),&_so_a)<=0);\
do --_so_j; while(cmpr(&_so_a,&(v.x[_so_j]))<=0);\
if(_so_j<_so_i) break;\
_swap(type,v.x[_so_i],v.x[_so_j]);\
}\
v.x[_so_l+1] = v.x[_so_j];\
v.x[_so_j] = _so_a;\
_so_jstack += 2;\
if(_so_ir-_so_i+1>=_so_j-_so_l){\
_so_istack[_so_jstack] = _so_ir;\
_so_istack[_so_jstack-1] = _so_i;\
_so_ir = _so_j-1;\
}else{\
_so_istack[_so_jstack] = _so_j-1;\
_so_istack[_so_jstack-1] = _so_l;\
_so_l = _so_i;\
}\
}\
}\
}while(0)
#define vec_sortpc(type,v,typeu,u,cmpr)\
do{\
int _so_i,_so_ir = v.vsize-1,_so_j,_so_k,_so_l = 0;\
int _so_istack[50],_so_jstack = -1;\
type _so_a;\
typeu _so_b;\
for(;;){\
if(_so_ir-_so_l<7){\
for(_so_j = _so_l+1;_so_j<=_so_ir;++_so_j){\
_so_a = v.x[_so_j];\
_so_b = u.x[_so_j];\
for(_so_i = _so_j-1;_so_i>=_so_l;--_so_i){\
if(cmpr(&_so_a,&(v.x[_so_i]))>0) break;\
v.x[_so_i+1] = v.x[_so_i];\
u.x[_so_i+1] = u.x[_so_i];\
}\
v.x[_so_i+1] = _so_a;\
u.x[_so_i+1] = _so_b;\
}\
if(_so_jstack==-1) break;\
_so_ir = _so_istack[_so_jstack];\
_so_l = _so_istack[_so_jstack-1];\
_so_jstack -= 2;\
}else{\
_so_k = (_so_l+_so_ir)>>1;\
_swap(type,v.x[_so_k],v.x[_so_l+1]);\
_swap(typeu,u.x[_so_k],u.x[_so_l+1]);\
if(cmpr(&(v.x[_so_ir]),&(v.x[_so_l]))<=0){\
_swap(type,v.x[_so_l],v.x[_so_ir]);\
_swap(typeu,u.x[_so_l],u.x[_so_ir]);\
}\
if(cmpr(&(v.x[_so_ir]),&(v.x[_so_l+1]))<=0){\
_swap(type,v.x[_so_l+1],v.x[_so_ir]);\
_swap(typeu,u.x[_so_l+1],u.x[_so_ir]);\
}\
if(cmpr(&(v.x[_so_l+1]),&(v.x[_so_l]))<=0){\
_swap(type,v.x[_so_l],v.x[_so_l+1]);\
_swap(typeu,u.x[_so_l],u.x[_so_l+1]);\
}\
_so_i = _so_l+1,_so_j = _so_ir;\
_so_a = v.x[_so_l+1];\
_so_b = u.x[_so_l+1];\
for(;;){\
do ++_so_i; while(cmpr(&(v.x[_so_i]),&_so_a)<=0);\
do --_so_j; while(cmpr(&_so_a,&(v.x[_so_j]))<=0);\
if(_so_j<_so_i) break;\
_swap(type,v.x[_so_i],v.x[_so_j]);\
_swap(typeu,u.x[_so_i],u.x[_so_j]);\
}\
v.x[_so_l+1] = v.x[_so_j];\
v.x[_so_j] = _so_a;\
u.x[_so_l+1] = u.x[_so_j];\
u.x[_so_j] = _so_b;\
_so_jstack += 2;\
if(_so_ir-_so_i+1>=_so_j-_so_l){\
_so_istack[_so_jstack] = _so_ir;\
_so_istack[_so_jstack-1] = _so_i;\
_so_ir = _so_j-1;\
}else{\
_so_istack[_so_jstack] = _so_j-1;\
_so_istack[_so_jstack-1] = _so_l;\
_so_l = _so_i;\
}\
}\
}\
}while(0)
#define vec_swap(type,des,src)\
do{\
_swap(int,des.vsize,src.vsize);\
_swap(int,des.asize,src.asize);\
_swap(type *,des.x,src.x);\
}while(0)
#define vec2_swap(type,des,src)\
do{\
_swap(int,des.vsize,src.vsize);\
_swap(int,des.asize,src.asize);\
_swap(VEC_##type *,des.x,src.x);\
}while(0)
#define _vec_top(v) (v.x[v.vsize-1])
#define vec_top(type,v) _vec_top(v)
#define _vec2_top(v) _vec_top(v)
#define vec2_top(type,v) _vec2_top(v)
#endif

复制代码

[ 本帖最后由 emacsnw 于 2006-5-30 07:58 编辑 ]

emacsnw

小富即安

论坛徽章:: 0

5楼 [报告]

发表于 2006-05-23 04:52 |只看该作者

test.c 一个简单的应用gvec.h程序，附输出。

#include <time.h>
#include "gvec.h"
int main()
{
int i;
vec(int) vi,vi2;
vec2(int) vvi;
srand((unsigned)time(0));
vec_init(int,vi);
for(i = 0;i<20;++i)
vec_pushback(int,vi,rand()%20);
vec_initc(int,vi2,vi);
printf("\nvi2:\n");
vec_printf(int,vi2,",%d");
vec_sort(int,vi2,<);
printf("\nvi2 after sorting in ascending order:\n");
vec_printf(int,vi2,",%d");
vec_cpy(int,vi2,vi);
printf("\nvi2:\n");
vec_printf(int,vi2," %d");
printf("\nvi2 after sorting in descending order:\n");
vec_sort(int,vi2,>);
vec_printf(int,vi2," %d");
vec2_initn(int,vvi,10,vi);
for(i = 0;i<vvi.vsize;++i)
vec_remove(int,vvi.x[i],i);
vec2_reducelength(int,vvi,4);
for(i = 0;i<vvi.vsize;++i)
vec_reducelength(int,vvi.x[i],5+i);
vec2_pushfront(int,vvi,vi);
printf("\nvvi:\n");
vec2_printf(int,vvi," %d");
printf("\nvi,vi2:\n");
vec_printf(int,vi,"/%d");
vec_printf(int,vi2,"/%d");
vec_sortp(int,vi,int,vi2,>);
printf("\nvi,vi2 after parallel sorting according to vi's descending order:\n");
vec_printf(int,vi,"/%d");
vec_printf(int,vi2,"/%d");
vec_free(int,vi);
vec_free(int,vi2);
vec2_free(int,vvi);
exit(0);
}