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

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

static void		init_vector(t_svr_vector *vec, t_select *slt){  vec->slt = slt;  vec->client = vector_new(NULL);  vec->action = vector_new(NULL);  vec->graph = vector_new(NULL);}

void hashmap_new(hashmap* hm, int elem_size, int num_buckets, hashmap_hash_fun hash_fun, hashmap_compare_fun compare_fun, hashmap_free_fun free_fun, key_type type){	assert(elem_size > 0 || num_buckets > 0 || hash_fun != NULL || compare_fun != NULL);	if ((hm->pairs = malloc((num_buckets + 1) * sizeof(vector))) == NULL) {		printf("memory allocation error in hm->pairs creation./n");		exit(0);	}	// Problem with position initilization at 0, so i use a dirty solution, added 1 in	// some places, but no in hm->num_buckets, for simpliest code.	for (int i = 1; i < num_buckets + 1; ++i)		vector_new(hm->pairs + i, sizeof(pair), free_fun, 4);	if ((hm->used_buckets = malloc(sizeof(vector))) == NULL) {		printf("memory allocation error in hm->used_buckets creation./n");		return ;	}	vector_new(hm->used_buckets, sizeof(int), NULL, 4);	hm->k_type = type;	hm->pairs->elem_size = sizeof(vector);	hm->num_buckets = num_buckets;	hm->compare_fun = compare_fun;	hm->free_fun = free_fun;	hm->hash_fun = hash_fun;	hm->value_size = elem_size;}

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

t_ray	*ray_new(void){	t_ray	*rayon;	rayon = (t_ray	*)malloc(sizeof(t_ray));	rayon->o = vector_new(0, 0, 0);	rayon->d = vector_new(0, 0, 0);	return (rayon);}

// ----------------------------------------------------------------------------vertex_buffer_t *vertex_buffer_new( const char *format ){    size_t i, index = 0, stride = 0;    const char *start = 0, *end = 0;    char *pointer = 0;    vertex_buffer_t *self = (vertex_buffer_t *) malloc (sizeof(vertex_buffer_t));    if( !self )    {        return NULL;    }    self->format = strdup( format );    for( i=0; i<MAX_VERTEX_ATTRIBUTE; ++i )    {        self->attributes[i] = 0;    }    start = format;    do    {        end = (char *) (strchr(start+1, ':'));        char *desc = 0;        if (end == NULL)        {            desc = strdup(start);        }        else        {            desc = strdup(start);            desc[end-start] = '0';        }        vertex_attribute_t *attribute = vertex_attribute_parse( desc );        start = end+1;        free(desc);        attribute->pointer = pointer;        stride += attribute->size*GL_TYPE_SIZE( attribute->type );        pointer+= attribute->size*GL_TYPE_SIZE( attribute->type );        self->attributes[index] = attribute;        index++;    } while ( end && (index < MAX_VERTEX_ATTRIBUTE) );    for( i=0; i<index; ++i )    {        self->attributes[i]->stride = stride;    }    self->vertices = vector_new( stride );    self->vertices_id  = 0;    self->indices = vector_new( sizeof(GLuint) );    self->indices_id  = 0;    self->dirty = 1;    return self;}

btc_tx* btc_tx_new(){    btc_tx* tx;    tx = calloc(1, sizeof(*tx));    tx->vin = vector_new(8, btc_tx_in_free_cb);    tx->vout = vector_new(8, btc_tx_out_free_cb);    tx->version = 1;    tx->locktime = 0;    return tx;}

voidmodule_init(){    ModuleList = vector_new(0, sizeof(Module));    ModulePaths = vector_new(0, sizeof(char *));    ModuleSection = config_register_section("module", false);    config_register_field(ModuleSection, "path", json_type_string,                          module_config_set_path);}

END_TESTSTART_TEST (new_should_return_error_if_invalid_elem_size_or_initial){  vector *v;  v = vector_new(0, NULL, 10);  fail_unless(v == NULL, "should fail if invalid size");  v = vector_new(sizeof(int), NULL, 0);  fail_unless(v == NULL, "should fail if invalid initial");  vector_free(v);}

void run() {    int t = 0;    vector* stack = vector_new(100);    vector_push(stack, (void*)0);    while (1) {        t = cur_token();        action a = table[(int)vector_peek(stack)][t];        if (a.action == 's') {            vector_push(stack, (void*)a.attr);            index++;            printf("shift %d/n", a.attr);        } else if (a.action == 'r') {            for (int i=0; i<rules[a.attr][0]-1; i++)                vector_pop(stack);            int head_of_production = rules[a.attr][1];            int top_of_stack = (int)vector_peek(stack);            int new_state = table[top_of_stack][head_of_production].attr;            vector_push(stack, (void*)new_state);            printf("Reduce by rule %d/n", a.attr);            printf("Stack top: %d/n", (int)vector_peek(stack));        } else if (a.action == 'a') {            printf("Accept/n");            break;        } else {            error("Parsing failed", "");        }    }}

void hashset_add(Hashset *self, const char *key) {    assert(self);    assert(key);    u64 hash = _hashset_djb2(key);    u32 index = _hashset_index(self, key);    Vector *bucket = NULL;    if (!self->buckets[index]) {        self->buckets[index] = vector_new(8, free);    }    bucket = self->buckets[index];    for (u32 i = 0; i < bucket->size; ++i) {        void *pkvp = vector_index(bucket, i);        HashsetNode *kvp = (HashsetNode *)pkvp;        // key already exists in hashset, set it to true and return success        if (kvp->key == hash) {            kvp->value = true;            return;        }    }    HashsetNode *kvp = (HashsetNode *)calloc(1, sizeof(HashsetNode));    kvp->key = hash;    kvp->value = true;    vector_add(bucket, kvp);}

text_buffer_t *text_buffer_new_with_program( size_t depth,                                    GLuint program ){    text_buffer_t *self = (text_buffer_t *) malloc (sizeof(text_buffer_t));    self->buffer = vertex_buffer_new(                                     "vertex:3f,tex_coord:2f,color:4f,ashift:1f,agamma:1f" );    self->manager = font_manager_new( 512, 512, depth );    self->shader = program;    self->shader_texture = glGetUniformLocation(self->shader, "tex");    self->shader_pixel = glGetUniformLocation(self->shader, "pixel");    self->line_start = 0;    self->line_ascender = 0;    self->base_color.r = 0.0;    self->base_color.g = 0.0;    self->base_color.b = 0.0;    self->base_color.a = 1.0;    self->line_descender = 0;    self->lines = vector_new( sizeof(line_info_t) );    self->bounds.left   = 0.0;    self->bounds.top    = 0.0;    self->bounds.width  = 0.0;    self->bounds.height = 0.0;    return self;}

vector_t * vector_deep_copy(vector_t * vector, libcontain_copy_func_t vector_valcopy_func){	size_t i;	size_t size;	vector_t * retval;	void * val;	rw_spinlock_read_lock(vector->lock);	do	{		size = vector->size;	} while (!size);	retval = vector_new(size);	if (!retval)		goto abort_vector_deep_copy1;	for (i = 0; i < size; i++)	{		val = vector_get(vector, i);		if (val != NULL)			if (vector_put(retval, i, vector_valcopy_func(vector->nodes[i].val)) != 0)				goto abort_vector_deep_copy2;	}	rw_spinlock_read_unlock(vector->lock);	return retval;abort_vector_deep_copy2:	vector_free(retval);abort_vector_deep_copy1:	rw_spinlock_read_unlock(vector->lock);	return NULL;}

vector *ol_bulk_unjar(ol_database *db, const ol_key_array keys, const size_t num_keys) {    ol_transaction *tx = NULL;    vector *to_return = NULL;    check(db != NULL, "Cannot unjar on NULL database.");    check((tx = olt_begin(db)) != NULL, "Could not begin transaction.");    to_return = vector_new(sizeof(unsigned char *), 256);    unsigned int i;    for (i = 0; i < num_keys; i++) {        const char *key = keys[i];        unsigned char *item = NULL;        size_t item_size = 0;        olt_unjar(tx, key, strnlen(key, KEY_SIZE), &item, &item_size);        if (item != NULL) {            vector_append_ptr(to_return, item);        } else {            vector_append_ptr(to_return, NULL);        }    }    check(olt_commit(tx) == 0, "Could not commit unjar transaction.");    return to_return;error:    return NULL;}

void			ft_set_plan(t_data *data, char **line, int fd){	int			cons;	char		ref;	data->origin = '0';	data->color = '0';	data->co = '0';	ref = 0;	while (ft_strcmp("#end_object", *line) != 0)	{		if (ft_strcmp("#const", *line) == 0 && (data->co = '1'))			ft_set_plan_const(&cons, line, fd);		else if (ft_strcmp("#origin", *line) == 0 && (data->origin = '1'))			ft_set_plan_origin(data, line, fd);		else if (ft_strcmp("#color", *line) == 0 && (data->color = '1'))			ft_set_plan_color(data, line, fd);		else if (ft_strcmp("#ref", *line) == 0)			ft_set_plan_ref(&ref, line, fd);		if (get_next_line(fd, line) <= 0)			ft_error("[ERROR OBJECT] - Object plan has no end");	}	if (data->origin == '0' || data->co == '0' || data->color == '0')		ft_error("[ERROR OBJECT] - Plan's spec missing");	plan_new(vector_new(data->x, data->y, data->z), cons	, color_set((int)data->x2, (int)data->y2, (int)data->z2, ref));}

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

struct vector* vector_normalize(struct vector* v) {    struct vector* vnorm = vector_new(v->length);    double norm = vector_norm(v);    assert(norm != 0);    vector_normalize_into(vnorm, v);    return vnorm;}

struct vector* vector_scalar_multiply(struct vector* v, double s) {    struct vector* w = vector_new(v->length);    for(int i = 0; i < v->length; i++) {        VECTOR_IDX_INTO(w, i) = VECTOR_IDX_INTO(v, i) * s;    }    return w;}

int main (int argc, char **argv){    int error = 0;    Vector *vector = vector_new ();        if (vector_load_from_file (vector, argc, argv))    {        Stopwatch *stopwatch = stopwatch_new ();        uint64_t inversions = 0;        stopwatch_start (stopwatch);                inversions = count_inversions (vector);                stopwatch_stop (stopwatch);                printf ("%llu inversions of %zu numbers in %llu.%03u ms./n", inversions, vector->length, stopwatch->elapsed, stopwatch->usec);                stopwatch_free (stopwatch);    }    else    {        error = 1;    }        vector_free (vector);        return error;}

/* ------------------------------------------------------------------------- */TextureAtlas *texture_atlas_new( size_t width, size_t height, size_t depth ){    assert( (depth == 1) || (depth == 3) );    TextureAtlas *self = (TextureAtlas *) malloc( sizeof(TextureAtlas) );    if( !self )    {        return NULL;    }    self->nodes = vector_new( sizeof(Node) );    self->used = 0;    self->width = width;    self->height = height;    self->depth = depth;    Node node = {0,0,width};    vector_push_back( self->nodes, &node );    self->texid = 0;    self->data = (unsigned char *)        calloc( width*height*depth, sizeof(unsigned char) );    // This is a special region that is used for background and underlined    // decorations of glyphs    int n = 4;    unsigned char buffer[n*n];    memset(buffer, 255, n*n);    Region1 r = texture_atlas_get_region( self, n, n );    texture_atlas_set_region( self, r.x, r.y, r.width, r.height, buffer, 1);    self->black.x     = r.x + 1;    self->black.y     = r.y + 1;    self->black.width = r.width - 2;    self->black.height= r.height - 2;    return self;}

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("%s/n", point_toString(myPoint));  return 0;}

void test_sort() {    struct vector* v = vector_new(7, sizeof(struct test));    struct test* t = NULL;    t = vector_get(v,0);    t->id = 4;    t = vector_get(v,1);    t->id = 1;    t = vector_get(v,2);    t->id = 2;    t = vector_get(v,3);    t->id = 0;    t = vector_get(v,4);    t->id = 3;    t = vector_get(v,5);    t->id = 6;    t = vector_get(v,6);    t->id = 5;    vector_sort(v, &compare_test);    size_t i=0;    struct test* iter = vector_front(v);    struct test* end  = vector_end(v);    while (iter != end) {        assert(iter->id == i);        iter++;        i++;    }}

struct point_hash* point_hash_new(int64 hpixid) {    struct point_hash* pth =         alloc_or_die(sizeof(struct point_hash),"hash entry");    pth->points = vector_new(0,sizeof(struct point*));    pth->hpixid=hpixid;    return pth;}

/* allocates the vector, and wraps it up into a data structure that ruby can understand */static VALUE vector_alloc(VALUE klass) {  Vector *vector;  VALUE obj;  vector = vector_new();  obj = Data_Wrap_Struct(klass, 0, vector_free, vector);  return obj;}

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() {    /* Create the vector */    vector *v = vector_new(3);    printf("Vector size: %d/n", vector_size(v));    /* Add elements to the vector */    vector_push(v, (void*)0);    vector_push(v, (void*)11);    vector_push(v, (void*)22);    printf("Vector size: %d/n", vector_size(v));    vector_push(v, (void*)33);    vector_push(v, (void*)44);    vector_push(v, (void*)55);    vector_push(v, (void*)66);    /* Get the size and print the elements */    printf("Vector size: %d/n", vector_size(v));    printf("Element 1: %d/n", vector_get(v, 0));    printf("Element 2: %d/n", vector_get(v, 1));    printf("Element 3: %d/n", vector_get(v, 2));    printf("Element 4: %d/n", vector_get(v, 3));    printf("Element 5: %d/n", vector_get(v, 4));    printf("Element 6: %d/n", vector_get(v, 5));    printf("Element 7: %d/n", vector_get(v, 6));    /* Clear vector and print the size */    vector_clear(v);    printf("Vector size: %d/n", vector_size(v));    /* We have not destructor at C, so clean up memory by ourselves */    vector_free(v);    return 0;}

// ------------------------------------------------------ texture_glyph_new ---texture_glyph_t *texture_glyph_new( void ){    texture_glyph_t *self = (texture_glyph_t *) malloc( sizeof(texture_glyph_t) );    if( self == NULL)    {        fprintf( stderr,                 "line %d: No more memory for allocating data/n", __LINE__ );        exit( EXIT_FAILURE );    }    self->id        = 0;    self->width     = 0;    self->height    = 0;    self->outline_type = 0;    self->outline_thickness = 0.0;    self->offset_x  = 0;    self->offset_y  = 0;    self->advance_x = 0.0;    self->advance_y = 0.0;    self->s0        = 0.0;    self->t0        = 0.0;    self->s1        = 0.0;    self->t1        = 0.0;    self->kerning   = vector_new( sizeof(kerning_t) );    return self;}

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