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

static int list_devices(void){	struct vector v;	vector_init(&v, sizeof(const char *));	if (fet_db_enum(add_fet_device, &v) < 0) {		pr_error("couldn't allocate memory");		vector_destroy(&v);		return -1;	}	printc("Devices supported by FET driver:/n");	namelist_print(&v);	vector_destroy(&v);	vector_init(&v, sizeof(const char *));	if (fet_olimex_db_enum(add_fet_olimex_device, &v) < 0) {		pr_error("couldn't allocate memory");		vector_destroy(&v);		return -1;	}	printc("/n");	printc("Devices supported by Olimex FET driver:/n");	namelist_print(&v);	vector_destroy(&v);	return 0;}

int cvector_read_moments(complex_t *scnd, complex_t *thrd, complex_t *frth, vector_t *vec, complex_t org){  int n;  vector_t *moment, *diff;  assert(scnd);  assert(thrd);  assert(frth);  assert(vec);  moment = vector_new_and_copy(vec);  diff = vector_new_and_copy(vec);  cvector_copy_cvector_subtract_scalar(diff, vec, org);  cvector_copy_cvector_multiply_cvector(moment, diff, diff);  n = vector_get_dimension(vec);  *scnd = cvector_get_sum(moment);  scnd->real /= (real_t)n, scnd->imag /= (real_t)n;  cvector_multiply_cvector(moment, diff);  *thrd = cvector_get_sum(moment);  thrd->real /= (real_t)n, thrd->imag /= (real_t)n;  cvector_multiply_cvector(moment, diff);  *frth = cvector_get_sum(moment);  frth->real /= (real_t)n, frth->imag /= (real_t)n;  vector_destroy(diff);  vector_destroy(moment);  return n;}

int ivector_read_moments(real_t *scnd, real_t *thrd, real_t *frth, vector_t *vec, real_t org){  vector_t *moment, *diff;  assert(scnd);  assert(thrd);  assert(frth);  assert(vec);  moment = vector_new_and_copy(vec);  diff = vector_new_and_copy(vec);  ivector_copy_ivector_subtract_scalar(diff, vec, org);  ivector_copy_ivector_multiply_ivector(moment, diff, diff);  *scnd = ivector_get_sum(moment) / vector_get_dimension(moment);  ivector_multiply_ivector(moment, diff);  *thrd = ivector_get_sum(moment) / vector_get_dimension(moment);  ivector_multiply_ivector(moment, diff);  *frth = ivector_get_sum(moment) / vector_get_dimension(moment);  vector_destroy(diff);  vector_destroy(moment);  return vector_get_dimension(vec);}

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;}

/* free the memory used by the vetting structure */voidmtsFreeWork (vetting_t ** w){  vetting_t *work = (*w);  if (work->desired.X != -SPECIAL || work->desired.Y != -SPECIAL)    {       heap_free (work->untested.h, free);       heap_destroy (&work->untested.h);       heap_free (work->no_fix.h, free);       heap_destroy (&work->no_fix.h);       heap_free (work->no_hi.h, free);       heap_destroy (&work->no_hi.h);       heap_free (work->hi_candidate.h, free);       heap_destroy (&work->hi_candidate.h);    }  else    {       while (!vector_is_empty (work->untested.v))         free (vector_remove_last (work->untested.v));       vector_destroy (&work->untested.v);       while (!vector_is_empty (work->no_fix.v))         free (vector_remove_last (work->no_fix.v));       vector_destroy (&work->no_fix.v);       while (!vector_is_empty (work->no_hi.v))         free (vector_remove_last (work->no_hi.v));       vector_destroy (&work->no_hi.v);       while (!vector_is_empty (work->hi_candidate.v))         free (vector_remove_last (work->hi_candidate.v));       vector_destroy (&work->hi_candidate.v);    }  free (work);  (*w) = NULL;}

/* * Unit test for the vector_prepend function. Runs some example * operations and checks that results are as expected, writing * messages to the terminal so that errors can be detected and * pinpointed. * * /return zero on success. */int test_prepend (void){  Vector vec;  int ii;    printf ("/nrunning test_prepend.../n");    vector_init (&vec);  printf ("initialized: ");  vector_dump (&vec);    for (ii = -3; ii < 10; ++ii) {    if (0 != vector_prepend (&vec, ii)) {      printf ("test_prepend ERROR: could not prepend %d/n", ii);      vector_destroy (&vec);      return -1;    }    printf ("prepended %2d: ", ii);    vector_dump (&vec);  }    for (ii = 0; ii < 13; ++ii)    if (vec.arr[ii] != 9-ii) {      printf ("test_prepend ERROR: arr[%d] should be %d but is %d/n", ii, 9-ii, vec.arr[ii]);      vector_destroy (&vec);      return -1;    }    printf ("test_prepend SUCCESS/n");    vector_destroy (&vec);  return 0;}

/** * Clean up torrent context by freeing all dynamically  * allocated memory. */void torrent_cleanup(torrent_ctx *ctx){  assert(ctx);  vector_destroy(&ctx->blocks_hashes.blocks);  vector_destroy(&ctx->files);  free(ctx->program_name);  free(ctx->announce);  ctx->announce = ctx->program_name = 0;  str_free(ctx->torrent);}

voidcall_destroy(sip_call_t *call){    // Remove all call messages    vector_destroy(call->msgs);    // Remove all call streams    vector_destroy(call->streams);    // Remove all call attributes    vector_destroy(call->attrs);    // Remove all call rtp packets    vector_destroy(call->rtp_packets);    // Deallocate call memory    sng_free(call);}

void vector_resize(struct Vector * vector) {  void * new_storage;  int new_length;  if (vector->population == vector->length) {    new_length = vector->length * 2;    new_storage = realloc(vector->storage, sizeof(void *) * vector->length * 2);  } else if ((float)vector->population/(float)vector->length < 0.25) {    new_length = vector->length / 2;    new_storage = realloc(vector->storage, sizeof(void *) * vector->length / 2);  } else {    return;  }  /* not sure if this is morally correct. On one hand, the system has no more     memory to give. On the other, such a trivial error should not bring down     the program. Comments? */  if (new_storage == NULL) {    vector_destroy(vector);    fprintf(stderr, "could not allocate more memory for vector. Sorry/n");    exit (1);  }  vector->storage = new_storage;  vector->length = new_length;}

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();}

int main() {    struct vector_t myVector, secondVector;    vector_init(&myVector);    vector_push_back(&myVector,3);    vector_push_back(&myVector,1);    vector_push_back(&myVector,4);    vector_push_back(&myVector,1);    vector_push_back(&myVector,5);    vector_push_back(&myVector,9);    vector_push_back(&myVector,2);    vector_push_back(&myVector,6);    vector_copy(&myVector, &secondVector);    printf("Size of copied vector: %d/n", vector_get_size(secondVector));    printf("Size: %d/n", vector_get_size(myVector));    printf("Pop: %d/n", vector_pop_back(&myVector));    printf("Pop: %d/n", vector_pop_back(&myVector));    printf("Pop: %d/n", vector_pop_back(&myVector));    printf("Pop: %d/n", vector_pop_back(&myVector));    printf("Pop: %d/n", vector_pop_back(&myVector));    printf("Size: %d/n", vector_get_size(myVector));    printf("Pop: %d/n", vector_pop_back(&myVector));    printf("Pop: %d/n", vector_pop_back(&myVector));    printf("Pop: %d/n", vector_pop_back(&myVector));    printf("Size: %d/n", vector_get_size(myVector));    vector_destroy(&myVector);    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;}

int cmd_help(char **arg){	const char *topic = get_arg(arg);	if (topic) {		struct cmddb_record cmd;		struct opdb_key key;		if (!cmddb_get(topic, &cmd)) {			printc("/x1b[1mCOMMAND: %s/x1b[0m/n/n%s/n",			       cmd.name, cmd.help);			return 0;		}		if (!opdb_get(topic, &key, NULL)) {			printc("/x1b[1mOPTION: %s (%s)/x1b[0m/n/n%s/n",			       key.name, type_text(key.type), key.help);			return 0;		}		printc_err("help: unknown command: %s/n", topic);		return -1;	} else {		struct vector v;		vector_init(&v, sizeof(const char *));		if (!cmddb_enum(push_command_name, &v)) {			printc("Available commands:/n");			namelist_print(&v);			printc("/n");		} else {			pr_error("help: can't allocate memory for command list");		}		vector_realloc(&v, 0);		if (!opdb_enum(push_option_name, &v)) {			printc("Available options:/n");			namelist_print(&v);			printc("/n");		} else {			pr_error("help: can't allocate memory for option list");		}		vector_destroy(&v);		printc("Type /"help <topic>/" for more information./n");		printc("Use the /"opt/" command (/"help opt/") to set "			"options./n");#if defined(__Windows__) && !defined(USE_READLINE)		printc("Press Ctrl+Z, Enter to quit./n");#else		printc("Press Ctrl+D to quit./n");#endif	}	return 0;}

void mnist_images_destroy(mnist_images_t images) {    assert(images);    for (size_t i = 0; i < images->size; i++) {        vector_destroy(images->imgs[i]);    }    Free(images);}

static void tcas_renderer_fin(TcasStPtr pTcas) {    if (pTcas->indexStreams)        vector_destroy(pTcas->indexStreams);    pTcas->indexStreams = NULL;    if (pTcas->chunksCache.streamCount > 0)        libtcas_free_chunks_cache(&pTcas->chunksCache);    libtcas_close_file(&pTcas->file);}

void test4(void){    vector_t vec = vector_from_string_list(NULL_VECTOR, "1920x1080,1280x720,720x576,720x480,704x576", NULL);    vector_foreach(vec, test4_walker, NULL);    printf("size: %d, capacity: %d/n", vector_size(vec), vector_capacity(vec));    vector_clear(vec);    vector_destroy(vec);}

int main() {	struct vector_t vec;	struct vector_t vec2;	int i;	printf("Original vector test/n");	vector_init(&vec);	printf("Pushing into vector/n");	for(i=0; i<10; i++)	{		vector_push_back(&vec, i);		printf("Index: %d/n", vector_get_size(vec));	}	printf("Popping out of vector/n");	for(i=0; i<10; i++)	{		vector_pop_back(&vec);		printf("Index: %d/n", vector_get_size(vec));	}	vector_copy(&vec, &vec2);	vector_destroy(&vec);	printf("Copied vector test/n");	printf("Pushing in vector/n");	for(i=0; i<10; i++)	{		vector_push_back(&vec2, i);		printf("Index: %d/n", vector_get_size(vec2));	}	printf("Popping out of vector/n");	for(i=0; i<10; i++)	{		vector_pop_back(&vec2);		printf("Index: %d/n", vector_get_size(vec2));	}		vector_destroy(&vec2);return 0;}

voidcapture_deinit(){    // Close pcap handler    capture_close();    // Deallocate vectors    vector_set_destroyer(capture_cfg.sources, vector_generic_destroyer);    vector_destroy(capture_cfg.sources);    vector_set_destroyer(capture_cfg.tcp_reasm, packet_destroyer);    vector_destroy(capture_cfg.tcp_reasm);    vector_set_destroyer(capture_cfg.ip_reasm, packet_destroyer);    vector_destroy(capture_cfg.ip_reasm);    // Remove capture mutex    pthread_mutex_destroy(&capture_cfg.lock);}

/* 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;}

 int get_heading (data_t* data) {    // Initialize heading value -  it's an integer because it is    // going to eventually be binned into North, South, East, or West    vector north, east, mag_vector, accel_vector, from;    int heading;    // Initialize north and east vectors    vector_init(&north, 0, 0, 0);    vector_init(&east, 0, 0, 0);    // Put magnetometer and accelerometer data into vector format    vector_init(&mag_vector, data->Mx, data->My, data-> Mz);    vector_init(&accel_vector, data->Ax, data->Ay, data-> Az);    // Initialize "from" vector based on carrier board design    vector_init(&from, 1, 0, 0);    // Subtract calibration offset from magnetometer readings    mag_vector.x -= ((float) MAG_MAX_X + MAG_MIN_X) / 2.0;    mag_vector.y -= ((float) MAG_MAX_Y + MAG_MIN_Y) / 2.0;    mag_vector.z -= ((float) MAG_MAX_Z + MAG_MIN_Z) / 2.0;    // Compute East and North    vector_cross(&mag_vector, &accel_vector, &east);    vector_norm(&east);    vector_cross(&accel_vector, &east, &north);    vector_norm(&north);    // Compute the heading and make sure it's positive    heading = (int)(atan2(vector_dot(&east, &from), vector_dot(&north, &from))* 180 / PI);    if (heading < 0) {        heading += 360;    }    // Memory cleanup    vector_destroy(&north);    vector_destroy(&east);    vector_destroy(&mag_vector);    vector_destroy(&accel_vector);    vector_destroy(&from);    return heading; }

void test1(void){    vector_t vec = vector_create2(0, 4);    int value = 1;    for (int i = 0; i < 1000; i++)        vector_push_back(vec, &value);    vector_foreach(vec, test1_walker, NULL);    vector_destroy(vec);}

static void watchfile_destroy(void){  for (int i = 0; i < watchfile_entries.size; ++i) {    struct watchfile_entry *entry = vector_at(&watchfile_entries, i);    free(entry->name);    adex_destroy(&entry->adex);  }  vector_destroy(&watchfile_entries);}

/** * free the vector * @param vec the vector to free */void vector_free(vector_t * vec){#ifdef DEBUG    assert(NULL != vec);#endif    vector_destroy(vec);    free(vec);}

void test__type_get_varg_value__cstl_builtin(void** state){    _typeinfo_t t_info;    size_t i = 0;    vector_t* pvec_result = create_vector(int);    vector_t* pvec_input = create_vector(int);    _test__get_type(&t_info, "vector_t");    t_info._t_style = _TYPE_CSTL_BUILTIN;    vector_init(pvec_result);    vector_init_elem(pvec_input, 10, 100);    _test__type_get_varg_value__stub(pvec_result, &t_info, pvec_input);    assert_true(vector_size(pvec_result) == 10);    for (i = 0; i < 10; ++i) {        assert_true(*(int*)vector_at(pvec_result, i) == 100);    }    vector_destroy(pvec_result);    vector_destroy(pvec_input);}

voidmedia_destroyer(void *item){    sdp_media_t *media = (sdp_media_t *) item;    if (!item)        return;    vector_destroy(media->formats);    sng_free(media);}

/* * read_images: Reads the images from and mnist image db file and puts the *              images into and array of vectors. * * Parameters: *  - train: boolean value, read from training db if 0, test db if 1 * * Return value: *  - array of vectors containing mnist images */ mnist_images_t read_images(uint32_t train){    // Set the filename based the mode (train or test)    char *full_path;    if (train) {        full_path = concat_fname(mnist_path, train_image_fname);    } else {        full_path = concat_fname(mnist_path, test_image_fname);    }    // Open the file for reading    char *mode = FILE_MODE;    FILE *fp = Fopen(full_path, mode);     // Read the header of the file    uint8_t header[IMAGE_HEADER_SIZE];    Fread(header, sizeof(uint8_t), IMAGE_HEADER_SIZE, fp);    // Extract size info from mnist db header    uint32_t num_images = read_word(header, NUM_ITEMS_OFFSET);    uint32_t rows = read_word(header, ROW_OFFSET);    uint32_t cols = read_word(header, COL_OFFSET);    uint32_t img_size = rows * cols;    // Create array of mnist image vectors    vector_t *mnist_data = (vector_t*) Calloc(num_images, sizeof(vector_t));        // Populate vectors with one image each    for (uint32_t i = 0; i < num_images; i++) {        mnist_data[i] = Vector((size_t) img_size);        uint8_t *image_bytes = (uint8_t*) Calloc(img_size, sizeof(uint8_t));        uint32_t actual_size;        // Read img_size bytes from the db file into the byte array        if ((actual_size = fread(image_bytes, sizeof(uint8_t), img_size, fp)) < img_size) {            Free(image_bytes);            for (uint32_t i = 0; i < num_images; i++) vector_destroy(mnist_data[i]);            return NULL;        }        // Move 8 bit data to 32 bit integer for more precision        uint32_t *vector_data = (uint32_t*) Calloc(img_size, sizeof(uint32_t));        for (uint32_t j = 0; j < img_size; j++) {            vector_data[j] = (uint32_t) image_bytes[j];        }        mnist_data[i]->data = vector_data;        Free(image_bytes);    }    // Create the mnist_images_t pointer and populate the struct it points to    mnist_images_t mnist_imgs = Mnist_images((size_t) num_images);     mnist_imgs->imgs = mnist_data;    Free(full_path);    Fclose(fp);    return mnist_imgs;}

static void BM_VectorDestroy(benchmark::State& state){    vector_t * vector = NULL;    while(state.KeepRunning())    {        vector = vector_new(sizeof(int));        vector_destroy(vector);    }}

void del_value(values *v, const char *key) {	vector *values_set;	if (hash_get(v, key, (void**)(&values_set)) == ERR_HASH_NOTFOUND) {		return;	}		vector_destroy(values_set);	return;}

void test__create_vector__registed_type(void** state){    typedef struct _tag__create_vector__registed_type{int n_elem;}_create_vector__registed_type_t;    vector_t* pvec = NULL;    type_register(_create_vector__registed_type_t, NULL, NULL, NULL, NULL);    pvec = _create_vector("_create_vector__registed_type_t");    assert_true(pvec != NULL);    vector_destroy(pvec);}

void hashtbl_destroy(hashtbl_t *h) {  if (!h) return;  for (size_t i = 0; i < h->bktnum; ++i) {    if (h->buckets[i]) {      vector_destroy(h->buckets[i]);    }  }  free(h->buckets);  free(h);}