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

sip_call_t *call_create(char *callid, char *xcallid){    sip_call_t *call;    // Initialize a new call structure    if (!(call = sng_malloc(sizeof(sip_call_t))))        return NULL;    // Create a vector to store call messages    call->msgs = vector_create(2, 2);    vector_set_destroyer(call->msgs, msg_destroyer);    // Create an empty vector to store rtp packets    if (setting_enabled(SETTING_CAPTURE_RTP)) {        call->rtp_packets = vector_create(0, 40);        vector_set_destroyer(call->rtp_packets, packet_destroyer);    }    // Create an empty vector to strore stream data    call->streams = vector_create(0, 2);    vector_set_destroyer(call->streams, vector_generic_destroyer);    // Create an empty vector to store x-calls    call->xcalls = vector_create(0, 1);    // Initialize call filter status    call->filtered = -1;    // Set message callid    call->callid = strdup(callid);    call->xcallid = strdup(xcallid);    return call;}

void liquid_wave_get_normal_z(map_liquid_type *liq,int div,float *wave_y,int top_add,d3vct *normal){	int				top,top_prev,top_next,					y,y_prev,y_next;	d3vct			p10,p20,n1,n2;	top=liq->top+(top_add*div);	y=(int)wave_y[div&0x3];	top_prev=top-top_add;	y_prev=(int)wave_y[(div-1)&0x3];	top_next=top+top_add;	y_next=(int)wave_y[(div+1)&0x3];		// get previous and next		// polygon normals	vector_create(&p10,liq->rgt,y_prev,top_prev,liq->lft,y_prev,top_prev);	vector_create(&p20,liq->lft,y,top,liq->lft,y_prev,top_prev);	vector_cross_product(&n1,&p10,&p20);	vector_normalize(&n1);	vector_create(&p10,liq->rgt,y,top,liq->lft,y,top);	vector_create(&p20,liq->lft,y_next,top_next,liq->lft,y,top);	vector_cross_product(&n2,&p10,&p20);	vector_normalize(&n2);		// average for normal	normal->x=(n1.x+n2.x)*0.5f;	normal->y=(n1.y+n2.y)*0.5f;	normal->z=(n1.z+n2.z)*0.5f;	vector_normalize(normal);}

void animation_create(animation *ani, void *src, int id) {    sd_animation *sdani = (sd_animation*)src;    // Copy simple stuff    ani->id = id;    ani->start_pos = vec2i_create(sdani->start_x, sdani->start_y);    str_create_from_cstr(&ani->animation_string, sdani->anim_string);    // Copy collision coordinates    vector_create(&ani->collision_coords, sizeof(collision_coord));    collision_coord tmp_coord;    for(int i = 0; i < sdani->col_coord_count; i++) {        tmp_coord.pos = vec2i_create(sdani->col_coord_table[i].x, sdani->col_coord_table[i].y);        tmp_coord.frame_index = sdani->col_coord_table[i].y_ext;        vector_append(&ani->collision_coords, &tmp_coord);    }    // Copy extra strings    vector_create(&ani->extra_strings, sizeof(str));    str tmp_string;    for(int i = 0; i < sdani->extra_string_count; i++) {        str_create_from_cstr(&tmp_string, sdani->extra_strings[i]);        vector_append(&ani->extra_strings, &tmp_string);        // don't str_free tmp_str here because it will free the pointers        // inside it, which vector_append does not copy    }    // Handle sprites    vector_create(&ani->sprites, sizeof(sprite));    sprite tmp_sprite;    for(int i = 0; i < sdani->frame_count; i++) {        sprite_create(&tmp_sprite, (void*)sdani->sprites[i], i);        vector_append(&ani->sprites, &tmp_sprite);    }}

voidcapture_init(size_t limit, bool rtp_capture){    capture_cfg.limit = limit;    capture_cfg.rtp_capture = rtp_capture;    capture_cfg.sources = vector_create(1, 1);    capture_cfg.tcp_reasm = vector_create(0, 10);    capture_cfg.ip_reasm = vector_create(0, 10);    // Fixme    if (setting_has_value(SETTING_CAPTURE_STORAGE, "none")) {        capture_cfg.storage = CAPTURE_STORAGE_NONE;    } else if (setting_has_value(SETTING_CAPTURE_STORAGE, "memory")) {        capture_cfg.storage = CAPTURE_STORAGE_MEMORY;    } else if (setting_has_value(SETTING_CAPTURE_STORAGE, "disk")) {        capture_cfg.storage = CAPTURE_STORAGE_DISK;    }    // Initialize calls lock    pthread_mutexattr_t attr;    pthread_mutexattr_init(&attr);#if defined(PTHREAD_MUTEX_RECURSIVE) || defined(__FreeBSD__) || defined(BSD) || defined (__OpenBSD__) || defined(__DragonFly__)    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);#else    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE_NP);#endif    pthread_mutex_init(&capture_cfg.lock, &attr);}

intmain(int argc, char **argv){  const int n = 3;  // init our vectors of size n  struct vector *x = vector_create(n);  struct vector *y = vector_create(n);  struct vector *z = vector_create(n);  struct vector *z_ref = vector_create(n);  // initialize values for testing  for (int i = 0; i < n; i++) {    VEC(x, i) = i + 1.f;    VEC(y, i) = i + 2.f;    VEC(z_ref, i) = 2*i + 3.f;  }  // test the vector_add()  vector_add(x, y, z);  // and make sure it equals the reference result  assert(vector_is_equal(z, z_ref));  // clean up  vector_destroy(x);  vector_destroy(y);  vector_destroy(z);  vector_destroy(z_ref);  return 0;}

animation* create_animation_from_single(sprite *sp, vec2i pos) {    animation *a = malloc(sizeof(animation));    a->start_pos = pos;    a->id = -1;    str_create_from_cstr(&a->animation_string, "A9999999999");    vector_create(&a->collision_coords, sizeof(collision_coord));    vector_create(&a->extra_strings, sizeof(str));    vector_create(&a->sprites, sizeof(sprite));    vector_append(&a->sprites, sp);    free(sp);    return a;}

int main(int argc, char * argv[]){    int n, n_threads = 0;    matrix_t * A,             * A_orig;    vector_t * b,             * b_orig,             * x,             * check_res_mat;                 double t_start, t_end;            get_input_params(argc, argv, &n);    initialize_global_state();        /* initialize data */    A_orig          = matrix_create_rand(n, n),    A               = matrix_clone(A_orig),    b_orig          = vector_create_rand(n),    b               = vector_clone(b_orig),    x               = vector_create(n),    check_res_mat   = vector_create(n);        t_start = get_time_in_sec();        perform_gaussian_elimination_on_matrix(A, b);    perform_back_substitution(A, x, b);        t_end  = get_time_in_sec();        /* calculate Ax - b and find it's l2norm to test for correctness */    matrix_mult_vector(A_orig, x, check_res_mat);        vector_subtract(check_res_mat, check_res_mat, b_orig); /* c = c - b */        printf("num-procs   = %d/n", omp_get_num_procs());#pragma omp parallel num_threads(num_threads)#pragma omp single    n_threads = omp_get_num_threads();    printf("num-threads = %d/n", n_threads);    printf("Performed Gaussian Elimination in %.12lfs/n", t_end - t_start);    printf("Ax-b l2norm = %.6le/n", vector_l2norm(check_res_mat));        puts("done");       return 0;}

void test_vector_remove_empty_array() {    array* arr = vector_create();    ASSERT(vector_remove(arr, 0) == false);    ASSERT(arr->size == 0);    vector_free(arr);}

void test_vector_create() {    array *arr = vector_create();    ASSERT(arr->capacity == init_capacity);    ASSERT(arr->size == 0);    vector_free(arr);}

intmain(int argc, char **argv){  MPI_Init(&argc, &argv);  libmrc_params_init(argc, argv);  struct vector *vec = vector_create(MPI_COMM_WORLD);  vector_set_from_options(vec);  vector_setup(vec);  vector_view(vec);  int nr_elements;  vector_get_param_int(vec, "nr_elements", &nr_elements);  for (int i = 0; i < nr_elements; i++) {    vector_set_element(vec, i, 2. * i);  }  for (int i = 0; i < nr_elements; i++) {    assert(vector_get_element(vec, i) == 2. * i);  }  vector_destroy(vec);  MPI_Finalize();}

void bk_create(bk *b, void *src) {    sd_bk_file *sdbk = (sd_bk_file*)src;    // File ID    b->file_id = sdbk->file_id;    // Copy VGA image    surface_create_from_data(        &b->background,        SURFACE_TYPE_PALETTE,        sdbk->background->w,        sdbk->background->h,        sdbk->background->data);    // Copy sound translation table    memcpy(b->sound_translation_table, sdbk->soundtable, 30);    // Copy palettes    vector_create(&b->palettes, sizeof(palette));    for(int i = 0; i < sdbk->palette_count; i++) {        vector_append(&b->palettes, (palette*)sdbk->palettes[i]);    }    // Copy info structs    hashmap_create(&b->infos, 7);    bk_info tmp_bk_info;    for(int i = 0; i < 50; i++) {        if(sdbk->anims[i] != NULL) {            bk_info_create(&tmp_bk_info, (void*)sdbk->anims[i], i);            hashmap_iput(&b->infos, i, &tmp_bk_info, sizeof(bk_info));        }    }}

void light_map_ray_trace_diffuse(int mesh_idx,int poly_idx,d3pnt *rpt,d3pnt *lit_pnt,d3col *col){	float				diffuse;	d3vct				diffuse_vct;	map_mesh_poly_type	*poly;	if ((mesh_idx==-1) || (poly_idx==-1)) return;	poly=&map.mesh.meshes[mesh_idx].polys[poly_idx];		// create the diffuse factor	vector_create(&diffuse_vct,lit_pnt->x,lit_pnt->y,lit_pnt->z,rpt->x,rpt->y,rpt->z);	diffuse=(diffuse_vct.x*poly->tangent_space.normal.x)+(diffuse_vct.y*poly->tangent_space.normal.y)+(diffuse_vct.z*poly->tangent_space.normal.z);	diffuse=((diffuse+1.0f)*0.5f)+map.light_map.diffuse_boost;	if (diffuse>=1.0f) return;	if (diffuse<0.0f) diffuse=0.0f;			// calculate the color			col->r*=diffuse;	col->g*=diffuse;	col->b*=diffuse;}

/* * Returns a new absolute value vector. */vector_t *vabs(vector_t *vector) {	vector_t *vector2 = vector_create(vector->x, vector->y);	vector2->x = abs(vector2->x);	vector2->y = abs(vector2->y);	return vector2;}

static HANDLE_FUNC (handle_listen){        char *arg = get_string_arg (line, &match[2]);        if (arg == NULL) {                return -1;        }        if (conf->listen_addrs == NULL) {               conf->listen_addrs = vector_create();               if (conf->listen_addrs == NULL) {                       log_message(LOG_WARNING, "Could not create a list "                                   "of listen addresses.");                       safefree(arg);                       return -1;               }        }        vector_append (conf->listen_addrs, arg, strlen(arg) + 1);        log_message(LOG_INFO, "Added address [%s] to listen addresses.", arg);        safefree (arg);        return 0;}

int main(int argc, char **argv){	vector *c = NULL;	int v1 = 4;	int v2 = 1;	int v3 = 3;	int v4 = 2;	int v5 = 16;	int v6 = 9;	int v7 = 10;	int v8 = 14;	int v9 = 8;	int v10 = 7;	c = vector_create();		c->push(c, (void *)(&v1 ));	c->push(c, (void *)(&v2 ));	c->push(c, (void *)(&v3 ));	c->push(c, (void *)(&v4 ));	c->push(c, (void *)(&v5 ));	c->push(c, (void *)(&v6 ));	c->push(c, (void *)(&v7 ));	c->push(c, (void *)(&v8 ));	c->push(c, (void *)(&v9 ));	c->push(c, (void *)(&v10));	Print(c, visit);	make_heap(c, compare);	Print(c, visit);	printf("/n===============================/n");	heap_sort(c, compare);	Print(c, visit);	vector_destroy(&c, NULL);	return 0;}

options_t * options_create(bool (* collision_callback)(option_t * option1, const option_t * option2)){    options_t * options;    if (!(options = malloc(sizeof(options_t)))) {        goto ERR_MALLOC;    }    if (!(options->optspecs = vector_create(        sizeof(option_t),        (ELEMENT_FREE) option_free,        (ELEMENT_DUMP) option_dump    ))) {        goto ERR_VECTOR_CREATE;    }    options->collision_callback = collision_callback;    options->optspecs->cells = (option_t *) options->optspecs->cells;    return options;ERR_VECTOR_CREATE:    free(options);ERR_MALLOC:    return NULL;}

void expand_word_state(search_prefix_t *search, prefix_fifo_t * prefix_info,                       const struct words_state_t *word_state,                       const symbol_t *ip, const symbol_t *op, float bo){  prefix_fifo_key_t key = { word_state->state_next, ip, op };  prefix_fifo_t *pf = (prefix_fifo_t *)hash_search((void *)&key, sizeof(prefix_fifo_key_t), search->hash);  if (pf == NULL) {    pf = (prefix_fifo_t *) malloc(sizeof(prefix_fifo_t));    pf->base_state = word_state->state_next;    pf->input = ip;    pf->output = op;    pf->state = state_grammar_create();    pf->state->name = (symbol_t*) realloc(pf->state->name, sizeof(symbol_t) * (symlen(pf->base_state->name) + 1));    symcpy(pf->state->name, pf->base_state->name);    pf->initial_prob = LOG_ZERO;    pf->is_accesible = false;    pf->incoming = vector_create();    vector_append(search->fifo, pf);    hash_insert((void *)&key, sizeof(prefix_fifo_key_t), pf, search->hash);  }  incoming_t *incoming = (incoming_t *) malloc(sizeof(incoming_t));  MEMTEST(incoming);  incoming->prev_pf = prefix_info;  incoming->word_idx = state_grammar_append(prefix_info->state, word_state->word, word_state->prob + bo, pf->state);  vector_append(pf->incoming, incoming);}

bool fionpoll_create(struct fionobj * const obj){    bool ret = false;    if (UTILDEBUG_VERIFY((obj != NULL) && (vector_getsize(&obj->fds) == 0)))    {        obj->ops.fion_create    = fionpoll_create;        obj->ops.fion_destroy   = fionpoll_destroy;        obj->ops.fion_insertfd  = fionpoll_insertfd;        obj->ops.fion_deletefd  = fionpoll_deletefd;        obj->ops.fion_setflags  = fionpoll_setflags;        obj->ops.fion_poll      = fionpoll_poll;        obj->ops.fion_getevents = fionpoll_getevents;        obj->timeoutms          = 0;        obj->pevents            = 0;        obj->revents            = 0;        if (!vector_create(&obj->fds, 0, sizeof(struct pollfd)))        {            logger_printf(LOGGER_LEVEL_ERROR,                          "%s: vector allocation failed (%d)/n",                          __FUNCTION__,                          errno);        }        else        {            ret = true;        }    }    return ret;}

Vector *vector_cross(Vector *a, Vector *b, Vector *write){	if(!write) write = vector_create(0,0,0);	write->x = (a->y * b->z) - (a->z * b->y);	write->y = (a->z * b->x) - (a->x * b->z);	write->z = (a->x * b->y) - (a->y * b->x);	return write;}

void test_vector_append() {    array *arr = vector_create();    vector_append(arr, 5);    ASSERT(arr->array[0] == 5);    ASSERT(arr->size == 1);    vector_free(arr);}

/* Open new pptp_connection.  Returns NULL on failure. */PPTP_CONN * pptp_conn_open(int inet_sock, int isclient, pptp_conn_cb callback){    PPTP_CONN *conn;    /* Allocate structure */    if ((conn = malloc(sizeof(*conn))) == NULL) return NULL;    if ((conn->call = vector_create()) == NULL) { free(conn); return NULL; }    /* Initialize */    conn->inet_sock = inet_sock;    conn->conn_state = CONN_IDLE;    conn->ka_state  = KA_NONE;    conn->ka_id     = 1;    conn->call_serial_number = 0;    conn->callback  = callback;    /* Create I/O buffers */    conn->read_size = conn->write_size = 0;    conn->read_alloc = conn->write_alloc = INITIAL_BUFSIZE;    conn->read_buffer =        malloc(sizeof(*(conn->read_buffer)) * conn->read_alloc);    conn->write_buffer =        malloc(sizeof(*(conn->write_buffer)) * conn->write_alloc);    if (conn->read_buffer == NULL || conn->write_buffer == NULL) {        if (conn->read_buffer  != NULL) free(conn->read_buffer);        if (conn->write_buffer != NULL) free(conn->write_buffer);        vector_destroy(conn->call); free(conn); return NULL;    }    /* Make this socket non-blocking. */    fcntl(conn->inet_sock, F_SETFL, O_NONBLOCK);    /* Request connection from server, if this is a client */    if (isclient) {        struct pptp_start_ctrl_conn packet = {            PPTP_HEADER_CTRL(PPTP_START_CTRL_CONN_RQST),            hton16(PPTP_VERSION), 0, 0,             hton32(PPTP_FRAME_CAP), hton32(PPTP_BEARER_CAP),            hton16(PPTP_MAX_CHANNELS), hton16(PPTP_FIRMWARE_VERSION),             PPTP_HOSTNAME, PPTP_VENDOR        };        /* fix this packet, if necessary */        int idx, rc;        idx = get_quirk_index();        if (idx != -1 && pptp_fixups[idx].start_ctrl_conn) {            if ((rc = pptp_fixups[idx].start_ctrl_conn(&packet)))                warn("calling the start_ctrl_conn hook failed (%d)", rc);        }        if (pptp_send_ctrl_packet(conn, &packet, sizeof(packet)))            conn->conn_state = CONN_WAIT_CTL_REPLY;        else            return NULL; /* could not send initial start request. */    }    /* Set up interval/keep-alive timer */    /*   First, register handler for SIGALRM */    sigpipe_create();    sigpipe_assign(SIGALRM);    global.conn = conn;    /* Reset event timer */    pptp_reset_timer();    /* all done. */    return conn;}

TEST(VectorTest, CreateRelease) {	status_t err = NO_ERROR;	vector_handle_t vector = NULL;	err = vector_create(1, 1, &vector);	ASSERT_EQ(err, NO_ERROR);	ASSERT_TRUE(vector != NULL);	vector_release(vector);}

void menu_create(menu *menu, int x, int y, int w, int h) {    vector_create(&menu->objs, sizeof(component*));    menu->x = x;    menu->y = y;    menu->w = w;    menu->h = h;    menu_background_create(&menu->sur, w, h);    menu->selected = 0;}

PerceptronModel create_PerceptronModel(size_t transformed_embedding_length, IntegerIndexedFeatures iif) {    PerceptronModel model = (PerceptronModel) malloc(sizeof (struct PerceptronModel));    check_mem(model);    model->embedding_w = NULL;    model->discrete_w = NULL;    model->c = 1;    //FeatureMatrix mat = training->feature_matrix_singleton;    if (transformed_embedding_length > 0) {        model->embedding_w = vector_create(transformed_embedding_length);        model->embedding_w_avg = vector_create(transformed_embedding_length);        model->embedding_w_temp = vector_create(transformed_embedding_length);        model->embedding_w_best = vector_create(transformed_embedding_length);        log_info("Embedding features of %ld dimension", model->embedding_w->n);    } else {        model->embedding_w = NULL;        model->embedding_w_avg = NULL;        model->embedding_w_temp = NULL;    }    /*    if (training->disrete_patterns_parts) {        model->discrete_w = vector_create(iif->feature_id);        model->discrete_w_avg = vector_create(iif->feature_id);        model->discrete_w_temp = vector_create(iif->feature_id);        log_info("Discrete features of %ld dimension", model->discrete_w->n);    } else {        model->discrete_w = NULL;        model->discrete_w_avg = NULL;        model->discrete_w_temp = NULL;    }     */    return model;error:    exit(1);}

bool shadow_get_volume(d3pnt *pnt,int high,int *px,int *py,int *pz){	int							n;	float						f_dist;	bool						hits[8];	d3pnt						spt[8],ept[8],hpt[8],*sp,*ep;	d3vct						ray_move;	view_light_spot_type		*lspot;	ray_trace_contact_type		base_contact;		// get light and draw distance	lspot=shadow_get_light_spot(pnt,high);	f_dist=(float)lspot->intensity;		// ray trace bounding box			sp=spt;	ep=ept;	for (n=0;n!=8;n++) {		sp->x=px[n];		sp->y=py[n];		sp->z=pz[n];		vector_create(&ray_move,lspot->pnt.x,lspot->pnt.y,lspot->pnt.z,sp->x,sp->y,sp->z);						ep->x=sp->x-(int)(ray_move.x*f_dist);		ep->y=sp->y-(int)(ray_move.y*f_dist);		ep->z=sp->z-(int)(ray_move.z*f_dist);				sp++;		ep++;	}	base_contact.obj.on=FALSE;	base_contact.obj.ignore_uid=-1;	base_contact.proj.on=FALSE;	base_contact.proj.ignore_uid=-1;	base_contact.hit_mode=poly_ray_trace_hit_mode_all;	base_contact.origin=poly_ray_trace_origin_object;	ray_trace_map_by_point_array_no_contact(8,spt,ept,hpt,hits,&base_contact);		// set the volume	for (n=0;n!=8;n++) {		px[n]=hpt[n].x;		py[n]=hpt[n].y;		pz[n]=hpt[n].z;	}	return(TRUE);}