Quando è consigliabile utilizzare le variabili temporanee? [chiuso]

https://stackoverflow.com/questions/2725285

02-10-2019
|

Domanda

In particolare, mi chiedo quale di questi dovrei scrivere:

{
    shared_ptr<GuiContextMenu> subMenu = items[j].subMenu.lock();
    if (subMenu)
        subMenu->setVisible(false);
}

{
    if (items[j].subMenu.lock())
        items[j].subMenu.lock()->setVisible(false);
}

Io non sono tenuto a seguire le linee guida dello stile. Dopo l'ottimizzazione, non credo che sia la scelta fa la differenza in termini di prestazioni. Qual è in generale lo stile preferito e perché?

EDIT: il tipo di elementi [j] .subMenu è boost :: weak_ptr. lock () crea uno shared_ptr fuori di esso. V'è in realtà una differenza ambiguo nelle due versioni di cui sopra, per quanto riguarda la durata della shared_ptr temporanea dura, così ho avvolto le mie due esempi in {} parentesi graffe per risolvere l'ambiguità lì.

Soluzione

Un metodo alternativo:

if(shared_ptr<GuiContextMenu> subMenu = items[j].subMenu.lock()) {
    subMenu->setVisible(false);
}
//subMenu is no longer in scope

Sto assumendo subMenu è un weak_ptr, nel qual caso il secondo metodo crea due temporanei, che potrebbe o non potrebbe essere un problema. E il tuo primo metodo aggiunge una variabile per una portata più ampia di quanto dovrebbe. Personalmente, cerco di assegnazioni Evitare all'interno dichiarazioni if, ma questo è uno dei pochi casi in cui mi sento il suo più utile rispetto alle alternative.

Altri suggerimenti

questo caso particolare , è dovrebbe davvero utilizzare la versione con la variabile temporanea. La ragione non è la prestazione, ma la correttezza - in pratica, non si ha la garanzia che le due chiamate x.lock() restituiscono lo stesso valore (ad esempio, se un altro thread rilascia l'ultima forte riferimento per l'oggetto proprio tra le due chiamate.). Tenendo il forte riferimento nella variabile temporanea, si garantisce che non andrà via.

Oltre a questo:

i compilatori di solito non può ottimizzare le chiamate di funzione, a meno che siano dimostrabilmente effetto collaterale gratuito (questo è difficile da fare, ma attribuisce aiuto maggio) o inline. In questo caso, la chiamata ha effetti collaterali.
utilizzando provvisori può portare a programmi più brevi, più leggibile e più mantenibili (ad es. In caso di errore, a risolvere il problema in un posto)

Credo che siete sulla strada giusta su entrambe le scelte di essere non è diverso dopo l'ottimizzazione.

Personalmente, vorrei dichiarare una nuova variabile se rende il codice più leggibile, come ad esempio quando si sta concatenamento chiamate, o di mettere le chiamate di funzione all'interno chiamate di funzione. Finché è mantenibile ed il codice ottiene lo stesso effetto senza differenza di velocità, tutto si riduce al codice leggibile.

Modifica

mmyers comprati un buon commento. Sì, essere attenti a chiamare lock() due volte, al contrario di una sola volta. Essi avranno effetti diversi a seconda dell'implementazione.

La scelta è essenzialmente a voi, ma la cosa fondamentale che si dovrebbe guardare fuori per è la manutenibilità.

Quando il valore di ritorno è qualcosa di diverso che un valore booleano, assegnandolo ad una variabile intermedia spesso può semplificare il debug. Ad esempio, se fate un passo sopra il seguente:

if( fn() > 0 ) ...

tutto quello che si sa, dopo il fatto era che la funzione ha restituito un valore sia inferiore a zero, o zero o più. Anche se il valore di ritorno fosse errato, il codice può ancora sembrano funzionare. L'assegnazione ad una variabile che può essere ispezionato nel vostro debugger vi permetterà di determinare se era previsto il valore di ritorno.

Quando il ritorno è booleano, il valore effettivo è interamente implicito dal flusso di codice, quindi è meno critica; comunque sotto la manutenzione del codice si possono trovare in seguito è necessario che risultato, quindi si può decidere di fare l'abitudine, in ogni caso.

Anche se il valore di ritorno è booleano, un altro aspetto da considerare è se la funzione è richiesta effetti collaterali, e se questo può essere influenzato dall'ambiente valutazione di corto circuito. Per esempio nella dichiarazione:

if( isValid && fn() ) ...

la funzione non sarà mai chiamato è isValid è falso.

Le circostanze in cui il codice potrebbe essere rotto in manutenzione dal programmatore incauti (e spesso i programmatori meno esperti che ottengono le attività di manutenzione) sono molti, e probabilmente meglio evitare.

In questo esempio specifico, penso che dipende da quello che lock() fa. È la funzione costoso? Potrebbe tornare cose diverse ogni volta che la funzione viene chiamata (potrebbe restituire un puntatore la prima volta e NULL la seconda volta)? C'è un altro filo conduttore che potrebbe intercalare fra le due chiamate a lock()?

Per questo esempio, è necessario comprendere il comportamento dei lock() e il resto del codice per prendere una decisione intelligente.

io preferisco il primo maggior parte del tempo perché rende il codice più chiaro e facile da leggere, quindi meno soggetto a errori. Per esempio, hai dimenticato una parentesi su questo secondo esempio :) In questo caso, in realtà, probabilmente farei quello che hai fatto nel secondo esempio, se avevo bisogno di usare quel sottomenu più di un paio di volte mi piacerebbe andare con il primo a rendere il codice più facile da leggere. Per quanto riguarda le prestazioni, ho cosa che qualsiasi compilatore sano di mente sarebbe in grado di ottimizzare quello (che è probabilmente perché si è visto alcuna differenza in termini di prestazioni).

Inoltre, come mmyers sottolineato, che dipende anche da ciò che bloccare () fa. In generale, se si tratta di un metodo semplice getter o qualcosa del genere, andrà tutto bene.

quello che preferite. Per me, dipende da quanto lo userò; per due linee, potrei scriverlo fuori entrambe le volte, mentre io creo una variabile se lo uso più. Tuttavia, tu sei quello che sarà molto probabilmente per mantenere il codice e continuare a guardarla, quindi l'uso quello che funziona per voi. Naturalmente, se sei in una società con una linea guida di codifica, seguirla.

Credo che lo stile preferito è qualunque sia lo stile si pensa rende il codice più leggibile e gestibile. Se sei un team di più di uno, l'unica altra considerazione è che è generalmente una buona idea per tutti di adottare lo stesso stile, di nuovo per migliorare la leggibilità e facilità di manutenzione.

In questo caso penso che si dovrebbe utilizzare la temporanea. Anche se si conosce l'implementazione di .lock () è poco costoso, che può cambiare. Se non c'è bisogno di blocco delle chiamate () due volte, non lo fanno. Il valore qui è che si disaccoppia il codice con l'applicazione di blocco (). E questa è una buona cosa in generale.

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow