自学教程：C++ updateStats函数代码示例

void ComputationManager::optimize(Computation &c) {    updateStats(c);        if (optUnsatCheckInterval.getValue() > 0) {        optUnsatCheckCounter++;        optUnsatCheckCounter %= optUnsatCheckInterval.getValue();        if (optUnsatCheckCounter == 0) {            RESULT result = decide(c);             if (result == RESULT::UNSAT) {                throw AbortException("Intermediate unsat check successful", RESULT::UNSAT);            }        }    }        if (optOptimizeInterval.getValue() > 0) {        optIntervalCounter++;        optIntervalCounter %= optOptimizeInterval.getValue();        if (optIntervalCounter == 0) {            while ((maxGlobalNSFSizeEstimation < optMaxGlobalNSFSize.getValue()) || (optMaxGlobalNSFSize.getValue() <= -1)) {                unsigned int oldLeavesCount = c.leavesCount();//    divideGlobalNSFSizeEstimation(c.leavesCount());                if (!(c.optimize(left))) {                    break;                }                left = !left;                divideGlobalNSFSizeEstimation(oldLeavesCount);                multiplyGlobalNSFSizeEstimation(c.leavesCount());            }        }    }    updateStats(c);}

void State_selectPart::KeyDown(const int &key, const int &unicode){    if (key == SDLK_ESCAPE)    {        resultRef = -1;        popMe = true;    }    else if (key == SDLK_DOWN)    {        int size = getInventorySize();        if (selector < size - 1)        {            selector++;            redraw();            updateStats();        }    }    else if (key == SDLK_UP)    {        int size = getInventorySize();        if (selector > 0)        {            selector--;            redraw();            updateStats();        }    }    else if (key == SDLK_RETURN)    {        resultRef = selector;        popMe = true;    }}

// ~Game()// Description: game ends, calculate & dump results to logGame::~Game(){    m_objCount--;    if(m_objCount == 0 && m_objInit){        m_endTime = cpuTime();        updateStats();        dumpLog("open_src_version.log");    }    else        updateStats();}

MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent){  setupUi(this);  setupActions();  mStatLabel = new QLabel;  statusBar()->addPermanentWidget(mStatLabel);  connect(textEdit, SIGNAL(textChanged()), this, SLOT(updateStats()));  updateStats();}

void FPSGraph::update(float dt){	time += dt;	++frames;	if (time > GUIFPS_MIN_TIME)	{		tpfLast = time / frames;		fpsLast = frames / time;		time = 0.0f;		frames = 0;				currentSample = (currentSample + 1) % GUIFPS_NUM_SAMPLES;		times[currentSample] = tpfLast;				updateStats();				if (print)			printf("%.2ffps %.2fms/n", fpsLast, 1000.0*tpfLast);				gotNewSample = true;	}	else		gotNewSample = false;		if (tpfMaximum > 0)	{		float step = dt * 10000.0;		float targetHeight = 0.6666 / tpfMaximum;		float to = targetHeight - heightScale;		if (fabs(to) > step)			heightScale += step * to / fabs(to);		else			heightScale = targetHeight;	}}

	void ChunkManager::prioritise(Uint32 from,Uint32 to,Priority priority)	{		if (from > to)			std::swap(from,to);		Uint32 i = from;		while (i <= to && i < (Uint32)d->chunks.size())		{			Chunk* c = d->chunks[i];			c->setPriority(priority);						if (priority == ONLY_SEED_PRIORITY)			{				only_seed_chunks.set(i,true);				d->todo.set(i,false);			}			else if (priority == EXCLUDED)			{				only_seed_chunks.set(i,false);				d->todo.set(i,false);			}			else			{				only_seed_chunks.set(i,false);				d->todo.set(i,!bitset.get(i));			}						i++;		}		updateStats();	}

CWidgetSearchTemplate::CWidgetSearchTemplate(QString searchString, QWidget* parent) :	QWidget(parent),	ui(new Ui::CWidgetSearchTemplate){	ui->setupUi(this);	searchMenu = new QMenu(this);	searchMenu->addAction(ui->actionDownload);	searchMenu->addSeparator();	searchMenu->addAction(ui->actionBanNode);	searchMenu->addAction(ui->actionMarkAsJunk);	searchMenu->addAction(ui->actionClearResults);	searchMenu->addSeparator();	searchMenu->addAction(ui->actionViewReviews);	searchMenu->addAction(ui->actionVirusTotalCheck);	m_sSearchString = searchString;	m_pSearch = 0;	m_nFiles = 0;	m_nHits = 0;	m_nHubs = 0;	m_nLeaves = 0;	m_searchState = SearchState::Default;	m_pSortModel = new QSortFilterProxyModel(this);	m_pSearchModel = new SearchTreeModel();	m_pSortModel->setSourceModel(m_pSearchModel);	ui->treeViewSearchResults->setModel(m_pSortModel);	m_pSortModel->setDynamicSortFilter(false);	connect(m_pSearchModel, SIGNAL(sort()), this, SLOT(Sort()));	connect(m_pSearchModel, SIGNAL(updateStats()), this, SLOT(OnStatsUpdated()));	loadHeaderState();	connect(ui->treeViewSearchResults->header(), SIGNAL(sectionMoved(int,int,int)), this, SLOT(saveHeaderState()));	connect(ui->treeViewSearchResults->header(), SIGNAL(sectionResized(int,int,int)), this, SLOT(saveHeaderState()));	connect(ui->treeViewSearchResults->header(), SIGNAL(sectionClicked(int)), this, SLOT(saveHeaderState()));	setSkin();}

/*-------------------------------------------------------------------------------------------------------------------- FUNCTION: SendPacket---- DATE: November 25, 2015---- REVISIONS: (Date and Description)---- DESIGNER: Alvin Man---- PROGRAMMER: Alvin Man---- INTERFACE:  SendPacket(char* str)--					-char* str : the packet to be sent---- RETURNS: VOID---- NOTES:--		Sends a packet to the serial port.  If we get an ACK back acknowledging the packet we just sent, the packet is--  considered sent successfully, and we return.  If we don't get an ACK back, we assume something went wrong with the--  transmission and we resend the same packet, up to the maximum specified tries.  ----------------------------------------------------------------------------------------------------------------------*/VOID SendPacket(char* str) { 	DWORD numTries_sendPacket = 0;	//Try to send the packet until we reach the maximum number of tries	while (numTries_sendPacket < SEND_PACKET_MAX_TRIES) {		//Send the packet		Send(str, strlen(str), hWrite_Lock);		//Wait for a response for the Packet we sent		char *response = "";		if (!Wait_For_Data(&response, 1, 3000))		{			updateStats(stats.packetSent++, IDC_SDATA0);			//Time'd out, increment counter and restart the loop to send the packet again			OutputDebugString("Packet sending timeout/n");			numTries_sendPacket++;			continue;		}		else if (Evaluate_Response (response[0])) {			updateProgressBar (progressSize / Write_Packets.size());			return;		}	}}

void Application::go(){	Ogre::Timer loopTimer;	bool continueRunning = true;	while ( continueRunning )	{		Ogre::WindowEventUtilities::messagePump();				SimpleInputManager::capture();		// Update logic stuff		float elapsedSeconds = loopTimer.getMicroseconds() * 1.0 / 1000000;		updateLogic( elapsedSeconds );		// Update graphics stuff		updateAnimations( elapsedSeconds );				bool windowClosed = m_window->isClosed();		continueRunning &= ! windowClosed;		updateStats();		loopTimer.reset();		bool renderFrameSuccess = m_root->renderOneFrame();		continueRunning &= renderFrameSuccess;		continueRunning &= ! m_exitRequested;			}}

/* instruments a Binary Operation Expression in a Ist_WrTmp statement */static void instrument_Triop(IRSB* sb, IRStmt* st, Addr64 cia) {  Char thisFct[]="instrument_Triop";  IRDirty* di;  IRExpr** argv;  IRExpr *op = st->Ist.WrTmp.data;  IRExpr* oa_event_expr;  IROp irop=op->Iex.Triop.details->op;  void* f=callbackFromIROp(irop);  if (f == NULL) return;  OA_InstrumentContext inscon=contextFor(cia, irop);  if (not_worth_watching(inscon))    return;  // filter events that can't be attached to source-code location  updateStats(inscon->op);  oa_event_expr = mkIRExpr_HWord( (HWord)inscon );  IRExpr * args1[2];  packToI32orI64(sb, op->Iex.Triop.details->arg2, args1, irop);  IRExpr * args2[2];  packToI32orI64(sb, op->Iex.Triop.details->arg3, args2, irop);  argv = mkIRExprVec_3(args1[0], args2[0], oa_event_expr);  di = unsafeIRDirty_0_N( 3, thisFct, VG_(fnptr_to_fnentry)( f ), argv);  addStmtToIRSB( sb, IRStmt_Dirty(di) );  if (args1[1] != NULL) {    // we need a second callback for 64bit types    argv = mkIRExprVec_3(args1[1], args2[1], oa_event_expr);    di = unsafeIRDirty_0_N( 3, thisFct, VG_(fnptr_to_fnentry)( f ), argv);    addStmtToIRSB( sb, IRStmt_Dirty(di) );  }}

void ConditionAttributes::addCondition(Creature* creature, const Condition* condition){	if (updateCondition(condition)) {		setTicks(condition->getTicks());		const ConditionAttributes& conditionAttrs = static_cast<const ConditionAttributes&>(*condition);		//Remove the old condition		endCondition(creature);		//Apply the new one		memcpy(skills, conditionAttrs.skills, sizeof(skills));		memcpy(specialSkills, conditionAttrs.specialSkills, sizeof(specialSkills));		memcpy(skillsPercent, conditionAttrs.skillsPercent, sizeof(skillsPercent));		memcpy(stats, conditionAttrs.stats, sizeof(stats));		memcpy(statsPercent, conditionAttrs.statsPercent, sizeof(statsPercent));		disableDefense = conditionAttrs.disableDefense;		if (Player* player = creature->getPlayer()) {			updatePercentSkills(player);			updateSkills(player);			updatePercentStats(player);			updateStats(player);		}	}}

void ServerMonitorWindow::loadServers(){	ScrollBarLayout = new QWidget(this);	Layout = new QGridLayout(ScrollBarLayout);	AvailableServers = 0;	UnavailableServers = 0;	ServerStatusWidgetList.clear();	(ProtocolsManager::instance()->byName("gadu") && config_file.readBoolEntry("serverMonitor", "useGaduServersList", true))?			loadServersListFromGaduManager() : loadServersListFromFile();	int serverCounter = 0;	foreach (ServerStatusWidget* serverStatusWidget, ServerStatusWidgetList)	{		int row = serverCounter;		if (serverCounter % 2)			--row;		Layout->addWidget(serverStatusWidget, row, (serverCounter) % 2);		connect (serverStatusWidget, SIGNAL(statusChanged (ServerStatusWidget::ServerState, ServerStatusWidget::ServerState)),			this, SLOT(updateStats (ServerStatusWidget::ServerState, ServerStatusWidget::ServerState)));		serverCounter++;	}

void ConditionAttributes::addCondition(Creature* creature, const Condition* addCondition){	if(updateCondition(addCondition))	{		setTicks(addCondition->getTicks());		const ConditionAttributes& conditionAttrs = static_cast<const ConditionAttributes&>(*addCondition);		//Remove the old condition		endCondition(creature, CONDITIONEND_ABORT);		//Apply the new one		memcpy(skills, conditionAttrs.skills, sizeof(skills));		memcpy(skillsPercent, conditionAttrs.skillsPercent, sizeof(skillsPercent));		memcpy(stats, conditionAttrs.stats, sizeof(stats));		memcpy(statsPercent, conditionAttrs.statsPercent, sizeof(statsPercent));		if(Player* player = creature->getPlayer())		{			updatePercentSkills(player);			updateSkills(player);			updatePercentStats(player);			updateStats(player);		}	}}

void InventoryState::onAutoequip(Action *){	// don't act when moving items	if (_inv->getSelectedItem() != 0)	{		return;	}	BattleUnit               *unit          = _battleGame->getSelectedUnit();	Tile                     *groundTile    = unit->getTile();	std::vector<BattleItem*> *groundInv     = groundTile->getInventory();	Mod                      *mod           = _game->getMod();	RuleInventory            *groundRuleInv = mod->getInventory("STR_GROUND", true);	int                       worldShade    = _battleGame->getGlobalShade();	std::vector<BattleUnit*> units;	units.push_back(unit);	BattlescapeGenerator::autoEquip(units, mod, NULL, groundInv, groundRuleInv, worldShade, true, true);	// refresh ui	_inv->arrangeGround(false);	updateStats();	_refreshMouse();	// give audio feedback	_game->getMod()->getSoundByDepth(_battleGame->getDepth(), Mod::ITEM_DROP)->play();}

Computation* ComputationManager::newComputation(const std::vector<NTYPE>& quantifierSequence, const std::vector<BDD>& cubesAtLevels, const BDD& bdd) {    bool keepFirstLevel = false;    if (quantifierSequence.size() >= 1) { // && quantifierSequence.at(0) == NTYPE::EXISTS) {        keepFirstLevel = app.enumerate() || app.modelCount();    }    if (keepFirstLevel) {        if (optUnsatCheckInterval.getValue() > 0 && quantifierSequence.size() >= 1 && quantifierSequence.at(0) == NTYPE::FORALL) {            throw std::runtime_error("Intermediate UNSAT checking must be disabled for enumeration and counting if outermost quantifier is universal");        }        if (optDisableCache.isUsed()) {            throw std::runtime_error("Removal cache must be enabled for enumeration and counting");        }    }    if (optDisableCache.isUsed()) {        if ((optMaxGlobalNSFSize.isUsed() && optMaxGlobalNSFSize.getValue() != -1) ||                (optMaxBDDSize.isUsed() && optMaxBDDSize.getValue() != 0) ||                (optDependencyScheme.isUsed() && optDependencyScheme.getValue() != "naive")) {            throw std::runtime_error("Cache can only be disabled if none of NSF size, BDD size, and dependency scheme are set");        }        optMaxGlobalNSFSize.setValue("-1");        optMaxBDDSize.setValue("0");        optDependencyScheme.setValue("naive");    }            Computation* c = NULL;    #ifdef DEPQBF_ENABLED    if (optDependencyScheme.getValue() == "standard" || (optDependencyScheme.getValue() == "dynamic" && quantifierSequence.size() > 2)) {        if (depqbf == NULL) {            initializeDepqbf();        }        if (cuddToOriginalIds == NULL) {            initializeCuddToOriginalIds();        }        // always return a new vector        std::vector<std::set < htd::vertex_t>> notYetRemovedAtLevels = initializeNotYetRemovedAtLevels();        c = new StandardDependencyCacheComputation(*this, quantifierSequence, cubesAtLevels, bdd, optMaxBDDSize.getValue(), keepFirstLevel, *depqbf, *cuddToOriginalIds, notYetRemovedAtLevels);    }#endif    if (optDependencyScheme.getValue() == "simple") {        if (variableCountAtLevels == NULL) {            initializeVariableCountAtLevels();        }        c = new SimpleDependencyCacheComputation(*this, quantifierSequence, cubesAtLevels, bdd, optMaxBDDSize.getValue(), keepFirstLevel, *variableCountAtLevels);    }     if (c == NULL) {        if (!optDisableCache.isUsed()) {            c = new CacheComputation(*this, quantifierSequence, cubesAtLevels, bdd, optMaxBDDSize.getValue(), keepFirstLevel);        } else {            c = new Computation(*this, quantifierSequence, cubesAtLevels, bdd);        }    }    updateStats(*c);    return c;}

SignStats * CoreData::addStats(QDate &sdate, QDate &edate){    SignStats * stats = new SignStats(sdate, edate);    updateStats(stats);    statsReports.insert(stats->getKey(), stats);    return stats;}

    void RenderTarget::_endUpdate()    {         // notify listeners (post)        firePostUpdate();        // Update statistics (always on top)        updateStats();    }

state_t * ship_fail(){   printf("Failed to ship parts.../n");   refund();   updateStats(LOST);   return &accepting;   }

state_t * ship_success(){   printf("Successfully shipped parts.../n");   start_warranty();   updateStats(DONE);   exit_from();   return &accepting;}

GUIPlayer::GUIPlayer( Player* p ){  player = p;  if(nameLabel == NULL)      nameLabel = new QLabel( this );  nameLabel->setTextFormat(Qt::RichText);  updateStats();}

State_selectPart::State_selectPart(Fleet& fleet, const int& shipnum, const char& type, int& resultsave): refToFleet(fleet), parttype(type), resultRef(resultsave), page(shipnum){    selector = 0;    console = new TCODConsole(screenwidth/2, screenheight);    partConsole = new TCODConsole(screenwidth / 2, screenheight);    redraw();    updateStats();}

void CoreData::updateReport(){    QMapIterator<QString, SignStats*> ist(statsReports);    while (ist.hasNext()) {        ist.next();        SignStats * stats = ist.value();        updateStats(stats);    }}

void ReliabilitySystem::update( float deltaTime ) {	acked.clear();	advanceQueueTime( deltaTime );	updateQueues();	updateStats();#ifdef NET_UNIT_TEST	validate();#endif}

/** * Unloads the selected weapon. * @param action Pointer to an action. */void InventoryState::btnUnloadClick(Action *){	if (_inv->unload())	{		_txtItem->setText(L"");		_txtAmmo->setText(L"");		_selAmmo->clear();		updateStats();	}}

void KBBGame::abortGame(){  if (running) {    running = FALSE;    ballsPlaced = 0;    updateStats();    gr->clearFocus();    emit gameRuns( running );  }}

/** Public driver routine to call  * other private update methods */void Window::update(){	updateRink();	updatePlayers();	updatePuck();	updateStats();	// Swap buffers to show the whole thing	SDL_Flip(mainSurface);}

// Inicializa los elementos necesarios para la aplicaciónMainWindow::MainWindow(QWidget *parent) : QMainWindow(parent){	setupUi(this);	setupActions();		// Configura la barra de herramienta	QMenu *toolBarMenu = menuSettings->addMenu(tr("&Toolbars"));	toolBar->toggleViewAction()->setShortcut(tr("CTRL+T"));	toolBar->toggleViewAction()->setStatusTip(tr("Show/Hide Main Toolbar"));	toolBar->toggleViewAction()->setText(tr("&Main Toolbar"));	toolBarMenu->addAction(toolBar->toggleViewAction());		actionUndo->setEnabled(false);	actionRepeat->setEnabled(false);		mStatLabel = new QLabel();	statusBar()->addPermanentWidget(mStatLabel);		connect(textEdit, SIGNAL(textChanged()),			this, SLOT(updateStats()));		updateStats();		QDockWidget *templateDocker = new QDockWidget;	templateDocker->setAllowedAreas(Qt::LeftDockWidgetArea|									Qt::RightDockWidgetArea);	templateDocker->setObjectName("TemplateDocker");	templateDocker->setWindowTitle("Templates");	addDockWidget(Qt::LeftDockWidgetArea,templateDocker);		QListView *view = new QListView();	templateDocker->setWidget(view);		TemplateHandler *mTemplate = new TemplateHandler(view, textEdit, this);		templateDocker->toggleViewAction()->setShortcut(tr("CTRL+M"));	templateDocker->toggleViewAction()->setStatusTip(tr("Show/Hide Template Docker"));	templateDocker->toggleViewAction()->setText(tr("&Template Docker"));	toolBarMenu->addAction(templateDocker->toggleViewAction());		// Recuoera la configuración del editor	readsettings();}

// reset()// Description: prepare variables for new gamevoid Game::reset(){    updateStats();    m_grid.clear();    m_gameOver = FALSE;    resetGrabBag();    setNextTile();            for(int i = 0;i < INITIAL_TILE_NUM;i++)        genInitTile();}