C++ stack::emplace方法代码示例

void EvalStack::exec(char chr) {
  AttributeValue a, b, c;
  switch (chr) {
  case '+':
  case '-':
  case '*':
  case '/':
  case '>':
  case '<':
  case funcMin:
  case funcMax:
  case funcTable:
    if (vals.size() < 2) return;
    b = vals.top(); vals.pop();
    a = vals.top(); vals.pop();
    vals.push(binop(a, b, chr));
    break;
  case '~':
    if (vals.size() < 1) return;
    if (vals.top().text.empty()) {
      a = vals.top(); vals.pop();
      vals.emplace(-a.max, -a.min);
    }
    break;
  case ':':
    if (vals.size() < 3) return;
    c = vals.top(); vals.pop();
    b = vals.top(); vals.pop();
    a = vals.top(); vals.pop();
    vals.push(a.max ? b : c);
    break;
  }
}

	void emplace(Args&&... args)
	{
		bool empty_ = empty();
		internal.emplace(std::forward<Args>(args)...);
		if (empty_)
			not_empty.notify_all();
	}

int main(int argc, char* argv[])
{
  for (int i = 10; i > 0; --i) {
    A.emplace(i);
  }
  Dump("init", 0);

  HanoiTowerMoveN(A.size(), A, B, C);

  return 0;
}

// TraialPool::get_traials() specialization for STL std::stack<>
template<> void
TraialPool::get_traials(std::stack< Reference<Traial> >& stack,
						unsigned numTraials)
{
	assert(0u < numTraials);
	numTraials++;  // loop guard condition requires this increment
	retrieve_traials:
	while (!available_traials_.empty() && 0u < --numTraials) {
		stack.emplace(available_traials_.front());
		available_traials_.pop_front();
	}
	if (0u < numTraials) {
		ensure_resources(std::max<unsigned>(numTraials++, sizeChunkIncrement));
		goto retrieve_traials;
	}
}

void HanoiTowerMoveN(int n, std::stack<int>& from, std::stack<int>& to, std::stack<int>& tmp)
{
  assert(n >= 1);
  if (n  == 1) {
    if (to.empty() || to.top() > from.top()) {
      to.emplace(from.top());
      from.pop();
    }
  }
  else {
    HanoiTowerMoveN(n - 1, from, tmp, to);
    Dump("(a)", n - 1);
    HanoiTowerMoveN(1, from, to, tmp);
    Dump("(b)", 1);
    HanoiTowerMoveN(n - 1, tmp, to, from);
    Dump("(c)", n - 1);
  }
}

 void emplace(Args&&... args) {
   return q.emplace(std::forward<Args>(args)...);
 }

void RecreatorImpl::push(const std::string &operand)
{
    stack.emplace(operand, Precedence::Operand);
}

 void setboard(std::string fen) {
   // not sure about when setboard will be called. assuming after "new"
   // and before anything that modifies the state.
   history = std::stack<State>();
   history.emplace(fen);
 }

 Game() {
   history = std::stack<State>();
   history.emplace();
 }

 bool Key(const char* str, SizeType length, bool copy)
 {
     stack.emplace(stack.top()->key({str, (size_t)length}));
     return true;
 }

 inline void setCategory(Category& mCategory)
 {
     lastCategories.emplace(&mCategory);
     category = &mCategory;
 }

void algorithms::KDDecomposer<IROBOT>::DecomposeSubspaces(std::stack<int>& stack, double large_radius, double min_radius, std::unordered_map<int, double>& impt_map)
{
    while (!stack.empty())
    {
        int node_index = stack.top();
        stack.pop();
        
        double cell_radius = radius_array[get_node(node_index).depth()];
        // 3R Arm:
        //double local_min_radius = std::min( large_radius/2.0, std::max(min_radius, large_radius/(impt_map[node_index]*10)));
        // 4R Arm:
        double local_min_radius = std::min( large_radius/2.0, std::max(min_radius, large_radius/(impt_map[node_index])));
        
        robot_.set_config(get_node(node_index).center());
        double dist_to_obsts = obstacle_manager_.dist_to_obsts(robot_);
        if (dist_to_obsts > 0)
        {
            get_node(node_index).reset_info();
            // Create free space ball
            double initial_guess = CalcFreeCellRadius(dist_to_obsts);
            double radius = robot_.free_space_oracle(obstacle_manager_, initial_guess /* lower bound */, 2 * initial_guess /* upper bound */);
            if (robot_.subconvex_radius(obstacle_manager_, radius, cell_radius))
            {
                get_node(node_index).set_covered();
                get_node(node_index).set_free();
                if (!MERGE_CELLS)
                    get_node(node_index).set_cell(get_new_cell(get_node(node_index).center(), cell_radius, node_index));
            }
            else if( cell_radius > local_min_radius )
            {
                get_node(node_index).set_children( NOT_FOUND );
                SplitCell(node_index);
                for (int i = 0; i < NUM_SPLITS; ++i)
                {
                    impt_map[get_node(node_index).get_children()+i] = impt_map[node_index];
                    stack.emplace(get_node(node_index).get_children()+i);
                }
            }
        }
        else
        {
            get_node(node_index).reset_info();
            const double penetration = obstacle_manager_.penetration(robot_);
            if ( penetration / robot_.get_max_speed() >= (PENETRATION_CONSTANT / min_param_speed_) * cell_radius  )
            {
                continue;
            }
            else if (cell_radius > local_min_radius )
            {
                get_node(node_index).set_children( NOT_FOUND );
                SplitCell(node_index);
                for (int i = 0; i < NUM_SPLITS; ++i)
                {
                    impt_map[get_node(node_index).get_children() + i] = impt_map[node_index];
                    stack.emplace(get_node(node_index).get_children() + i);
                }

            }
        }
        
    }
}