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

 void compute(stack<int>& operands, stack<char>& operators) {
     const int left = operands.top();
     operands.pop();
     const int right = operands.top();
     operands.pop();
     const char op = operators.top();
     operators.pop();
     if (op == '+') {
         operands.emplace(left + right);
     } else if (op == '-') {
         operands.emplace(left - right);
     }
 } 

 void compute(stack<int>& operands, stack<string>& operators) {
     const int left = operands.top();
     operands.pop();
     const int right = operands.top();
     operands.pop();
     const string op = operators.top();
     operators.pop();
     if (op == "+") {
         operands.emplace(left + right);
     } else if (op == "-") {
         operands.emplace(left - right);
     } else if (op == "*") {
         operands.emplace(left * right);
     } else if (op == "/") {
         operands.emplace(left / right);
     }
 }

void DFS(GraphVertex* cur, stack<GraphVertex*> &vertex_order) {
  cur->visited = true;
  for (GraphVertex* &next : cur->edges) {
    if (next->visited == false) {
      DFS(next, vertex_order);
    }
  }
  vertex_order.emplace(cur);
}

static void
entry(const string &type)
{
#ifdef DEBUG
    types.push(type);
    recognition.emplace();
    if (unrecognized.count(type) == 0) {
        unrecognized[type] = set<string>();
    }
#endif
}

    void operator delete(void* pMem)
    {
        lock_guard<mutex> lock{ s_Mutex };

        const int index{
            (static_cast<MyManagedObject*>(pMem)-s_ManagedObjects.data()) /
            static_cast<intptr_t>(sizeof(MyManagedObject)) };
        if (0 <= index && index < static_cast<int>(s_ManagedObjects.size()))
        {
            s_FreeList.emplace(static_cast<unsigned int>(index));
        }
        else
        {
            free(pMem);
        }
    }

/// Produce \c element_count foos.
void produce(size_t element_count, size_t id_offset, stack& foos)
{
    size_t id = id_offset;

    {
        lock_guard<mutex> _(g_io_mutex);
        cout << this_thread::get_id() << " - produce from ID " << id << endl;
    }

    for (size_t i = 0; i < element_count; ++i) {
        foos.emplace(foo(id++));
    }

    {
        lock_guard<mutex> _(g_io_mutex);
        cout << this_thread::get_id() << " - produced to ID " << id << endl;
    }
}

void Node::expandNextNode(stack<Node>& fringe)
{
	auto x = get<0>(nextNodeMove);
	auto y = get<1>(nextNodeMove);

	// Has this function call already expanded a node.
	// We need to keep track of this so that we can increment nextNodeMove
	// until it points to the next valid move.
	auto expanded = false;

	for (/* y */; y < 3; ++y)
	{
		for (/* first init x as stored value, then 0 */ ; x < 3; ++x)
		{
			if (state->isFree(x, y))
			{
				if (!expanded)
				{
					// Add child state to the fringe
					auto newBoard = make_unique<GameBoard>(*state);
					auto newMove = make_unique<Move>(x, y);
					newBoard->makeMove(*newMove);
					fringe.emplace(Node{move(newBoard), this,
						move(newMove), depth > 0 ? depth - 1 : 0,
						alpha, beta, !maximizer});
					expanded = true; // Only expand once per function call
				}
				else
				{
					// Save the coordinates of the next free space
					nextNodeMove = decltype(nextNodeMove){ x, y };
					return;
				}
			}
		}
		x = 0; // On a new row, so reset x to 0
	}

	// No more nodes found, so indicate that with an invalid move
	nextNodeMove = decltype(nextNodeMove){ 3, 3 };
}

 void push(const T &x) {
   s.emplace(x, std::max(x, empty() ? x : s.top().second));
 }

 void push(int x) {
     int minVal = d_stack.empty() ? x : min(x, d_stack.top().second);
     d_stack.emplace(x, minVal);
 }