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

void vecDiff(const deque<unsigned int>& first, const deque<unsigned int>& second, deque<unsigned int>& result){
  result.clear();
  /* Assumption: the first argument is larger than the second one */
  int carry = 0;
  bool finished = false;
  deque<unsigned int>::const_reverse_iterator secondItr = second.rbegin(), secondItrEnd = second.rend();
  for (deque<unsigned int>::const_reverse_iterator itr = first.rbegin(), endItr = first.rend(); itr != endItr; itr++){
    int sec  = 0;
    if(secondItr != secondItrEnd){
      sec = *secondItr;
      secondItr++;
    }
    int sub =  carry + sec;
    if (*itr >= sub){
      result.push_front(*itr - sub);
      carry = 0;
    }
    else {
      result.push_front(*itr + 10 - sub);
      carry = 1;
    }
  }

  while (!result.empty() && result.front() == 0)
    result.pop_front();

  if (result.empty())
    result.push_back(0);
}

        void add(T evnt) override {

		if(data.empty()) {
			data.push_back(evnt);
		}
		else {

			//try to add it at the end
			auto riter = data.rbegin();
			auto iter = data.begin();

			if(evnt >= (*riter)) {
				//aka, the event being added is further off than the
				//oldest event currently in the queue.
				data.push_back(evnt);
			}
			else if (evnt <= (*iter)) {
				//aka, the event being added is younger than the next event in the queue.
				data.push_front(evnt);
			}
			else {
				//gutted. Now have to find the place for it to go.
				iter = upper_bound(data.begin(), data.end(), evnt);
				data.insert(iter, evnt);
			}

		}

        }

void set_last_items_to(deque<bool> &list, uint32_t nb_elts, bool value)
{
	uint32_t count = 0;
	deque<bool>::reverse_iterator it = list.rbegin();
	deque<bool>::reverse_iterator it_end = list.rend();
	for (; count < nb_elts && it != it_end; it++, count++)
		*it = value;
}

 void detectCamera_T(double time){
     for(deque<TimedT, Eigen::aligned_allocator<TimedT> >::reverse_iterator it = timedTbuf.rbegin();
         it != timedTbuf.rend(); it++){
         if(time >= it->time){
             camera_T = it->T;
             return;;
         }
     }
     camera_T = timedTbuf.front().T;
 }

    n_t regular()
    {
        n_t res = 0;
        n_t position = 0;

        deque<d_t>::reverse_iterator rit;
        for(rit = number.rbegin(); rit != number.rend(); rit++)
            res += (*rit) * pow_int(base, position++);

        return(res);

    }

int dqtoi(deque<int>& dnum)
{
    int place = 1;
    int num = 0;
    
    for(deque<int>::reverse_iterator rit = dnum.rbegin();
        rit != dnum.rend(); ++rit, place *= 10)
    {
        num += (*rit * place);
    }
    
    return num;
}

void vecSum (deque<unsigned int>& number , unsigned int summand){
  if (number.empty())
    number.push_back(0);
  unsigned int carry = summand;
  for (deque<unsigned int>::reverse_iterator itr = number.rbegin(), endItr = number.rend(); carry > 0 && itr != endItr; itr++){
    int sum = *itr + carry;
    *itr = sum % 10;
    carry = sum / 10;
  }

  while (carry > 0){
    number.push_front(carry%10);
    carry /= 10;
  }
}

void add(deque<char> &a,deque<char> &b)
{
  char c = 0;
  char t = 0;
  int i;
  if (a.size() < b.size())
    swap(a,b);
  deque<char>::reverse_iterator ai = a.rbegin();
  deque<char>::reverse_iterator bi = b.rbegin();
  for (;bi != b.rend(); ++bi,++ai)
  {
    t = *ai + *bi +c;
    *ai = t%10;
    c = t/10;
  }
  for (;ai != a.rend(); ++ai)
  {
    t = *ai + c;
    *ai = t%10;
    c = t/10;
  }
  if ( c != 0 )
    a.push_front(c);
}

void Query::invokeErrorHandlers(deque<shared_ptr<ErrorHandler> >& errorHandlers)
{
    for (deque<shared_ptr<ErrorHandler> >::reverse_iterator riter = errorHandlers.rbegin();
         riter != errorHandlers.rend(); riter++) {
        shared_ptr<ErrorHandler>& eh = *riter;
        try {
            eh->handleError(shared_from_this());
        } catch (const std::exception& e) {
            LOG4CXX_FATAL(_logger, "Query (" << _queryID
                          << ") error handler failed:"
                          << e.what()
                          << "Aborting!");
            abort();
        }
    }
}

void Query::invokeFinalizers(deque<Finalizer>& finalizers)
{
   assert(finalizers.empty() || checkFinalState());
   for (deque<Finalizer>::reverse_iterator riter = finalizers.rbegin();
        riter != finalizers.rend(); riter++) {
      Finalizer& fin = *riter;
      if (!fin) {
         continue;
      }
      try {
         fin(shared_from_this());
      } catch (const std::exception& e) {
         LOG4CXX_FATAL(_logger, "Query (" << _queryID
                       << ") finalizer failed:"
                       << e.what()
                       << "Aborting!");
         abort();
      }
   }
}

			void reverse(deque<int> &que){
				for(rpos=que.rbegin();rpos!=que.rend();rpos++)
					cout<<*rpos<<" ";
				cout<<endl;
			}