C++ container::size方法代码示例

	void reserve(size_type n) {
		if (size_ == 0) {
			elements.resize(n, std::make_pair(res_empty, V()));
			return;
		}

		static container vals;
		vals.resize(0);
		vals.reserve(size_);
		for (size_type i = 0, ie = capacity(); i < ie; ++i) {
			if (elements[i].first != res_empty && elements[i].first != res_del) {
				vals.push_back(elements[i]);
			}
		}

		clear(n);
		size_ = vals.size();
		size_t max = capacity() - 1;
		for (size_type i = 0, ie = vals.size(); i < ie; ++i) {
			size_t spot = hash_value(vals[i].first) & max;
			while (elements[spot].first != res_empty && elements[spot].first != vals[i].first) {
				spot = (spot + 5) & max;
			}
			elements[spot] = vals[i];
		}
	}

int global_gene_init()
{
    //gene init
    int op_total=g_gene_cell_meta_pool.size();
    vector< vector<gene_cell_meta_t> > gene_cell_meta_vv;
    vector< gene_cell_meta_t> dest;
    LOG_DEBUG<<"op_total:"<<op_total<<std::endl;
    for(int i=0;i<op_total;i++) {
        gene_cell_meta_t *pgene_cell_meta=g_gene_cell_meta_pool.get(i);
        if(pgene_cell_meta) {
            vector<gene_cell_meta_t> gene_cell_meta_v;
            gene_cell_meta_v.clear();
            gene_cell_meta_t gene_cell_meta;
            gene_cell_data_t gene_cell_data;
            gene_cell_data_t *pgene_cell_data;

            pgene_cell_data=g_gene_cell_data_pool.get(pgene_cell_meta->did);

            for(int j=0;j<pgene_cell_meta->cn;j++) {
                memcpy(&gene_cell_meta, pgene_cell_meta, sizeof(gene_cell_meta_t));
                memcpy(&gene_cell_data, pgene_cell_data, sizeof(gene_cell_data_t));
                gene_cell_data.cn=j;
                int data_idx=g_gene_cell_data_pool.put(gene_cell_data);
                gene_cell_meta.did=data_idx;
                gene_cell_meta_v.push_back(gene_cell_meta);
                int meta_idx=g_gene_cell_meta_pool.put(gene_cell_meta);
            }
            LOG_DEBUG<<"gene_cell_meta_v.size: "<<gene_cell_meta_v.size()<<std::endl;
            gene_cell_meta_vv.push_back(gene_cell_meta_v);
        }
        LOG_DEBUG<<"gene_cell_meta_vv.size: "<<gene_cell_meta_vv.size()<<std::endl;
    }

    /*gene gene_pool
     * */

    //gene all the genome
    if(gene_cell_meta_vv.size() < 6) {
        gene_generate(gene_cell_meta_vv.begin() , gene_cell_meta_vv.end(),
                        dest, g_gene_meta_pool);
        LOG_DEBUG<<"g_gene_meta_pool.size:"<<g_gene_meta_pool.size()<<std::endl;
    }else if(gene_cell_meta_vv.size() > 10) {
        /*
        gene small
        gene half
        gene full
        */
    }else {
        /*
        gene small
        gene full
        */
    }
    return 0;
}

long long int findSmallestScalarProduct(container x, container y)
{
    long long int zero = 0;

    if(x.size() != y.size())
    {
        std::cout << "Containers Are Not Same Length!\n";
        throw -1;
    }

    ascend_sort(x.begin(),x.end());
    descend_sort(y.begin(),y.end());

    return std::inner_product(x.begin(),x.end(),y.begin(),zero);
}

void container::copy(size_t i, container const &other, size_t l, size_t r)
{
    if (r <= l)
        throw std::invalid_argument(
                "big_integer: container: in function copy(): left bound is larger than the right one"
        );

    if (r - l == 1 && sz == 0) {
        sz = 1;
        data_short = *(other.data_long->begin() + l);
        return;
    }

    if (sz == 1)
        data_long = std::make_shared< std::vector<uint32_t> > (1, data_short);
    else
        real_copy();

    if (other.size() == 1)
        data_long->insert(data_long->begin() + i, other.data_short);
    else
        std::copy(other.data_long->begin() + l,
                  other.data_long->begin() + r,
                  this->data_long->begin() + i
        );

    sz = data_long->size();
}

		inline void push_front(const container<T>& aOther) {
			if (&aOther == this) throw std::runtime_error("P12218319::deque::push_front : Cannot push self");
			const uint32_t s = size();
			reserve(s + aOther.size());
			single_for<const container<T>&>(aOther, 0, s, [this](const T& aValue)->void {
				push_front(aValue);
			});
		}

	BigData getRightPart(){
		char halfSize = data.size() / 2;

		container buffer;
		for (char i = 0; i < halfSize; i++)
			buffer.push_back(data[i]);

		return BigData(buffer);
	}

 matrix(size_type N, size_type M, container<T> vector)
 : vec(N * M),
   rows(N),
   columns(M)
 {
     if (vector.size() == N * M) {
         std::copy(vector.begin(), vector.end(), vec.begin());
     }
 }

template <template <class> class container, class T> void print(container<T>& vec)
{
  printf("vector - size(%u) capacity(%u)\n", vec.size(), vec.capacity());

  for (auto it = vec.begin(); it != vec.end(); ++it)
    print(*it);
  
  //test const version
  printf("test const version\n");
  const container<T>& const_vec = vec;
  for (auto it : vec)
    print(it);
}

int global_genome_init()
{
    int size=g_gene_meta_pool.size();
    int cell_num;
    int gene_num;
    genome_meta_t *pgenome_meta=g_genome_meta_pool.get(-1);

    cell_num=sizeof(g_gene_chaos)/sizeof(g_gene_chaos[0]);
    gene_num=g_gene_meta_pool.size();

    pgenome_meta->cell_num=cell_num;
    pgenome_meta->gene_num=gene_num;

    for(int i=0;i<g_gene_meta_pool.total;i++) {
        gene_meta_t *pgene_meta=g_gene_meta_pool.get(i);
        if(pgene_meta) {
                        pgene_meta->gene_cells[i]=i;
                        pgene_meta->cell_cases[i];
/*
typedef struct genome_meta{
    uint8_t  *gene_cell_feas;
    uint8_t   gene_cells[10];
    uint16_t  cell_num;
    uint16_t  gene_num;
} genome_meta_t;

typedef struct gene_meta{
    uint8_t gene_cells[10];
    uint8_t cell_cases[10];
    uint8_t cnums;
    gene_action action;    
}gene_meta_t;

*/
        }
    }
    return 0;
}

	BigData getLeftPart(){
		char halfSize = data.size() / 2;
		
		container buffer;

		container test = data;
		
		while (test.size() > 1 && test[test.size() - 1] == 0) {
			test.pop_back();
		}

		if (test.size() > 1) {
			for (char i = 0; i < halfSize; i++)
				buffer.push_back(data[i + halfSize]);
		}

		if (!buffer.size())
			buffer.push_back(0);

		return BigData(buffer);
	}

double median(container l) {
    typedef container::size_type l_sz;
	
	l_sz size = l.size();
	if (size == 0)
		throw std::domain_error("median of an empty list");
	
	l.sort();

    std::size_t mid = size / 2;
    const_iter it = l.begin();
    
    for(std::size_t i = 0; i != mid; ++i) {
        ++it;
    }
    
    if (size % 2 == 0) {
        const_iter base = it--;
        return (*base + *it) / 2;
    }
    else {
        return *it;
    }
}