Ho notato che qualcuno nella mia organizzazione programma confronti come:
if (100 == myVariable)
anziché:
if (myVariable == 100)
Afferma che il primo è più veloce in linguaggi come il C ++. Non riesco a trovare alcuna prova. Programmiamo in C #.
È vero per qualsiasi linguaggio di programmazione?
No, non è "più veloce": i compilatori tradurranno entrambe le espressioni nello stesso codice.
Qualche tempo fa il primo schema è stato suggerito a persone che arrivano a C da altre lingue dove il confronto degli oggetti richiedeva un singolo = . L'idea era di proteggerli dal fare questo errore:
if (myVariable = 100)
Questo è legale, ma assegna 100 a myVariable invece di confrontare myVariable a 100 . Se prendi l'abitudine di mettere 100 prima di myVariable , il compilatore attiverà un errore, perché
if (100 = myVariable)
è illegale.
I compilatori moderni emettono avvisi quando vedono un'assegnazione al posto di un controllo di uguaglianza == . Puoi disattivare l'avviso nei casi in cui desideri utilizzare un compito all'interno di if aggiungendo un secondo insieme di parentesi attorno all'espressione di assegnazione.
Inoltre, il costrutto non è utile in C #, perché if (myVariable = 100) non è legale.
Confronta lo smontaggio:
if (cmdline == NULL)
cmp dword ptr [ebp-138h],0
jne ........
A:
if (NULL == cmdline)
cmp dword ptr [ebp-138h],0
jne ........
Nessuna differenza.
L'unico motivo per l'ordine "if (const == variable)" è quello di catturare gli errati errori di "=" per "==", ma il tuo compilatore, con il livello di avviso appropriato impostato (hai il livello di avviso appropriato set? Buono, basta controllare) li catturerà comunque.
Peggio, oltre ad essere illeggibile come il manoscritto Voynich, può portare il programmatore in un falso senso di sicurezza. Testimone:
int a = GetMeAnInteger ();
int b = GetMeAnotherInteger ();
if (a = b)
Ha! Gotcha!
Quindi - non un più veloce, falso senso di sicurezza, fa in modo che i tuoi colleghi programmatori vogliano sgranare gli occhi.
O d'altra parte potresti semplicemente aumentare il livello di avviso e catturarli comunque.
C'è un caso in cui c'è una differenza in C ++, e se la variabile è di un tipo definito dall'utente, hai la possibilità di sovraccaricare gli operatori di test di uguaglianza o un operatore con un'implementazione distorta.
bool operator == (int a, T b);
bool operator == (T a, int b);
Loro potrebbero avere diverse implementazioni, avere una avanti o l'altra Per il confronto simmetrico alla vaniglia, non dovrebbero esserci differenze.
Risposta breve: No, non c'è differenza. Entrambi i confronti nell'esempio sopra hanno lo stesso effetto.
Viene tradotto nel compilatore con la stessa logica di confronto. Quindi, sono identici nella velocità.
Ciò che fa la differenza è l'ordine di operazione. Pertanto, per evitare problemi di ordine operativo, è consigliabile utilizzare parentesi. Inoltre, riceverai l'avviso del compilatore in C # .NET se è presente una sintassi errata.
Nel mondo multi-core e fuori-ordinamento di oggi, non puoi più contare su microefficienze come questa. Anche se ha salvato un ciclo o due, non c'è alcuna garanzia quando l'istruzione verrà programmata, o se la linea della cache che contiene la variabile verrà bloccata (o svuotata). Non sono nemmeno sicuro di quanto sia più efficiente la valutazione del cortocircuito (per semplici confronti).