C++ deque::insert方法代码示例

	void next(std::deque<std::deque<match_t *> > *last_round, std::deque<player_t *> &tournament_players) {
		int half = tournament_players.size()/2;

		/** "Rotates clockwise" */
		tournament_players.insert(tournament_players.begin() + 1, tournament_players[half]);
		tournament_players.erase(tournament_players.begin() + half + 1);
		tournament_players.insert(tournament_players.end(), tournament_players[half]);
		tournament_players.erase(tournament_players.begin() + half);
	}

BOOL CWizKMDatabaseServer::document_downloadFullListEx(const CWizStdStringArray& arrayDocumentGUID, std::deque<WIZDOCUMENTDATAEX>& arrayRet)
{
    int nCountPerPage = 30;
    //
    CWizStdStringArray::const_iterator it = arrayDocumentGUID.begin();
    //
    while (1)
    {
        //
        CWizStdStringArray subArray;
        //
        for (;
            it != arrayDocumentGUID.end(); )
        {
            subArray.push_back(*it);
            it++;
            //
            if (subArray.size() == nCountPerPage)
                break;
        }
        //
        std::deque<WIZDOCUMENTDATAEX> subRet;
        if (!document_downloadFullList(subArray, subRet))
            return FALSE;
        //
        arrayRet.insert(arrayRet.end(), subRet.begin(), subRet.end());
        //
        if (it == arrayDocumentGUID.end())
            break;
    }
    //
    return TRUE;
}

void Color3DTree::Node::insertSorted(std::deque<Neighbour>& nearestNeighbours, const Neighbour& neighbour, unsigned int maxneighbours) const
{
  std::deque<Neighbour>::iterator it = nearestNeighbours.begin();
  const std::deque<Neighbour>::iterator end = it + maxneighbours;
  ASSERT(end == nearestNeighbours.end());
  int distance = neighbour.getDistance();
  for(; it < end; it++)
    if(it->getDistance() > distance)
    {
      nearestNeighbours.insert(it, neighbour);
      nearestNeighbours.pop_back();
      break;
    }
}

    std::vector<T> filter(const std::vector<T> & in)
    {
        assert(in.size() > 0);

        //---------------------------------------------------------------------
        // init state

        unsigned hist_ptr = 0;

        std::fill(_history.begin(), _history.end(), in[0]);
        std::fill(_pool.begin(), _pool.end(), in[0]);

        // pool is keep sorted

        //---------------------------------------------------------------------
        // filter input

        std::vector<T> out;
        out.reserve(in.size());

        for(auto x : in)
        {
            // step 1, remove oldest value from the pool.

            auto last = _history[hist_ptr];

            auto last_pos = std::lower_bound(_pool.begin(), _pool.end(), last);

            _pool.erase(last_pos);

            // step 2, insert new value into pool

            auto insert_pos = std::lower_bound(_pool.begin(), _pool.end(), x);

            _pool.insert(insert_pos, x);

            // step 3, write input value into history.

            _history[hist_ptr] = x;

            hist_ptr = (hist_ptr + 1) % _history.size();

            // median is always the middle of the pool

            out.push_back(*(_pool.begin() +_median));
        }

        return out;
    }

void densifyWaypoints(){
	if(waypointMaxDistance>0){
		std::cout << "densifying waypoints" << std::endl;
		int count=0;
		current_path.push_front(startState);
		for(int i=0;i<current_path.size()-1;++i){
			if((current_path[i]-current_path[i+1]).norm()>waypointMaxDistance){
				count++;
				current_path.insert(current_path.begin()+i+1,current_path[i]+(current_path[i+1]-current_path[i])*(waypointMaxDistance/((current_path[i+1]-current_path[i]).norm())));
			}
		}
		current_path.pop_front();
		std::cout << count << " points added" << std::endl;
	}
}

void
test(int P, std::deque<int>& c1, int x)
{
    typedef std::deque<int> C;
    typedef C::iterator I;
    typedef C::const_iterator CI;
    std::size_t c1_osize = c1.size();
    CI i = c1.insert(c1.begin() + P, x);
    assert(i == c1.begin() + P);
    assert(c1.size() == c1_osize + 1);
    assert(distance(c1.begin(), c1.end()) == c1.size());
    i = c1.begin();
    for (int j = 0; j < P; ++j, ++i)
        assert(*i == j);
    assert(*i == x);
    ++i;
    for (int j = P; j < c1_osize; ++j, ++i)
        assert(*i == j);
}

void
test(int P, std::deque<int>& c1, const std::deque<int>& c2)
{
    typedef std::deque<int> C;
    typedef C::iterator I;
    typedef C::const_iterator CI;
    typedef bidirectional_iterator<CI> BCI;
    std::size_t c1_osize = c1.size();
    CI i = c1.insert(c1.begin() + P, BCI(c2.begin()), BCI(c2.end()));
    assert(i == c1.begin() + P);
    assert(c1.size() == c1_osize + c2.size());
    assert(distance(c1.begin(), c1.end()) == c1.size());
    i = c1.begin();
    for (int j = 0; j < P; ++j, ++i)
        assert(*i == j);
    for (int j = 0; j < c2.size(); ++j, ++i)
        assert(*i == j);
    for (int j = P; j < c1_osize; ++j, ++i)
        assert(*i == j);
}

	bool sortMembers(const DependencyIdMap& depMap, std::deque<DependencyId>& members) {
		//organize members dependencies
		const std::size_t membersSize = members.size();
		if (membersSize>1) {
			//bool sorting = true;
			std::size_t index = 0;
			std::size_t moveCounter = 0;
			while(index < membersSize) {
				bool moved = false;
				DependencyId currId = members[index];
				if (depMap.count(currId)>0) {
					//have dependencies
					const DependencyIdSet& deps = depMap.at(currId);
					int lastDep = getIndexOfLastDependency(members, deps);
					if (lastDep > index) {
						//move
						std::deque<DependencyId>::iterator indexIter = members.begin() + index;
						members.erase(indexIter);
						std::deque<DependencyId>::iterator lastDepIter = members.begin() + lastDep;
						members.insert(lastDepIter, currId);
						moved = true;
						moveCounter++;
					}
				}
				if (moved==false) {
					index++;
					moveCounter = 0;
				} else {
					std::size_t rest = membersSize - index;
					if (moveCounter>=rest) {
						//cycle detected - break
						return false;
					}
				}
			}
		}
		return true;
	}

void
    test_insert_range(
        std::deque<int> &std_deque
      , SeqContainer &seq_container
      , std::deque<int> const& input_deque
      , std::size_t index
    )
{
    BOOST_TEST(CheckEqualContainers(&std_deque, &seq_container));

    std_deque.insert(
        std_deque.begin() + index
      , input_deque.begin()
      , input_deque.end()
    );

    seq_container.insert(
        seq_container.begin() + index
      , input_deque.begin()
      , input_deque.end()
    );
    BOOST_TEST(CheckEqualContainers(&std_deque, &seq_container));
}

void calculate() {
	size_t min = SIZE_MAX;
	size_t cnt = 0;

	g_list.clear();

	std::vector<size_t> mullist;

	for(i = 0; i < g_num + 1; ++i) {
		g_list.push_back(g_num_arr[i]);
	}//for

	function<void(size_t, size_t &)> cal = [&](size_t id, size_t & min) {
		showdbg("id: %lu listsz: %lu\n", id, g_list.size());
		showdbg("list: ");
		for(auto ii : g_list)
			showdbg("%lu ", ii);
		showdbg("\n");


		if(g_list.size() == 2) {
			showdbg("fin: cnt=%lu\n", cnt);
			if(min > cnt) {
				min = cnt;
				showdbg("update min!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");

				showdbg("mullist: ");
				for(auto ii : mullist)
					showdbg("%lu ", ii);
				showdbg("\n");
			}//if
			showdbg("\n");

			return;
		}//if
		
		if(id + 2 == g_list.size())
			return;

		auto erased = g_list[id + 1];
		auto cnt_resv = cnt;

		mullist.push_back(g_list[id + 1]);
		cnt += g_list[id] * g_list[id + 1] * g_list[id + 2];
		showdbg("cnt += %lu*%lu*%lu = %lu\n", g_list[id], g_list[id+1], g_list[id+2], cnt);

		g_list.erase(g_list.begin() + id + 1);

		for(auto newid = 0; (newid + 2) <= g_list.size(); ++newid) {
			cal(newid, min);
		}//for
		mullist.pop_back();
		g_list.insert(g_list.begin() + id + 1, erased);
		cnt = cnt_resv;
	};

	for(auto newid = 0; newid < g_list.size() - 1; ++newid) {
		cal(newid, min);
	}//for

	g_result = min;
}//calculate()

void bad_insert_deque1(std::deque<int> &D, int n) {
  auto i1 = D.cbegin(), i0 = i1++;
  D.insert(i1, n);
  *i0; // expected-warning{{Invalidated iterator accessed}}
  *i1; // expected-warning{{Invalidated iterator accessed}}
}

 //vector<int> d_;
 // Adds a number into the data structure.
 void addNum(int num)
 {
     auto it = lower_bound(d_.begin(), d_.end(), num);
     d_.insert(it, num);
 }