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

plot_dataset_type * plot_alloc_new_dataset(plot_type * plot , const char * __label , plot_data_type data_type) {  if (data_type == PLOT_HIST) {    if (vector_get_size( plot->dataset) > 0)      util_abort("%s: sorry - when using histograms you can *only* have one dataset/n",__func__);    plot->is_histogram = true;  } else if (plot->is_histogram)    util_abort("%s: sorry - when using histograms you can *only* have one dataset/n",__func__);    {    char * label;    if (__label == NULL)      label = util_alloc_sprintf("data_%d" , vector_get_size( plot->dataset ));    else      label = (char *) __label;        if (hash_has_key( plot->dataset_hash , label))      util_abort("%s: sorry - the label %s is already in use - must be unique /n",__func__ , label);    {      plot_dataset_type * dataset = plot_dataset_alloc(data_type, label , plot->logx , plot->logy);      vector_append_owned_ref(plot->dataset , dataset , plot_dataset_free__);      hash_insert_ref( plot->dataset_hash , label , dataset);      if (__label == NULL)        free(label);      return dataset;    }  }}  

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

void test_reverse() {  const char * val1 = "value1";  const char * val2 = "value2";  const char * val3 = "value3";  const char * val4 = "value4";    vector_type * vector1 = vector_alloc_new(  );  vector_type * vector2 = vector_alloc_new(  );  vector_append_ref( vector1 , val1 );  vector_append_ref( vector1 , val2 );  vector_append_ref( vector1 , val3 );  vector_append_ref( vector1 , val4 );  vector_append_ref( vector2 , val1 );  vector_append_ref( vector2 , val2 );  vector_append_ref( vector2 , val3 );  vector_append_ref( vector2 , val4 );  vector_inplace_reverse( vector1 );  {    int i;    int size = vector_get_size( vector1 );    for (i=0; i < vector_get_size( vector1 ); i++)      test_assert_ptr_equal( vector_iget_const( vector2 , i ) , vector_iget_const( vector1 , size - 1 - i ));  }  vector_free( vector1 );  vector_free( vector2 );}

void misfit_ensemble_fwrite( const misfit_ensemble_type * misfit_ensemble , FILE * stream ) {  int ens_size = vector_get_size( misfit_ensemble->ensemble);  util_fwrite_int( misfit_ensemble->history_length , stream );  util_fwrite_int( vector_get_size( misfit_ensemble->ensemble ) , stream);  /* Writing the nodes - one for each ensemble member */  {    int iens;    for (iens = 0; iens < ens_size; iens++)       misfit_member_fwrite( vector_iget( misfit_ensemble->ensemble , iens ) , stream );   }  }

int obs_vector_get_next_active_step(const obs_vector_type * obs_vector , int prev_step) {  if (prev_step >= (vector_get_size(obs_vector->nodes) - 1))    return -1;  else {    int size      = vector_get_size( obs_vector->nodes );    int next_step = prev_step + 1;    while (( next_step < size) && (obs_vector_iget_node(obs_vector , next_step) == NULL))      next_step++;    if (next_step == size)      return -1; /* No more active steps. */    else      return next_step;  }}

void ensemble_init( ensemble_type * ensemble , config_type * config) {  /*1 : Loading ensembles and settings from the config instance */  /*1a: Loading the eclipse summary cases. */  {    thread_pool_type * tp = thread_pool_alloc( LOAD_THREADS , true );    {      int i,j;      for (i=0; i < config_get_occurences( config , "CASE_LIST"); i++) {        const stringlist_type * case_list = config_iget_stringlist_ref( config , "CASE_LIST" , i );        for (j=0; j < stringlist_get_size( case_list ); j++)           ensemble_load_from_glob( ensemble , stringlist_iget( case_list , j ) , tp);      }    }    thread_pool_join( tp );    thread_pool_free( tp );  }    {    const sum_case_type * tmp = vector_iget_const( ensemble->data , 0 );    ensemble->refcase = tmp->ecl_sum;  }    /*1b: Other config settings */  if (config_item_set( config , "NUM_INTERP" ))    ensemble->num_interp  = config_iget_as_int( config , "NUM_INTERP" , 0 , 0 );      /*2: Remaining initialization */  ensemble_init_time_interp( ensemble );  if (vector_get_size( ensemble->data ) < MIN_SIZE )    util_exit("Sorry - quantiles make no sense with with < %d realizations; should have ~> 100./n" , MIN_SIZE);}

static void assert_type_and_index( const ecl_rft_node_type * rft_node , ecl_rft_enum target_type , int index) {  if (rft_node->data_type != target_type)    util_abort("%s: wrong type /n",__func__);  if ((index < 0) || (index >= vector_get_size( rft_node->cells )))    util_abort("%s: invalid index:%d /n",__func__ , index);}

config_path_elm_type * config_content_add_path_elm( config_content_type * content , const char * path ) {  const config_path_elm_type * current_path_elm;  if (vector_get_size( content->path_elm_stack ) == 0)    current_path_elm = NULL;  else    current_path_elm = vector_get_last_const(content->path_elm_stack);  {    config_path_elm_type * new_path_elm;    {      char * rel_path = NULL;      config_root_path_type * invoke_path = config_content_get_invoke_path( content );      if (path != NULL) {        if (current_path_elm == NULL)          rel_path = util_alloc_rel_path( config_root_path_get_abs_path(invoke_path) , path);        else          rel_path = config_path_elm_alloc_relpath( current_path_elm , path );      }      new_path_elm = config_path_elm_alloc( invoke_path , rel_path );      util_safe_free( rel_path );    }    vector_append_owned_ref( content->path_elm_storage , new_path_elm , config_path_elm_free__);    vector_append_ref( content->path_elm_stack , new_path_elm );    return new_path_elm;  }}

double sched_file_well_wconinje_rate( const sched_file_type * sched_file ,                                       int restart_nr ,                                       const char * well_name) {  double rate = -1;  bool well_found = false;  int block_nr    = restart_nr;  while (!well_found && (block_nr >= 0)) {    sched_block_type * block = sched_file_iget_block( sched_file , block_nr );        if (hash_has_key( block->kw_hash , "WCONINJE")) {      const vector_type * wconhist_vector = hash_get( block->kw_hash , "WCONINJE");      int i;      for (i=0; i < vector_get_size( wconhist_vector ); i++) {        sched_kw_type * kw = vector_iget( wconhist_vector , i );        if (sched_kw_has_well( kw , well_name )) {          well_found = true;          rate = sched_kw_wconinje_get_surface_flow( sched_kw_get_data( kw ) , well_name );        }      }    }        block_nr--;  }   return rate;}

/**   Will return NULL if the block which is asked for is not present.*/static file_map_type * file_map_alloc_blockmap(const file_map_type * file_map , const char * header, int occurence) {  if (file_map_get_num_named_kw( file_map , header ) > occurence) {    file_map_type * block_map = file_map_alloc( file_map->fortio , file_map->flags , file_map->inv_map , false);    if (file_map_has_kw( file_map , header )) {      int kw_index = file_map_get_global_index( file_map , header , occurence );      ecl_file_kw_type * file_kw = vector_iget( file_map->kw_list , kw_index );            while (true) {        file_map_add_kw( block_map , file_kw );                kw_index++;        if (kw_index == vector_get_size( file_map->kw_list ))          break;                      else {          file_kw = vector_iget(file_map->kw_list , kw_index);          if (strcmp( header , ecl_file_kw_get_header( file_kw )) == 0)            break;        }      }    }     file_map_make_index( block_map );    return block_map;  } else    return NULL;}

vector_type * load_expected( const ecl_grid_type * grid, const char * filename ) {  FILE * stream = util_fopen( filename , "r");  vector_type * expected = vector_alloc_new();  while (true) {    double x,y,z;    int i,j,k,skip;    if (fscanf( stream , "%lg %lg %lg %d %d %d %d" , &x,&y,&z,&i,&j,&k,&skip) == 7) {      point_type * p = util_malloc( sizeof * p );      p->x = x;      p->y = y;      p->z = z;      p->i = i-1;      p->j = j-1;      p->k = k-1;      p->skip = skip;      p->g = ecl_grid_get_global_index3(grid,    p->i, p->j, p->k);      vector_append_owned_ref( expected, p , free );    } else      break;  }  fclose( stream );  test_assert_int_equal( 10 , vector_get_size( expected ));  return expected;}

static void file_map_fwrite( const file_map_type * file_map , fortio_type * target , int offset) {  int index;  for (index = offset; index < vector_get_size( file_map->kw_list ); index++) {    ecl_kw_type * ecl_kw = file_map_iget_kw( file_map , index );    ecl_kw_fwrite( ecl_kw , target );  }}

void gen_kw_config_update_tag_format(gen_kw_config_type * config , const char * tag_format) {  int i;    config->tag_fmt = tag_format;  for (i=0; i < vector_get_size( config->parameters ); i++)     gen_kw_parameter_update_tagged_name( vector_iget( config->parameters , i ) , config->tag_fmt);}

void subst_list_fprintf(const subst_list_type * subst_list , FILE * stream) {  int index;  for (index=0; index < vector_get_size( subst_list->string_data ); index++) {    const subst_list_string_type * node = vector_iget_const( subst_list->string_data , index );    fprintf(stream , "%s = %s/n" , node->key , node->value);  }}

int main(int argc , char ** argv) {  util_install_signals();  {    ecl_grid_type * grid = ecl_grid_alloc( argv[1] );    vector_type * expected = load_expected( grid, argv[2] );    for (int c=0; c < vector_get_size( expected ); c++) {      const point_type * p = vector_iget_const( expected , c );      int g = ecl_grid_get_global_index_from_xyz(grid , p->x, p->y , p->z , 0 );      if (g != ecl_grid_get_global_index3(grid, p->i,p->j, p->k)) {        int i,j,k;        ecl_grid_get_ijk1(grid, g, &i, &j, &k);        fprintf(stderr,"point:%d   (%g,%g,%g), Simulated: %d:(%d,%d,%d)   Expected: %d:(%d,%d,%d)  contains:%d/n",                c , p->x, p->y, p->z, g, i,j,k, p->g, p->i, p->j, p->k, ecl_grid_cell_contains_xyz1( grid, p->g , p->x , p->y, p->z));      }      if (!p->skip)        test_assert_int_equal( g , ecl_grid_get_global_index3(grid, p->i,p->j, p->k));      else {        if ( g != ecl_grid_get_global_index3(grid, p->i,p->j, p->k))          fprintf(stderr," ** Skipping failed test for point:%d /n",c);      }    }    ecl_grid_free( grid );    vector_free( expected );  }  exit(0);}

void group_rate_update_wconinje( group_rate_type * group_rate , sched_kw_wconinje_type * kw, int restart_nr ) {  int well_nr;  for (well_nr = 0; well_nr < vector_get_size( group_rate->well_rates ); well_nr++) {    well_rate_type * well_rate = vector_iget( group_rate->well_rates , well_nr );    well_rate_update_wconinje( well_rate ,kw , restart_nr );  }}

static void file_map_load_all( file_map_type * file_map ) {  int index;  for (index = 0; index < vector_get_size( file_map->kw_list); index++) {    ecl_file_kw_type * ikw = vector_iget( file_map->kw_list , index );    ecl_file_kw_get_kw( ikw , file_map->fortio , file_map->inv_map);  }}

void comms_load_player_choices(){	while (vector_get_size(&comms_player_choices) > 0)	{		Comms_PlayerChoice *pc = (Comms_PlayerChoice *)vector_get(&comms_player_choices, 0);		vector_remove(&comms_player_choices, 0);		free(pc);	}	vector_init(&comms_player_choices, COMMS_PLAYER_CHOICE_COUNT);	vector_fill(&comms_player_choices, NULL);	Comms_PlayerChoice *pc;	pc = malloc(sizeof(Comms_PlayerChoice));	pc->text0 = "attack";	pc->choice0 = COMMS_NPC_DEFEND;	pc->text1 = "trade";	pc->choice1 = COMMS_NPC_TRADE;	pc->text2 = "talk";	pc->choice2 = COMMS_NPC_INFO;	pc->text3 = "disengage";	pc->choice3 = COMMS_NPC_FAREWELL;	vector_set(&comms_player_choices, COMMS_PLAYER_CHOICE_MAIN, pc);	pc = malloc(sizeof(Comms_PlayerChoice));	pc->text0 = "aggree";	pc->choice0 = COMMS_NPC_TRADE_ACCEPT_BUY; //TODO: This doesn't account for buy/sell separation	pc->text1 = "decline";	pc->choice1 = COMMS_NPC_TRADE_DECLINE;	pc->text2 = NULL;	pc->choice2 = -1;	pc->text3 = NULL;	pc->choice3 = -1;	vector_set(&comms_player_choices, COMMS_PLAYER_CHOICE_TRADE_INVITE, pc);	pc = malloc(sizeof(Comms_PlayerChoice));	pc->text0 = "buy";	pc->choice0 = COMMS_NPC_TRADE_ACCEPT_BUY;	pc->text1 = "sell";	pc->choice1 = COMMS_NPC_TRADE_ACCEPT_SELL;	pc->text2 = "back";	pc->choice2 = COMMS_PLAYER_CHOICE_MAIN;	pc->text3 = NULL;	pc->choice3 = -1;	vector_set(&comms_player_choices, COMMS_PLAYER_CHOICE_TRADE, pc);	pc = malloc(sizeof(Comms_PlayerChoice));	pc->text0 = "attack";	pc->choice0 = COMMS_NPC_ATTACK_ACCEPT;	pc->text1 = "flee";	pc->choice1 = COMMS_NPC_ATTACK_FLEE;	pc->text2 = "plead";	pc->choice2 = COMMS_NPC_ATTACK_PLEAD;	pc->text3 = NULL;	pc->choice3 = -1;	vector_set(&comms_player_choices, COMMS_PLAYER_CHOICE_DEFEND, pc);}

static void ecl_sum_data_build_index( ecl_sum_data_type * sum_data ) {  /* Clear the existing index (if any): */  ecl_sum_data_clear_index( sum_data );    /*    Sort the internal storage vector after sim_time.   */  vector_sort( sum_data->data , cmp_ministep );    /* Identify various global first and last values.  */  {    const ecl_sum_tstep_type * first_ministep = ecl_sum_data_iget_ministep( sum_data , 0 );    sum_data->first_ministep = ecl_sum_tstep_get_ministep( first_ministep );    /*        In most cases the days_start and data_start_time will agree       with the global simulation start; however in the case where we       have loaded a summary case from a restarted simulation where       the case we have restarted from is not available - then there       will be a difference.    */    sum_data->days_start      = ecl_sum_tstep_get_sim_days( first_ministep );    sum_data->data_start_time = ecl_sum_tstep_get_sim_time( first_ministep );  }  ecl_sum_data_update_end_info( sum_data );    /* Build up the report -> ministep mapping. */  {    int internal_index;    for (internal_index = 0; internal_index < vector_get_size( sum_data->data ); internal_index++) {      const ecl_sum_tstep_type * ministep = ecl_sum_data_iget_ministep( sum_data , internal_index  );      int report_step = ecl_sum_tstep_get_report(ministep);                /* Indexing internal_index - report_step */        {          int current_first_index = int_vector_safe_iget( sum_data->report_first_index , report_step );          if (current_first_index < 0) /* i.e. currently not set. */            int_vector_iset( sum_data->report_first_index , report_step , internal_index);          else            if (internal_index  < current_first_index)              int_vector_iset( sum_data->report_first_index , report_step , internal_index);        }                {          int current_last_index =  int_vector_safe_iget( sum_data->report_last_index , report_step );          if (current_last_index < 0)            int_vector_iset( sum_data->report_last_index , report_step ,  internal_index);          else            if (internal_index > current_last_index)              int_vector_iset( sum_data->report_last_index , report_step , internal_index);        }                sum_data->first_report_step = util_int_min( sum_data->first_report_step , report_step );        sum_data->last_report_step  = util_int_max( sum_data->last_report_step  , report_step );    }  }  sum_data->index_valid = true;}

static void obs_vector_resize(obs_vector_type * vector , int new_size) {  int current_size = vector_get_size( vector->nodes );  int i;    for (i=current_size; i < new_size; i++)     vector_append_ref( vector->nodes , NULL);  }

static void sched_block_fprintf(const sched_block_type * block, FILE * stream){  int i;  for (i=0; i < vector_get_size(block->kw_list); i++) {    const sched_kw_type * sched_kw = vector_iget_const( block->kw_list , i);    sched_kw_fprintf(sched_kw, stream);  }}

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

static bool file_map_has_kw_ptr( const file_map_type * file_map, const ecl_kw_type * ecl_kw) {  int index;  for (index = 0; index < vector_get_size( file_map->kw_list ); index++) {    const ecl_file_kw_type * file_kw = vector_iget_const( file_map->kw_list , index );    if (ecl_file_kw_ptr_eq( file_kw , ecl_kw ))      return true;  }   return false;} 

bool local_updatestep_has_data_key( const local_updatestep_type * update_step , const char * key) {    bool has_key = false;    for (int i = 0; i < vector_get_size( update_step->ministep ); i++) {        const local_ministep_type * ministep = vector_iget_const( update_step->ministep , i );        if (local_ministep_has_data_key(ministep, key))            has_key = true;    }    return has_key;}

int nnc_info_get_total_size( const nnc_info_type * nnc_info ) {  int num_nnc = 0;  int ivec;  for (ivec = 0; ivec < vector_get_size( nnc_info->lgr_list ); ivec++) {    const nnc_vector_type * nnc_vector = vector_iget( nnc_info->lgr_list , ivec );    num_nnc += nnc_vector_get_size( nnc_vector );  }  return num_nnc;}

static int ecl_sum_data_get_index_from_sim_time( const ecl_sum_data_type * data , time_t sim_time) {  time_t data_start_time = data->data_start_time;    if ((sim_time < data_start_time) || (sim_time > data->sim_end)) {    fprintf(stderr , "Simulation start: "); util_fprintf_date( ecl_smspec_get_start_time( data->smspec ) , stderr );    fprintf(stderr , "Data start......: "); util_fprintf_date( data_start_time , stderr );    fprintf(stderr , "Simulation end .: "); util_fprintf_date( data->sim_end , stderr );    fprintf(stderr , "Requested date .: "); util_fprintf_date( sim_time , stderr );    util_abort("%s: invalid time_t instance:%d  interval:  [%d,%d]/n",__func__, sim_time , data_start_time , data->sim_end);  }    /*      The moment we have passed the intial test we MUST find a valid     ministep index, however care should be taken that there can     perfectly well be 'holes' in the time domain, because of e.g. the     RPTONLY keyword.  */  {    int  low_index      = 0;    int  high_index     = vector_get_size( data->data );    int  internal_index = -1;        while (internal_index < 0) {      if (low_index == high_index)        internal_index = low_index;      else {        int center_index = 0.5*( low_index + high_index );        const ecl_sum_tstep_type * ministep = ecl_sum_data_iget_ministep( data , center_index );                if ((high_index - low_index) == 1) {          /* Degenerate special case. */          if (sim_time < ecl_sum_tstep_get_sim_time( ministep ))            internal_index = low_index;          else            internal_index = high_index;        } else {          if (sim_time > ecl_sum_tstep_get_sim_time( ministep ))    /*     Low-----Center---X---High */            low_index = center_index;          else {            time_t prev_time = data_start_time;            if (center_index > 0) {              const ecl_sum_tstep_type * prev_step = ecl_sum_data_iget_ministep( data , center_index - 1  );              prev_time = ecl_sum_tstep_get_sim_time( prev_step );            }                        if (prev_time < sim_time)              internal_index = center_index; /* Found it */            else              high_index = center_index;          }        }      }    }    return internal_index;  }}

const char * subst_list_iget_doc_string( const subst_list_type * subst_list , int index) {  if (index < vector_get_size(subst_list->string_data)) {    const subst_list_string_type * node = vector_iget_const( subst_list->string_data , index );    return node->doc_string;  } else {    util_abort("%s: index:%d to large /n",__func__ , index);    return NULL;  }}

void output_save_plain__( const output_type * output , ensemble_type * ensemble , const double ** data , bool add_header) {  FILE * stream = util_mkdir_fopen( output->file , "w");  const char * key_fmt      = " %18s:%4.2f ";  const char * time_header  = "--    DAYS      DATE    ";  const char * time_dash    = "------------------------";  const char * key_dash     = "-------------------------";  const char * float_fmt    = "%24.5f ";  const char * days_fmt     = "%10.2f ";  const char * date_fmt     = "  %02d/%02d/%04d ";  const int    data_columns = vector_get_size( output->keys );  const int    data_rows    = time_t_vector_size( ensemble->interp_time );  int row_nr,column_nr;  if (add_header) {    fprintf( stream ,time_header);    for (int i=0; i < vector_get_size( output->keys ); i++) {      const quant_key_type * qkey = vector_iget( output->keys , i );      fprintf( stream , key_fmt , qkey->sum_key , qkey->quantile );    }    fprintf(stream , "/n");    fprintf( stream , time_dash );    for (int i=0; i < vector_get_size( output->keys ); i++)      fprintf(stream , key_dash );    fprintf(stream , "/n");  }  /*4: Writing the actual data. */  for (row_nr = 0; row_nr < data_rows; row_nr++) {    time_t interp_time = time_t_vector_iget( ensemble->interp_time , row_nr);    fprintf(stream , days_fmt , 1.0*(interp_time - ensemble->start_time) / 86400);    {      int mday,month,year;      util_set_datetime_values(interp_time , NULL , NULL , NULL , &mday , &month , &year);      fprintf(stream , date_fmt , mday , month , year);    }    for (column_nr = 0; column_nr < data_columns; column_nr++) {      fprintf(stream , float_fmt , data[row_nr][column_nr]);    }    fprintf( stream , "/n");  }}

void plot_update_range(plot_type * plot, plot_range_type * range) {  if (plot->is_histogram)     plot_dataset_update_range_histogram( vector_iget(plot->dataset , 0) , range);  else {    bool first_pass = true;    int iplot;    for (iplot = 0; iplot < vector_get_size( plot->dataset  ); iplot++)       plot_dataset_update_range(vector_iget(plot->dataset , iplot) , &first_pass , range);  }}

static void file_map_fprintf_kw_list(const file_map_type * file_map , FILE * stream) {  int i;  for (i=0; i < vector_get_size( file_map->kw_list ); i++) {    const ecl_file_kw_type * file_kw = vector_iget_const( file_map->kw_list , i );    fprintf(stream , "%-8s %7d:%s/n",            ecl_file_kw_get_header( file_kw ) ,             ecl_file_kw_get_size( file_kw ) ,             ecl_util_get_type_name( ecl_file_kw_get_type( file_kw )));  }}