自学教程：C++ v_free函数代码示例

/** * v_error_free: * @error: a #VError to free. * * Free's @error and its contents. */voidv_error_free (VError *error){	v_free (error->module);	v_free (error->message);	v_free (error);}

//--------------------------------------------------------------------------Omu_IntRKsuite::~Omu_IntRKsuite(){  v_free(_thres);  v_free(_work);  v_free(_u);  v_free(_yp);}

static void calc_rhs_Tr_m(int n_models, MAT **Vk,MAT *VinvIminAw, 		VEC *y, VEC *rhs, MAT *Tr_m) {	int j, k;	MAT **Pr = NULL, *Tmp = MNULL;	VEC *v_tmp = VNULL, *v_tmp2;	Pr = (MAT **) emalloc(n_models * sizeof(MAT *));	v_tmp2 = vm_mlt(VinvIminAw, y, VNULL); /* Vw-(I-Aw)Y == Y'(I-Aw)'Vw- */	for (j = 0; j < n_models; j++) {		Pr[j] = m_mlt(Vk[j], VinvIminAw, MNULL);		Tmp = m_mlt(Pr[j], Pr[j], Tmp);		Tr_m->me[j][j] = trace_matrix(Tmp); /* diagonal */		/* using Tr(A B) == Tr(B A) */		for (k = 0; k < j; k++) { /* we did Pr[k] and Pr[j], so */			Tmp = m_mlt(Pr[j], Pr[k], Tmp); /* off-diagonal */			Tr_m->me[j][k] = Tr_m->me[k][j] = trace_matrix(Tmp);		}		v_tmp = vm_mlt(Vk[j], v_tmp2, v_tmp); /* Vw-1(I-Aw)Y */		rhs->ve[j] = in_prod(v_tmp2, v_tmp);	}	for (j = 0; j < n_models; j++)		m_free(Pr[j]);	efree(Pr);	m_free(Tmp);	v_free(v_tmp);	v_free(v_tmp2);	return;}

/** * v_frame_free: * @frame: a #VFrame to free. * * Free's @frame and its contents. */voidv_frame_free (VFrame *frame){		/* free frame data */	switch (frame->type)	{		case V_FRAME_TYPE_RAW:			v_free (V_FRAME_RAW (frame)->data);			break;				case V_FRAME_TYPE_AUDIO:			v_free (V_FRAME_AUDIO (frame)->samples);			break;					case V_FRAME_TYPE_VIDEO:			//v_free (V_FRAME_VIDEO (frame)->data);			break;					case V_FRAME_TYPE_SUBTITLE:			break;	}			/* destroy frame */	v_free (frame);}

// kernelRegression// x:data// dimention: x's dimention// y: label of x // num: number of data// result: coeffiencedouble *kernelRegression(double **x,int dimention,double *y,int num,double gamma,double regilarization){	VEC *label;	MAT *gram,*ident,*inv;	int i,j;	double *result;	ident = m_get(num,num);	label = v_get(num);	memcpy(label->ve,y,sizeof(double)*num);	gram = m_get(num,num);	ident = m_get(num,num);	for(i=0;i<num;i++){		for(j=0;j<num;j++){			gram->me[i][j]=kernel(x[i],x[j],dimention,gamma);		}	}	inv=m_add(gram,sm_mlt(regilarization,m_ident(ident),NULL),NULL);	inv=m_inverse(inv,NULL); //memory leak.	VEC *coefficient=v_get(num);	mv_mlt(inv,label,coefficient);	result=malloc(sizeof(double)*num);	memcpy(result,coefficient->ve,sizeof(double)*num);	m_free(ident);	m_free(gram);	m_free(inv);	v_free(label);	v_free(coefficient);	return result;}

//-------------------------------------------------------------------------Prg_ASCEND::~Prg_ASCEND(){  iv_free(_var_solver_idxs);  iv_free(_var_master_idxs);  v_free(_derivatives);  iv_free(_var_asc2hqp);  v_free(_var_ub);  v_free(_var_lb);}

voidv_connection_free(v_connection_t *c){	v_free(c->local_addr);	v_free(c->remote_addr);	v_free(c->read_callback);	v_free(c->write_callback);	v_free(c);}

voidv_connection_idle(v_connection_t *c){	c->next = v_config.free_connections;	v_config.free_connections = c;	v_config.free_connections_count++;	v_free(c->local_addr);	v_free(c->remote_addr);	c->local_addr = NULL;	c->remote_addr = NULL;	c->event->type = V_IO_NONE;	c->status = V_CONNECTION_NONE;}

//--------------------------------------------------------------------------Omu_IntODE::~Omu_IntODE(){  m_free(_Y2);  m_free(_X2);  v_free(_v);  v_free(_x);  v_free(_u);  v_free(_y);  m_free(_Yx);  m_free(_Yu);}

static MAT *calc_VinvIminAw(MAT *Vw, MAT *X, MAT *VinvIminAw, int calc_Aw) {/* * calculate V_w^-1(I-A_w) (==VinvIminAw), * A = X(X'X)^-1 X' (AY = XBeta; Beta = (X'X)^-1 X'Y) * * on second thought (Nov 1998 -- more than 4 years later :-)) * calc (I-Aw) only once and keep this constant during iteration. */ 	MAT *tmp = MNULL, *V = MNULL; 	VEC *b = VNULL, *rhs = VNULL; 	int i, j;	if (X->m != Vw->n || VinvIminAw->m != X->m)		ErrMsg(ER_IMPOSVAL, "calc_VinvIminAw: sizes don't match");		if (calc_Aw) {		IminAw = m_resize(IminAw, X->m, X->m);		tmp = m_resize(tmp, X->n, X->n);		tmp = mtrm_mlt(X, X, tmp); /* X'X */		m_inverse(tmp, tmp); /* (X'X)-1 */		/* X(X'X)-1 -> X(X'X)-1 X') */		IminAw = XVXt_mlt(X, tmp, IminAw);		for (i = 0; i < IminAw->m; i++) /* I - Aw */			for (j = 0; j <= i; j++)				if (i == j)					IminAw->me[i][j] = 1.0 - IminAw->me[i][j];				else					IminAw->me[i][j] = IminAw->me[j][i] = -IminAw->me[i][j];	}	V = m_copy(Vw, V);	LDLfactor(V);	rhs = v_resize(rhs, X->m);	b = v_resize(b, X->m);	for (i = 0; i < X->m; i++) { /* solve Vw X = (I-A) for X -> V-1(I-A) */		rhs = get_col(IminAw, i, rhs);		LDLsolve(V, rhs, b);		set_col(VinvIminAw, i, b);	}	v_free(rhs);	v_free(b);	m_free(V);	if (tmp) 		m_free(tmp);	return VinvIminAw;}

// assign error to variable or match with next expressionint err_throw_catch(const char *err) {  var_t *arg;  var_t v_catch;  int caught = 1;  switch (code_peek()) {  case kwTYPE_VAR:    arg = code_getvarptr();    v_setstr(arg, err);    break;  case kwTYPE_STR:    v_init(&v_catch);    eval(&v_catch);    // catch is conditional on matching error    caught = (v_catch.type == V_STR && strstr(err, v_catch.v.p.ptr) != NULL);    v_free(&v_catch);    break;  case kwTYPE_EOC:  case kwTYPE_LINE:    break;  default:    rt_raise(ERR_INVALID_CATCH);    break;  }  return caught;}

/* * create array */void v_toarray1(var_t *v, dword r) {  var_t *e;  dword i;  v_free(v);  v->type = V_ARRAY;  if (r > 0) {    // create data    v->v.a.size = r;    v->v.a.ptr = malloc(sizeof(var_t) * (v->v.a.size + ARR_ALLOC));    for (i = 0; i < r; i++) {      e = (var_t *)(v->v.a.ptr + (sizeof(var_t) * i));      v_init(e);    }    // array info    v->v.a.maxdim = 1;    v->v.a.lbound[0] = opt_base;    v->v.a.ubound[0] = opt_base + (r - 1);  } else {    v->v.a.size = 0;    v->v.a.ptr = NULL;    v->v.a.lbound[0] = v->v.a.ubound[0] = opt_base;    v->v.a.maxdim = 1;  }}

/* * convert's a user's string to variable * * its decides in what format to store the value * its used mostly by 'input' functions */void v_input2var(const char *str, var_t *var) {  v_free(var);  if (strlen(str) == 0) {    // no data    v_setstr(var, str);  } else {    char *np, *sb;    char buf[64];    int type;    var_int_t lv;    var_num_t dv;    sb = strdup(str);    np = get_numexpr(sb, buf, &type, &lv, &dv);    if (type == 1 && *np == '/0') {      v_setint(var, lv);    } else if (type == 2 && *np == '/0') {      v_setreal(var, dv);    } else {      v_setstr(var, str);    }    free(sb);  }}

/* * set an empty string */void v_zerostr(var_t *r) {  v_free(r);  r->type = V_STR;  r->v.p.ptr = malloc(1);  r->v.p.ptr[0] = '/0';  r->v.p.size = 1;}

void v_setstr(var_t *var, const char *string) {  v_free(var);  var->type = V_STR;  var->v.p.size = strlen(string) + 1;  var->v.p.ptr = tmp_alloc(var->v.p.size);  strcpy(var->v.p.ptr, string);}

/* *release variable */void v_free(var_t *v) {  int i;  var_t *elem;  switch (v->type) {  case V_STR:    if (v->v.p.ptr) {      tmp_free(v->v.p.ptr);    }    v->v.p.ptr = NULL;    v->v.p.size = 0;    break;  case V_ARRAY:    if (v->v.a.size) {      if (v->v.a.ptr) {        for (i = 0; i < v->v.a.size; i++) {          elem = (var_t *) (v->v.a.ptr + (sizeof(var_t) *i));          v_free(elem);        }        tmp_free(v->v.a.ptr);        v->v.a.ptr = NULL;        v->v.a.size = 0;      }    }    break;  case V_UDS:    break;  }  v_init(v);}

//--------------------------------------------------------------------------Hqp_IpRedSpBKP::~Hqp_IpRedSpBKP(){  sp_free(_CT);  sp_free(_J);  sp_free(_J_raw);  px_free(_QP2J);  px_free(_J2QP);  px_free(_pivot);  px_free(_blocks);  v_free(_zw);  v_free(_scale);  v_free(_r12);  v_free(_xy);  iv_free(_CTC_degree);  iv_free(_CTC_neigh_start);  iv_free(_CTC_neighs);}

/*******************************************************************************   MAIN function******************************************************************************/int main ( int argc, char **argv ){    Widget appShell = init_application(&argc, argv );    catch_sigterm();    trace_main = TRACE_MAIN;    signal(SIGPIPE, SIG_IGN); /* ignore broken pipe on write */    /*  -- Register all application specific callbacks and widget classes     */    RegisterApplication ( appShell );    add_winmove_translations(appShell);    /*  -- Create widget tree below toplevel shell using Xrm database           register callbacks,actions, widget classe before     */    WcWidgetCreation ( appShell );    /* get application resources and widget ptr */    XtGetApplicationResources(	appShell, (XtPointer)&SETTINGS,				basicSettingRes,				XtNumber(basicSettingRes),				(ArgList)0, 0 );    SETTINGS.app = XtWidgetToApplicationContext(appShell);    SETTINGS.vset = v_init();    /* init widgets */    trace_level = SETTINGS.traceLevel;    TRACE(1,"Thermal1 %s/nThermal2 %s", SETTINGS.p[0], SETTINGS.p[1] );    /*  init application functions        All widgets are created, but not visible.        functions can now communicate with widgets    */    update_cb(0,0); /* start timer */    /*  -- Realize the widget tree and enter the main application loop     */    XtRealizeWidget ( appShell );    grab_window_quit( appShell );    make_borderless_window(appShell);    make_stay_above(appShell);    int x0,y0;    if( load_window_position(&x0,&y0) == 0 )        XMoveWindow(XtDisplay(appShell),XtWindow(appShell), x0, y0 );    XtAppMainLoop(XtWidgetToApplicationContext(appShell)); /* use XtAppSetExitFlag */    Dimension x,y;    XtVaGetValues( appShell, "x", &x, "y", &y, NULL );    save_window_position(x,y);    XtDestroyWidget(appShell);    v_free( SETTINGS.vset );    m_destruct();    return EXIT_SUCCESS;}

extern  int v_free_vars(VEC **pv,...){   va_list ap;   int i=1;   VEC **par;      v_free(*pv);   *pv = VNULL;   va_start(ap, pv);   while (par = va_arg(ap,VEC **)) {   /* NULL ends the list*/      v_free(*par);       *par = VNULL;      i++;   }    va_end(ap);   return i;}

/* * set the value of 'var' to string */void v_setstr(var_t *var, const char *string) {  if (var->type != V_STR || strcmp(string, var->v.p.ptr) != 0) {    v_free(var);    var->type = V_STR;    var->v.p.size = strlen(string) + 1;    var->v.p.ptr = malloc(var->v.p.size);    strcpy(var->v.p.ptr, string);  }}

void v_setstrn(var_t *var, const char *string, int len) {  if (var->type != V_STR || strncmp(string, var->v.p.ptr, len) != 0) {    v_free(var);    var->type = V_STR;    var->v.p.size = len + 1;    var->v.p.ptr = malloc(var->v.p.size);    strncpy(var->v.p.ptr, string, len);    var->v.p.ptr[len] = '/0';  }}

int16_t peakiness(int16_t input[], int16_t npts){	register int16_t i;	int16_t peak_fact, scale = 4;	int32_t sum_abs, L_temp;	int16_t temp1, temp2, *temp_buf;	temp_buf = v_get(npts);	v_equ_shr(temp_buf, input, scale, npts);	L_temp = L_v_magsq(temp_buf, npts, 0, 1);	if (L_temp) {		temp1 = melpe_norm_l(L_temp);		scale = melpe_sub(scale, melpe_shr(temp1, 1));		if (scale < 0)			scale = 0;	} else		scale = 0;	sum_abs = 0;	for (i = 0; i < npts; i++) {		L_temp = melpe_L_deposit_l(melpe_abs_s(input[i]));		sum_abs = melpe_L_add(sum_abs, L_temp);	}	/* Right shift input signal and put in temp buffer.                       */	if (scale)		v_equ_shr(temp_buf, input, scale, npts);	if (sum_abs > 0) {		/*      peak_fact = sqrt(npts * v_magsq(input, npts))/sum_abs             */		/*                        = sqrt(npts) * (sqrt(v_magsq(input, npts))/sum_abs)     */		if (scale)			L_temp = L_v_magsq(temp_buf, npts, 0, 0);		else			L_temp = L_v_magsq(input, npts, 0, 0);		L_temp = melpe_L_deposit_l(L_sqrt_fxp(L_temp, 0));	/* L_temp in Q0 */		peak_fact = L_divider2(L_temp, sum_abs, 0, 0);		if (peak_fact > LIMIT_PEAKI) {			peak_fact = SW_MAX;		} else {	/* shl 7 is mult , other shift is Q7->Q12 */			temp1 = melpe_add(scale, 5);			temp2 = melpe_shl(npts, 7);			temp2 = sqrt_fxp(temp2, 7);			L_temp = melpe_L_mult(peak_fact, temp2);			L_temp = melpe_L_shl(L_temp, temp1);			peak_fact = melpe_extract_h(L_temp);		}	} else		peak_fact = 0;	v_free(temp_buf);	return (peak_fact);}

/* * assign (dest = src) */void v_set(var_t *dest, const var_t *src) {  int i;  var_t *dest_vp, *src_vp;  if (src->type == V_UDS) {    uds_set(dest, (const var_p_t) src);    return;  } else if (dest->type == V_UDS) {    // lvalue struct assigned to non-struct rvalue    uds_clear(dest);    return;  } else if (src->type == V_HASH) {    hash_set(dest, (const var_p_t) src);    return;  } else if (dest->type == V_HASH) {    // lvalue struct assigned to non-struct rvalue    hash_clear(dest);    return;  }  v_free(dest);  *dest = *src;  dest->const_flag = 0;  switch (src->type) {  case V_STR:    dest->v.p.ptr = (byte *) tmp_alloc(strlen((char *)src->v.p.ptr) + 1);    strcpy((char *) dest->v.p.ptr, (char *) src->v.p.ptr);    break;  case V_ARRAY:    if (src->v.a.size) {      dest->v.a.ptr = tmp_alloc(src->v.a.size * sizeof(var_t));      // copy each element      for (i = 0; i < src->v.a.size; i++) {        src_vp = (var_t *) (src->v.a.ptr + (sizeof(var_t) * i));        dest_vp = (var_t *) (dest->v.a.ptr + (sizeof(var_t) * i));        v_init(dest_vp);        v_set(dest_vp, src_vp);      }    } else {      dest->v.a.size = 0;      dest->v.a.ptr = NULL;      dest->v.a.ubound[0] = dest->v.a.lbound[0] = opt_base;      dest->v.a.maxdim = 1;    }    break;  case V_PTR:    dest->v.ap = src->v.ap;    dest->type = src->type;    break;  }}

/* * assign (dest = src) */void v_set(var_t *dest, const var_t *src) {  v_free(dest);  dest->const_flag = 0;  dest->type = src->type;  switch (src->type) {  case V_INT:    dest->v.i = src->v.i;    break;  case V_STR:    dest->v.p.size = strlen(src->v.p.ptr) + 1;    dest->v.p.ptr = (char *)malloc(dest->v.p.size);    strcpy(dest->v.p.ptr, src->v.p.ptr);    break;  case V_NUM:    dest->v.n = src->v.n;    break;  case V_MAP:    map_set(dest, (const var_p_t)src);    break;  case V_PTR:    dest->v.ap.p = src->v.ap.p;    dest->v.ap.v = src->v.ap.v;    break;  case V_REF:    dest->v.ref = src->v.ref;    break;  case V_FUNC:    dest->v.fn.cb = src->v.fn.cb;    dest->v.fn.self = src->v.fn.self;    break;  case V_ARRAY:    if (src->v.a.size) {      memcpy(&dest->v.a, &src->v.a, sizeof(src->v.a));      dest->v.a.ptr = malloc(src->v.a.size * sizeof(var_t));      // copy each element      int i;      var_t *dest_vp, *src_vp;      for (i = 0; i < src->v.a.size; i++) {        src_vp = (var_t *)(src->v.a.ptr + (sizeof(var_t) * i));        dest_vp = (var_t *)(dest->v.a.ptr + (sizeof(var_t) * i));        v_init(dest_vp);        v_set(dest_vp, src_vp);      }    } else {      dest->v.a.size = 0;      dest->v.a.ptr = NULL;      dest->v.a.ubound[0] = dest->v.a.lbound[0] = opt_base;      dest->v.a.maxdim = 1;    }    break;  }}