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

void wmsPopNotifyFlags()
{
   if(theNotifyFlagsStack.empty())
   {
      return;
   }
   theNotifyFlags = theNotifyFlagsStack.top();
   theNotifyFlagsStack.pop();
}

        int PopExpListValueCount()
        {
            if (exp_list_value_count_.empty())
                return 0;

            int result = exp_list_value_count_.top();
            exp_list_value_count_.pop();
            return result;
        }

void reset()
{
	while(!VIEWSTACK.empty()) {
		VIEWSTACK.pop();
	}

	WORLDVIEW = new ViewBox(W,H,0,0);
	VIEWSTACK.push(*WORLDVIEW);
}

container convertStackToContainer(std::stack<uint32_t>& stack) {
    container result;
    do {
        result.push_back(stack.top());
        stack.pop();
    } while(not stack.empty());
    std::reverse(result.begin(), result.end());
    return result;
}

bool CameraManager::update(float dt)
{
	static std::stack<int> precedingBehaviors;

	if ( dt == 0 ) return false;

	mTransScale = mTransSpeed  * dt;
	mRotScale   = mRotateSpeed * dt;

	ctx.mCurrTruck  = BeamFactory::getSingleton().getCurrentTruck();
	ctx.mDt         = dt;
	ctx.mRotScale   = Degree(mRotScale);
	ctx.mTransScale = mTransScale;
	ctx.fovInternal = Degree(FSETTING("FOV Internal", 75.0f));
	ctx.fovExternal = Degree(FSETTING("FOV External", 60.0f));

	if ( currentBehaviorID < CAMERA_BEHAVIOR_END && INPUTENGINE.getEventBoolValueBounce(EV_CAMERA_CHANGE) )
	{
		switchToNextBehavior(false);
	}

	if ( INPUTENGINE.getEventBoolValueBounce(EV_CAMERA_FREE_MODE_FIX) )
	{
		toggleBehavior(CAMERA_BEHAVIOR_FIXED);
	}

	if ( INPUTENGINE.getEventBoolValueBounce(EV_CAMERA_FREE_MODE) )
	{
		toggleBehavior(CAMERA_BEHAVIOR_FREE);
	}

	if ( !ctx.mCurrTruck && hasActiveVehicleBehavior() )
	{
		precedingBehaviors.push(currentBehaviorID);
		switchBehavior(CAMERA_BEHAVIOR_CHARACTER);
	} else if ( ctx.mCurrTruck && hasActiveCharacterBehavior() )
	{
		if ( !precedingBehaviors.empty() )
		{
			switchBehavior(precedingBehaviors.top(), false);
			precedingBehaviors.pop();
		} else
		{
			switchBehavior(CAMERA_BEHAVIOR_VEHICLE);
		}
	}

	if ( currentBehavior )
	{
		currentBehavior->update(ctx);
	} else
	{
		switchBehavior(CAMERA_BEHAVIOR_CHARACTER);
	}

	return true;
}

void glScissorPop()
{
	if(!scissorStack.empty())
	{
		Recti scissor = scissorStack.top();
		scissorStack.pop();
		glScissor(scissor.min[0], scissor.min[1], scissor.max[0] - scissor.min[0] + 1, scissor.max[1] - scissor.min[1] + 1);
	}
}

 void pop() {
     if (s.empty())  {
         return;
     }
     if (min.top() == s.top()) {
         min.pop();
     }
     s.pop();
 }

void PrintStack(std::stack<int> stackIn)
{
	while(!stackIn.empty())
	{
		std::cout << stackIn.top() << " ";
		stackIn.pop();
	}
	std::cout << "\n";
}

jmp_buf* catch_point()
{
  if ( catch_points.empty() ) {
    fprintf(stderr, "Fatal internal error: Exception stack underflow\n");
    exit(1);
  }

  return catch_points.top();
}

void printstack(std::stack<frac*> s )
{
	std::cout<<"stack:"<<std::endl;
	while(!s.empty())
	{
		s.top()->display();
		s.pop();
	}
}

// Note: empties the passed stack
std::vector<int> toIndexPath(std::stack<maze_point> path, int mazeSize) {
	std::vector<int> indexPath;
	indexPath.reserve(path.size());
	while (!path.empty()) {
		indexPath.push_back(path.top().position.getIndex(mazeSize));
		path.pop();
	}
	return indexPath;
}

void reverse_stack(std::stack<T>& st)
{
	if(!st.empty())
	{
		T top = st.top();
		st.pop();
		reverse_stack(st);
		add_to_stack_bottom(st, top);
	}
}

void ReverseStack(std::stack<int>& stack)
{
	if (!stack.empty() )
	{
		int top = stack.top();
		stack.pop();
		ReverseStack(stack);
		addtobottom(stack,top);
	}
}

 void pop()
 {
     if (elements.empty()) {
         return;
     }
     if (elements.top() == mins.top()) {
         mins.pop();
     }
     elements.pop();
 }

template<typename T> void Add_Bottom(std::stack<T>& stk, T val) {
  if(stk.empty())
    stk.push(val);
  else {
    T t = stk.top();
    stk.pop();
    Add_Bottom(stk, val);
    stk.push(t);
  }
}