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

int main(int argc, char *argv[]) {  Point myPoint = point_new(0.0, 0.0);  Vector unitX = vector_new(1.0, 0.0);  Vector unitY = vector_new(0.0, 1.0);  printf("%s + %s + %s = ", point_toString(myPoint),                            vector_toString(unitX),                            vector_toString(unitY) );  point_addVector(myPoint, unitX);  point_addVector(myPoint, unitY);  printf("As a tuple: %s/n", tuple_toString((Tuple)myPoint));  printf("As a point: %s/n", point_toString(myPoint));  printf( "After scaling unitX by -0.5: %s/n",	  vector_toString(vector_scale(unitX, -0.5))	);  printf("unitX has length %lf/n", vector_length(unitX));  vector_delete(unitX);  vector_delete(unitY);  point_delete(myPoint);  return 0;}

// ----------------------------------------------------------------------------voidvertex_buffer_delete( vertex_buffer_t *self ){    assert( self );#ifdef BROKENVAO    if( self->vao_id )        glDeleteVertexArrays(1, &self->vao_id);#endif    vector_delete( self->vertices );    self->vertices = 0;    if( self->vertices_id )    {        glDeleteBuffers( 1, &self->vertices_id );    }    self->vertices_id = 0;    vector_delete( self->indices );    self->indices = 0;    if( self->indices_id )    {        glDeleteBuffers( 1, &self->indices_id );    }    self->indices_id = 0;    if( self->format )    {        free( self->format );    }    self->format = 0;    self->dirty = 0;    free( self );}

int main(void) {	int i;	vector v;	vector_init(&v);	vector_add(&v, "Bonjour");	vector_add(&v, "tout");	vector_add(&v, "le");	vector_add(&v, "monde");	for (i = 0; i < vector_total(&v); i++)		printf("%s ", (char *) vector_get(&v, i));	printf("/n");	vector_delete(&v, 3);	vector_delete(&v, 2);	vector_delete(&v, 1);	vector_set(&v, 0, "Hello");	vector_add(&v, "World");	for (i = 0; i < vector_total(&v); i++)		printf("%s ", (char *) vector_get(&v, i));	printf("/n");	vector_free(&v);}

int main(void){    int i;    vector v;    vector_init(&v);    // char temp1[20]    vector_add(&v, 1);    vector_add(&v, 2);    vector_add(&v, 3);    vector_add(&v, 4);    for (i = 0; i < vector_total(&v); i++)        printf("%s ", (char *) vector_get(&v, i));    printf("/n");    vector_delete(&v, 3);    vector_delete(&v, 2);    vector_delete(&v, 1);    vector_set(&v, 0, "Hello");    vector_add(&v, "World");    for (i = 0; i < vector_total(&v); i++)        printf("%s ", (char *) vector_get(&v, i));    printf("/n");    vector_free(&v);}

// ----------------------------------------------------------------------------voidvertex_buffer_delete( vertex_buffer_t *self ){    assert( self );    vector_delete( self->vertices );    self->vertices = 0;    if( self->vertices_id )    {        glDeleteBuffers( 1, &self->vertices_id );    }    self->vertices_id = 0;    vector_delete( self->indices );    self->indices = 0;    if( self->indices_id )    {        glDeleteBuffers( 1, &self->indices_id );    }    self->indices_id = 0;    if( self->format )    {        free( self->format );    }    self->format = 0;    self->dirty = 0;    free( self );}

int main(void){	vector v;	vector_init(&v);	vector_add(&v, "emil");	vector_add(&v, "hannes");	vector_add(&v, "lydia");	vector_add(&v, "olle");	vector_add(&v, "erik");	int i;	printf("first round:/n");	for (i = 0; i < vector_count(&v); i++) {		printf("%s/n", vector_get(&v, i));	}	vector_delete(&v, 1);	vector_delete(&v, 3);	printf("second round:/n");	for (i = 0; i < vector_count(&v); i++) {		printf("%s/n", vector_get(&v, i));	}	vector_free(&v);	return 0;}

/* build orthonormal basis matrixQ = Y;for j=1:k    vj = Q(:,j);    for i=1:(j-1)        vi = Q(:,i);        vj = vj - project_vec(vj,vi);    end    vj = vj/norm(vj);    Q(:,j) = vj;end*/void build_orthonormal_basis_from_mat(mat *A, mat *Q){    int m,n,i,j,ind,num_ortos=2;    double vec_norm;    vec *vi,*vj,*p;    m = A->nrows;    n = A->ncols;    vi = vector_new(m);    vj = vector_new(m);    p = vector_new(m);    matrix_copy(Q, A);    for(ind=0; ind<num_ortos; ind++){        for(j=0; j<n; j++){            matrix_get_col(Q, j, vj);            for(i=0; i<j; i++){                matrix_get_col(Q, i, vi);                project_vector(vj, vi, p);                vector_sub(vj, p);            }            vec_norm = vector_get2norm(vj);            vector_scale(vj, 1.0/vec_norm);            matrix_set_col(Q, j, vj);        }    }    vector_delete(vi);    vector_delete(vj);    vector_delete(p);}

// ----------------------------------------------------------------------------voidvertex_buffer_delete( vertex_buffer_t *self ){    size_t i;    assert( self );    for( i=0; i<MAX_VERTEX_ATTRIBUTE; ++i )    {        if( self->attributes[i] )        {            vertex_attribute_delete( self->attributes[i] );        }    }#ifdef FREETYPE_GL_USE_VAO    if( self->VAO_id )    {        //needs OpenGL ES 3.0        glDeleteVertexArrays( 1, &self->VAO_id );    }    self->VAO_id = 0;#endif    vector_delete( self->vertices );    self->vertices = 0;    if( self->vertices_id )    {        glDeleteBuffers( 1, &self->vertices_id );    }    self->vertices_id = 0;    vector_delete( self->indices );    self->indices = 0;    if( self->indices_id )    {        glDeleteBuffers( 1, &self->indices_id );    }    self->indices_id = 0;    vector_delete( self->items );    if( self->format )    {        free( self->format );    }    self->format = 0;    self->state = 0;    free( self );}

END_TESTSTART_TEST (delete_element_should_fail_if_invalid_position){  char *sport1 = strdup("winsurf");  vector *v = vector_new(sizeof(char *), free_string, 5);  vector_append(v, &sport1);  fail_unless(vector_delete(v, 2) == VECT_DELETE_INVALID_POSITION);  fail_unless(vector_delete(v, -2) == VECT_DELETE_INVALID_POSITION);  vector_free(v);}

static void vector_2(void) {    vector_t v;    CU_ASSERT(vector_init(&v, "my_vector.bin", 1) == 0);    CU_ASSERT(vector_size(&v) == 0);    CU_ASSERT(vector_pages(&v) == 0);    CU_ASSERT(vector_capacity(&v) == 0);    CU_ASSERT(vector_elem_size(&v) == 1);    CU_ASSERT(vector_size(&v, COUNT) == COUNT);    CU_ASSERT(COUNT <= vector_capacity(&v));    CU_ASSERT(COUNT <= vector_size(&v));    CU_ASSERT(3 <= vector_pages(&v));    for (int i=0; i<COUNT; i++) {        unsigned char c = (unsigned char)i;        crc2 = clib_crc32(c, crc2);        CU_ASSERT(vector_put(&v, i, &c) == 0);    }    CU_ASSERT_FATAL(crc2 != 0);    FILE * f = fopen(v.hdr.name, "w");    CU_ASSERT_FATAL(f != NULL);    CU_ASSERT(COUNT < vector_save(&v, f));    fclose(f), f = NULL;    CU_ASSERT(vector_delete(&v) == 0);}

int main(int argc, char *argv[]) {        vector_t vec;    vector_init(&vec);        printf("vector initialised/n");    printf("vector size=%d/n", vec.size);    printf("vector capacity=%d/n", vec.capacity);        int i;    for (i = 0; i < 50; i++) {        vector_set(&vec, i * 2, i);    }        printf("vector size=%d/n", vec.size);    printf("vector capacity=%d/n", vec.capacity);        while (vec.size > 10) {        int v = vector_get(&vec, 0);        vector_delete(&vec, 0);    }        printf("vector size=%d/n", vec.size);    printf("vector capacity=%d/n", vec.capacity);        vector_set(&vec, vec.size, 100);        printf("vector size=%d/n", vec.size);    printf("vector capacity=%d/n", vec.capacity);        return 0;}

void test_long() {    struct vector* v = vector_new(0, sizeof(long));    long n=10;    long i=0;    for (i=0; i<n; i++) {        vector_push(v, &i);    }    long* iter = vector_front(v);    long* end  = vector_end(v);    i=0;    while (iter != end) {        assert(i == *iter);        iter++;        i++;    }    long* lptr = vector_get(v,3);    assert(3 == *lptr);    lptr = vector_pop(v);    assert((n-1) == *lptr);    v=vector_delete(v);    assert(v==NULL);}

void test_pushpop() {    struct vector* v = vector_new(0, sizeof(struct test));    size_t i=0;    size_t n=10;    struct test t;    for (i=0; i<n; i++) {        t.id = i;        t.x = 2*i;        vector_push(v, &t);    }    struct test *tptr=NULL;    for (i=0; i<n; i++) {        tptr = vector_get(v,i);        assert(tptr->id == i);        assert(tptr->x == 2*i);    }    i=n-1;    while (NULL != (tptr=vector_pop(v))) {        assert(tptr->id == i);        assert(tptr->x == 2*i);        i--;    }    assert(v->size == 0);    assert(v->capacity >= n);    v = vector_delete(v);    assert(v == NULL);}

int main(int argc, char **argv){    int t = 0;    for (int c; (c = getopt(argc, argv, "n:p:")) != -1;) {        switch(c) {            case 'n':                t = atoi(optarg);                break;        }    }    uint32_t result = 1;    vector(int) *vstep = vector_new(int, 100);    int i = 0;    int pivot = 1;     int base = 10;    while(i < 1000000) {        i += pivot * (base - base / 10);         ++pivot;        base *= 10;        vector_pushback(vstep, i);    }        for(base = 1; base <= 1000000; base *= 10) {        if(t > 0) base = t;        i = 1;        int last = 0;        vector_closure(vstep, pivot) {            if(base <= pivot) break;            i++;            last = pivot;        }        int pbase;        pbase = POW(10, i - 1) - 1;        int ofs = (base - last);        ofs = (ofs % i == 0) ? ofs / i : ofs / i+ 1;        int num = pbase + ofs;        int dn;        int dofs = (i - (base - last) % i) % i;        DUMPD(dofs);        dn = num / POW(10, dofs);        dn %= 10;        DUMPD(base);        DUMPD(dn);        result *= dn;        if(t > 0) break;    }    DUMPD(result);     vector_delete(vstep);    return 0;}

static void vector_4(void) {    vector_t v;    if (vector_init(&v, NULL, 0) < 0) {        err_t * err = err_get();        fprintf(stderr, "%s(%d): UNEXPECTED: %.*s/n",                err_file(err), err_line(err), err_size(err),		(const char *)err_data(err));    }    if (vector_init(&v, "my_vector", 0) < 0) {	err_t * err = err_get();        fprintf(stderr, "%s(%d): UNEXPECTED: %.*s/n",                err_file(err), err_line(err), err_size(err),		(const char *)err_data(err));    }    for (size_t i=VECTOR_ELEM_MIN; i<=VECTOR_ELEM_MAX; i+=3) {        vector_init(&v, "my_vector", i);        CU_ASSERT(vector_size(&v) == 0);        CU_ASSERT(vector_pages(&v) == 0);        CU_ASSERT(vector_capacity(&v) == 0);        CU_ASSERT(vector_elem_size(&v) == i);        CU_ASSERT(vector_elem_size(&v) * v.hdr.elem_num <= v.hdr.page_size);        vector_size(&v, COUNT);        CU_ASSERT(vector_size(&v) == COUNT);        CU_ASSERT(vector_size(&v) <= vector_capacity(&v));        CU_ASSERT(0 < vector_pages(&v));        vector_delete(&v);    }}

static void vector_3(void) {    vector_t v;    vector_init(&v, __func__, 1);    CU_ASSERT(vector_size(&v) == 0);    CU_ASSERT(vector_pages(&v) == 0);    CU_ASSERT(vector_capacity(&v) == 0);    CU_ASSERT(vector_elem_size(&v) == 1);    FILE * f = fopen("my_vector.bin", "r");    CU_ASSERT_FATAL(f != NULL);    CU_ASSERT(COUNT < vector_load(&v, f));    fclose(f), f = NULL;    crc3 = 0;    for (int i=0; i<COUNT; i++) {        unsigned char c;        vector_get(&v, i, &c);        crc3 = clib_crc32(c, crc3);    }    CU_ASSERT_FATAL(crc3 != 0);    CU_ASSERT_FATAL(crc2 == crc3);    vector_delete(&v);}

// --------------------------------------------------- texture_glyph_delete ---voidtexture_glyph_delete( texture_glyph_t *self ){    assert( self );    vector_delete( self->kerning );    free( self );}

/* Performs [Q,R] = qr(M,'0') compact QR factorization M is mxn ; Q is mxn ; R is min(m,n) x min(m,n) */ void compact_QR_factorization(mat *M, mat *Q, mat *R){    int i,j,m,n,k;    m = M->nrows; n = M->ncols;    k = min(m,n);    mat *R_full = matrix_new(m,n);    matrix_copy(R_full,M);    vec *tau = vector_new(m);    // get R    //LAPACKE_dgeqrf(CblasRowMajor, m, n, R_full->d, n, tau->d);    culaDgeqrf(m, n, R_full->d, m, tau->d);        for(i=0; i<k; i++){        for(j=0; j<k; j++){            if(j>=i){                matrix_set_element(R,i,j,matrix_get_element(R_full,i,j));            }        }    }    // get Q    matrix_copy(Q,R_full);     //LAPACKE_dorgqr(CblasRowMajor, m, n, n, Q->d, n, tau->d);    culaDorgqr(m, n, n, Q->d, m, tau->d);    // clean up    matrix_delete(R_full);    vector_delete(tau);}

static void free_config (struct config_s *conf){        safefree (conf->config_file);        safefree (conf->logf_name);        safefree (conf->stathost);        safefree (conf->user);        safefree (conf->group);        vector_delete(conf->listen_addrs);#ifdef FILTER_ENABLE        safefree (conf->filter);#endif                          /* FILTER_ENABLE */#ifdef REVERSE_SUPPORT        free_reversepath_list(conf->reversepath_list);        safefree (conf->reversebaseurl);#endif#ifdef UPSTREAM_SUPPORT        free_upstream_list (conf->upstream_list);#endif                          /* UPSTREAM_SUPPORT */        safefree (conf->pidpath);        safefree (conf->bind_address);        safefree (conf->via_proxy_name);        hashmap_delete (conf->errorpages);        free_added_headers (conf->add_headers);        safefree (conf->errorpage_undef);        safefree (conf->statpage);        flush_access_list (conf->access_list);        free_connect_ports_list (conf->connect_ports);        hashmap_delete (conf->anonymous_map);        memset (conf, 0, sizeof(*conf));}

void config_delete(config_t c){	for (int i = 0; i < vector_size(c); ++i)	{		free(c[i].name);	}	vector_delete(c);}

int main(int argc, char **argv) {	vector_t *v;		printf("Calling vector_new()/n");	v = vector_new();		printf("Calling vector_delete()/n");	vector_delete(v);		printf("vector_new() again/n");	v = vector_new();	printf("These should all return 0 (vector_get()): ");	printf("%d ", vector_get(v, 0));	printf("%d ", vector_get(v, 1));	printf("%d/n", vector_get(v, 2));	printf("Doing a bunch of vector_set()s/n");	vector_set(v, 0, 98);	vector_set(v, 11, 15);	vector_set(v, 15, -23);	vector_set(v, 24, 65);        vector_set(v, 500, 3);	vector_set(v, 12, -123);	vector_set(v, 15, 21);	vector_set(v, 25, 43);	printf("These should be equal:/n");	printf("98 = %d/n", vector_get(v, 0));	printf("15 = %d/n", vector_get(v, 11));	printf("65 = %d/n", vector_get(v, 24));	printf("-123 = %d/n", vector_get(v, 12));	printf("21 = %d/n", vector_get(v, 15));	printf("43 = %d/n", vector_get(v, 25));        printf("0 = %d/n", vector_get(v, 23));        printf("0 = %d/n", vector_get(v, 1));        printf("0 = %d/n", vector_get(v, 501));        printf("3 = %d/n", vector_get(v, 500));        vector_delete(v);	printf("Test complete./n");		return 0;}

int vector_test(void) {	vector v = vector_new(5);	int i;	for (i=0; i<5; i++) assert(vector_set(&v, i, i*10));	for (i=5; i<10; i++) assert(vector_set(&v, i, i*10));	for (i=0; i<10; i++) printf("item[%i] = %i/n", i, v.items[i]);	vector_delete(&v);}

// ----------------------------------------------------------------------------voidtext_buffer_delete( text_buffer_t * self ){    vector_delete( self->lines );    font_manager_delete( self->manager );    vertex_buffer_delete( self->buffer );    glDeleteProgram( self->shader );    free( self );}

void ast_tree_recursive_clear(struct ast_tree_t *t) {    size_t i, len = t->children->size;    for (i = 0; i < len; i++) {        ast_recursive_delete(vector_get(t->children, i));    }    vector_delete(t->children);    t->children = NULL;}

// ----------------------------------------------------------------------------voidvertex_buffer_delete( vertex_buffer_t *self ){    size_t i;    assert( self );    for( i=0; i<MAX_VERTEX_ATTRIBUTE; ++i )    {        if( self->attributes[i] )        {            vertex_attribute_delete( self->attributes[i] );        }    }    vector_delete( self->vertices );    self->vertices = 0;    if( self->vertices_id )    {        glDeleteBuffers( 1, &self->vertices_id );    }    self->vertices_id = 0;    vector_delete( self->indices );    self->indices = 0;    if( self->indices_id )    {        glDeleteBuffers( 1, &self->indices_id );    }    self->indices_id = 0;    vector_delete( self->items );    if( self->format )    {        free( self->format );    }    self->format = 0;    self->state = 0;    free( self );}

/* computes SVD: M = U*S*V^T; note Vt = V^T */void singular_value_decomposition(mat *M, mat *U, mat *S, mat *Vt){    int m,n,k;    m = M->nrows; n = M->ncols;    k = min(m,n);    vec * svals = vector_new(k);    //LAPACKE_dgesvd( LAPACK_COL_MAJOR, 'S', 'S', m, n, M->d, m, svals->d, U->d, m, Vt->d, k, work->d );    culaDgesvd('S', 'S', m, n, M->d, m, svals->d, U->d, m, Vt->d, k);    initialize_diagonal_matrix(S, svals);    vector_delete(svals);}

static void delete_session(struct libwebsocket *wsi) {    int count = vector_count(sessions);    for (int i = 0; i < count; i++) {        server_session_t *s = vector_get(sessions, i);        if (s != NULL && s->wsi == wsi) {            vector_delete(sessions, i);            break;        }    }}

/* copy the first k columns of M into M_out where k = M_out->ncols (M_out pre-initialized) */void matrix_copy_first_columns(mat *M_out, mat *M){    int i,k;    k = M_out->ncols;    vec * col_vec;    for(i=0; i<k; i++){        col_vec = vector_new(M->nrows);        matrix_get_col(M,i,col_vec);        matrix_set_col(M_out,i,col_vec);        vector_delete(col_vec);    }}