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

/* Parse result structure. */struct cparam *cparam_alloc(void) {  struct cparam *cparam;  cparam = calloc(1, sizeof(struct cparam));  if (cparam == NULL) {    return NULL;  }  cparam->args = vector_alloc();  if (cparam->args == NULL) {    cparam_free(cparam);    return NULL;  }  cparam->matched = vector_alloc();  if (cparam->matched == NULL) {    cparam_free(cparam);    return NULL;  }  cparam->candidate = vector_alloc();  if (cparam->candidate == NULL) {    cparam_free(cparam);    return NULL;  }  cparam->argv = vector_alloc();  if (cparam->argv == NULL) {    cparam_free(cparam);    return NULL;  }  return cparam;}

static intblacklist_exceptions_handler(vector strvec){	conf->elist_devnode = vector_alloc();	conf->elist_wwid = vector_alloc();	conf->elist_device = vector_alloc();	if (!conf->elist_devnode || !conf->elist_wwid || !conf->elist_device)		return 1;	return 0;}

void main( ){  Matrix *m, *mT, *eig_vec_J, *eig_vec_T, *L;  Vector *eig_val_J, *eig_val_T;  int i, j, tt_ja, tt_ho;  m = matrix_alloc( 100, 50 );  for( i = 0; i < m->dim_M; i++ )    for( j = 0; j < m->dim_N; j++ )      {         M( m, i, j) = (double) i*i + 120.0;      }  mT = matrix_alloc( 50, 100 );  matrix_transpose( m, mT );    eig_vec_J = matrix_alloc( 100, 100 );  eig_val_J = vector_alloc( 100  );  L       = matrix_alloc( 100, 100 );  matrix_prod( m, mT, L );  Start_Clock_once( &tt_ja );  jacobi( L, eig_val_J, eig_vec_J );  End_ms_Clock_once( tt_ja, 1, "jacobi used " );  printf("done with jacobi/n" );  /* for( i = 0; i < 100; i++ ) printf(" %f", V(eig_val_J,i) );     printf("/n");     for( i = 0; i < 100; i++ ) printf(" %f", M(eig_vec_J,i,0) );     printf("/n");   */  matrix_prod( m, mT, L );  eig_vec_T = matrix_alloc( 100, 100 );  eig_val_T = vector_alloc( 100  );  Start_Clock_once( &tt_ho );  eigen_householder( L, eig_val_T, eig_vec_T );    End_ms_Clock_once( tt_ho, 1, "householder used " );  printf(" done with householder/n" );  /* for( i = 0; i < 100; i++ ) printf(" %f", V(eig_val_T,i) );     printf("/n");     for( i = 0; i < 100; i++ ) printf(" %f", M(eig_vec_T,i,0) );     printf("/n");   */  }

static void init_inner_problem(const struct Struct_FALM *s, struct Struct_FGM *p_in){	// Setting the inner problem to point to the outer problem except for c and z0	// Setting the inner problem to point to the same as the outer saves some memory	p_in->H = s->H_hat;	p_in->lb = s->prob->lb;	p_in->ub = s->prob->ub;    p_in->lb_is_inf = s->info->lb_is_inf;	p_in->ub_is_inf = s->info->ub_is_inf;	p_in->eigH_max = s->info->eigH_max;	p_in->eigH_min = s->info->eigH_min;	// Make own allocation for c (This is changing for each outer iteration)	p_in->c = vector_alloc(N);	p_in->z0 = vector_alloc(N);	// Allocate other necessary vectors	p_in->zopt = vector_alloc(N);	p_in->z = vector_alloc(N);	p_in->y = vector_alloc(N);	p_in->znew = vector_alloc(N);	p_in->ynew = vector_alloc(N);	p_in->temp1_dim_N = vector_alloc(N);	// Initialize options	p_in->maxiter = s->opt->maxiter_inner;	p_in->eps = s->opt->eps_inner;}

/* ============================================================================= * net_alloc * ============================================================================= */net_t*net_alloc (long numNode){    net_t* netPtr;    netPtr = (net_t*)SEQ_MALLOC(sizeof(net_t));    if (netPtr) {        vector_t* nodeVectorPtr = vector_alloc(numNode);        if (nodeVectorPtr == NULL) {            SEQ_FREE(netPtr);            return NULL;        }        long i;        for (i = 0; i < numNode; i++) {            net_node_t* nodePtr = allocNode(i);            if (nodePtr == NULL) {                long j;                for (j = 0; j < i; j++) {                    nodePtr = (net_node_t*)vector_at(nodeVectorPtr, j);                    freeNode(nodePtr);                }                vector_free(nodeVectorPtr);                SEQ_FREE(netPtr);                return NULL;            }            bool_t status = vector_pushBack(nodeVectorPtr, (void*)nodePtr);            assert(status);        }        netPtr->nodeVectorPtr = nodeVectorPtr;    }    return netPtr;}

/* Data initialization */intinit_data(char *conf_file, void (*init_keywords) (void)){	int r;	if (!keywords)		keywords = vector_alloc();	if (!keywords)		return 1;	stream = fopen(conf_file, "r");	if (!stream) {		syslog(LOG_WARNING, "Configuration file open problem");		return 1;	}	/* Init Keywords structure */	(*init_keywords) ();/* Dump configuration *  vector_dump(keywords);  dump_keywords(keywords, 0);*/	/* Stream handling */	r = process_stream(keywords);	fclose(stream);	//free_keywords(keywords);	return r;}

eng_table_t* eng_table_init() {    eng_table_t* eng_table = my_malloc(sizeof(eng_table_t));    //    eng_table->eng_datas = vector_alloc((vector_entry_free_func)eng_data_destroy);    eng_table->eng_keys = vector_alloc((vector_entry_free_func)eng_data_destroy);    return eng_table;}

static voiddpdk_interface_set_index(struct interface *ifp) {  if (ifp_vector == NULL) {    ifp_vector = vector_alloc();  }  vector_set_index(ifp_vector, ifp->info.eth_dpdk_phy.port_number, ifp);}

vector_t *alloc_strvec(char *string){	char *cp, *start, *token;	size_t str_len;	vector_t *strvec;	if (!string)		return NULL;	cp = string;	/* Skip white spaces */	while (isspace((int) *cp) && *cp != '/0')		cp++;	/* Return if there is only white spaces */	if (*cp == '/0')		return NULL;	/* Return if string begin with a comment */	if (*cp == '!' || *cp == '#')		return NULL;	/* Create a vector and alloc each command piece */	strvec = vector_alloc();	while (1) {		start = cp;		/* Save a quoted string without the "s as a single string */		if (*cp == '"') {			start++;			if (!(cp = strchr(start, '"'))) {				log_message(LOG_INFO, "Unmatched quote: '%s'", string);				return strvec;			}			str_len = (size_t)(cp - start);			cp++;		} else {			while (!isspace((int) *cp) && *cp != '/0' && *cp != '"'						   && *cp != '!' && *cp != '#')				cp++;			str_len = (size_t)(cp - start);		}		token = MALLOC(str_len + 1);		memcpy(token, start, str_len);		token[str_len] = '/0';		/* Alloc & set the slot */		vector_alloc_slot(strvec);		vector_set_slot(strvec, token);		while (isspace((int) *cp) && *cp != '/0')			cp++;		if (*cp == '/0' || *cp == '!' || *cp == '#')			return strvec;	}}

vector_t *read_value_block(vector_t *strvec){	char *buf;	unsigned int word;	char *str = NULL;	char *dup;	vector_t *vec = NULL;	vector_t *elements = vector_alloc();	int first = 1;	int need_bob = 1;	int got_eob = 0;	buf = (char *) MALLOC(MAXBUF);	while (first || read_line(buf, MAXBUF)) {		if (first && vector_size(strvec) > 1) {			vec = strvec;			word = 1;		}		else {			vec = alloc_strvec(buf);			word = 0;		}		if (vec) {			str = vector_slot(vec, word);			if (need_bob) {				if (!strcmp(str, BOB))					word++;				else					log_message(LOG_INFO, "'{' missing at beginning of block %s", FMT_STR_VSLOT(strvec,0));				need_bob = 0;			}			for (; word < vector_size(vec); word++) {				str = vector_slot(vec, word);				if (!strcmp(str, EOB)) {					if (word != vector_size(vec) - 1)						log_message(LOG_INFO, "Extra characters after '}' - /"%s/"", buf);					got_eob = 1;					break;				}				dup = (char *) MALLOC(strlen(str) + 1);				memcpy(dup, str, strlen(str));				vector_alloc_slot(elements);				vector_set_slot(elements, dup);			}			if (vec != strvec)				free_strvec(vec);			if (got_eob)				break;		}		memset(buf, 0, MAXBUF);		first = 0;	}	FREE(buf);	return elements;}

static intblacklist_exceptions_handler(struct config *conf, vector strvec){	if (!conf->elist_devnode)		conf->elist_devnode = vector_alloc();	if (!conf->elist_wwid)		conf->elist_wwid = vector_alloc();	if (!conf->elist_device)		conf->elist_device = vector_alloc();	if (!conf->elist_property)		conf->elist_property = vector_alloc();	if (!conf->elist_devnode || !conf->elist_wwid ||	    !conf->elist_device || !conf->elist_property)		return 1;	return 0;}

intalloc_handlers (void){	handlers = vector_alloc();	if (!handlers)		return 1;	return 0;}

/* * multipaths block handlers */static intmultipaths_handler(vector strvec){	conf->mptable = vector_alloc();	if (!conf->mptable)		return 1;	return 0;}

vectorread_value_block(void){	char *buf;	int i;	char *str = NULL;	char *dup;	vector vec = NULL;	vector elements = vector_alloc();	if (!elements)		return NULL;	buf = (char *) MALLOC(MAXBUF);	if (!buf)		return NULL;	while (read_line(buf, MAXBUF)) {		vec = alloc_strvec(buf);		if (vec) {			str = VECTOR_SLOT(vec, 0);			if (!strcmp(str, EOB)) {				free_strvec(vec);				break;			}			if (VECTOR_SIZE(vec))				for (i = 0; i < VECTOR_SIZE(vec); i++) {					str = VECTOR_SLOT(vec, i);					dup = (char *) MALLOC(strlen(str) + 1);					if (!dup)						goto out;					memcpy(dup, str, strlen(str));					if (!vector_alloc_slot(elements)) {						free_strvec(vec);						goto out1;					}					vector_set_slot(elements, dup);				}			free_strvec(vec);		}		memset(buf, 0, MAXBUF);	}	FREE(buf);	return elements;out1:	FREE(dup);out:	FREE(buf);	return NULL;}

static voidtestCounts (adtree_t* adtreePtr, data_t* dataPtr){    long numVar = dataPtr->numVar;    vector_t* queryVectorPtr = vector_alloc(numVar);    long v;    for (v = -1; v < numVar; v++) {        testCount(adtreePtr, dataPtr, queryVectorPtr, v, dataPtr->numVar);    }    vector_free(queryVectorPtr);}

/* ============================================================================= * maze_alloc * ============================================================================= */maze_t*maze_alloc (){    maze_t* mazePtr;    mazePtr = (maze_t*)malloc(sizeof(maze_t));    if (mazePtr) {        mazePtr->gridPtr = NULL;        mazePtr->workQueuePtr = queue_alloc(1024);        mazePtr->wallVectorPtr = vector_alloc(1);        mazePtr->srcVectorPtr = vector_alloc(1);        mazePtr->dstVectorPtr = vector_alloc(1);        assert(mazePtr->workQueuePtr &&               mazePtr->wallVectorPtr &&               mazePtr->srcVectorPtr &&               mazePtr->dstVectorPtr);    }    return mazePtr;}

/* * devices block handlers */static intdevices_handler(struct config *conf, vector strvec){	if (!conf->hwtable)		conf->hwtable = vector_alloc();	if (!conf->hwtable)		return 1;	return 0;}

struct vector *ports_alloc(void) {  struct vector *v;  v = vector_alloc();  if (v == NULL) {    return NULL;  }  return v;}

/* * multipaths block handlers */static intmultipaths_handler(struct config *conf, vector strvec){	if (!conf->mptable)		conf->mptable = vector_alloc();	if (!conf->mptable)		return 1;	return 0;}

vector_t *alloc_strvec(char *string){	char *cp, *start, *token;	int str_len;	vector_t *strvec;	if (!string)		return NULL;	cp = string;	/* Skip white spaces */	while (isspace((int) *cp) && *cp != '/0')		cp++;	/* Return if there is only white spaces */	if (*cp == '/0')		return NULL;	/* Return if string begin with a comment */	if (*cp == '!' || *cp == '#')		return NULL;	/* Create a vector and alloc each command piece */	strvec = vector_alloc();	while (1) {		start = cp;		if (*cp == '"') {			cp++;			token = MALLOC(2);			*(token) = '"';			*(token + 1) = '/0';		} else {			while (!isspace((int) *cp) && *cp != '/0' && *cp != '"')				cp++;			str_len = cp - start;			token = MALLOC(str_len + 1);			memcpy(token, start, str_len);			*(token + str_len) = '/0';		}		/* Alloc & set the slot */		vector_alloc_slot(strvec);		vector_set_slot(strvec, token);		while (isspace((int) *cp) && *cp != '/0')			cp++;		if (*cp == '/0' || *cp == '!' || *cp == '#')			return strvec;	}}

void cmd_bucket_init() {    cq_cmd_bucket = my_malloc(sizeof(cmd_bucket_t));    cq_cmd_bucket->cmd_lists =        vector_alloc((vector_entry_free_func)cmd_list_destroy);    if (NULL == cq_cmd_bucket->cmd_lists) {        log_error("init cmd vector failed!");        abort();    }    return;}

intmain (){    vector_t* vectorPtr;    vector_t* copyVectorPtr;    long data[] = {3, 1, 4, 1, 5, -1};    long i;    puts("Starting...");    vectorPtr = vector_alloc(1);    copyVectorPtr = vector_alloc(1);    for (i = 0; data[i] >= 0; i++) {        insertInt(vectorPtr, &data[i]);    }    vector_copy(copyVectorPtr, vectorPtr);    while (i-- > 0) {        removeInt(vectorPtr);    }    printf("copy ");    printVector(copyVectorPtr);    printf("sort ");    vector_sort(copyVectorPtr, &compareInt);    printVector(copyVectorPtr);    vector_free(vectorPtr);    vector_free(copyVectorPtr);    puts("Done.");    return 0;}

/* ============================================================================= * stream_alloc * ============================================================================= */stream_t*stream_alloc (long percentAttack){    stream_t* streamPtr;    streamPtr = (stream_t*)malloc(sizeof(stream_t));    if (streamPtr) {        streamPtr->percentAttack = percentAttack;        streamPtr->randomPtr = random_alloc();        streamPtr->allocVectorPtr = vector_alloc(1);        streamPtr->packetQueuePtr = queue_alloc(-1);        streamPtr->attackMapPtr = MAP_ALLOC(NULL, NULL);    }    return streamPtr;}

/* Standard allocation function, with initialization of the elements. */matrix_t* matrix_alloc(size_t nbrows, size_t nbcols, bool s){    size_t i;    assert(nbcols>0 || nbrows==0);    matrix_t* mat = (matrix_t*)malloc(sizeof(matrix_t));    mat->nbrows = mat->_maxrows = nbrows;    mat->nbcolumns = nbcols;    mat->_sorted = s;    mat->p = (numint_t**)malloc(nbrows * sizeof(numint_t*));    for (i=0; i<nbrows; i++) {        mat->p[i] = vector_alloc(nbcols);    }    return mat;}

struct cnode *cnode_alloc(void) {  struct cnode *cnode;  cnode = (struct cnode *)calloc(1, sizeof(struct cnode));  if (cnode == NULL) {    return NULL;  }  cnode->v = vector_alloc();  if (cnode->v == NULL) {    cnode_free(cnode);    return NULL;  }  return cnode;}

struct adapter_group *alloc_adaptergroup(void){	struct adapter_group *agp;	agp = (struct adapter_group *)MALLOC(sizeof(struct adapter_group));	if (!agp)		return NULL;	agp->host_groups = vector_alloc();	if (!agp->host_groups) {		FREE(agp);		agp = NULL;	}	return agp;}

/* Data initialization */voidinit_data(char *conf_file, vector_t * (*init_keywords) (void)){	/* Init Keywords structure */	keywords = vector_alloc();	(*init_keywords) ();#if 0	/* Dump configuration */	vector_dump(keywords);	dump_keywords(keywords, 0);#endif	/* Stream handling */	current_keywords = keywords;	read_conf_file((conf_file) ? conf_file : CONF);	free_keywords(keywords);}

struct pathgroup *alloc_pathgroup (void){	struct pathgroup * pgp;	pgp = (struct pathgroup *)MALLOC(sizeof(struct pathgroup));	if (!pgp)		return NULL;	pgp->paths = vector_alloc();	if (!pgp->paths) {		FREE(pgp);		pgp = NULL;	}	return pgp;}