The as-if rule
Da cppreference.com.
 |
Questa pagina è stata tradotta in modo automatico dalla versione in ineglese della wiki usando Google Translate.
La traduzione potrebbe contenere errori e termini strani. Muovi il puntatore sopra al testo per vedere la versione originale. Puoi aiutarci a correggere gli gli errori. Per ulteriori istruzioni clicca qui. |
Consente a qualsiasi e tutte le trasformazioni di codice che non cambiano il comportamento osservabile del programma
Original:
Allows any and all code transformations that do not change the observable behavior of the program
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
You can help to correct and verify the translation. Click here for instructions.
Indice |
[modifica] Spiegazione
Il compilatore C + + è consentito effettuare eventuali modifiche al programma finché il seguente rimane vero:
Original:
The C++ compiler is permitted to perform any changes to the program as long as the following remains true:
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
You can help to correct and verify the translation. Click here for instructions.
- Accessi (lettura e scrittura) agli oggetti volatili verificano nello stesso ordine come scritto.Original:Accesses (reads and writes) to the volatile objects occur in the same order as written.The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
- Al termine del programma, i dati scritti a tutti i file è esattamente come se il programma è stato eseguito come scritto.Original:At program termination, the data written to all files is exactly as if the program was executed as written.The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
- Tutte le operazioni di input e output si verificano nello stesso ordine e con lo stesso contenuto se il programma è stato eseguito come scritto.Original:All input and output operations occur in the same order and with the same content as if the program was executed as written.The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
[modifica] Note
Poiché il compilatore è (di solito) in grado di analizzare il codice di una libreria esterna per determinare se esso sia o non esegue l'accesso I / O o volatili, libreria di terze parti richiede anche non sono interessati da ottimizzazione. Tuttavia, le chiamate di libreria standard può essere sostituita da altre chiamate, eliminato o aggiunto al programma durante l'ottimizzazione.
Original:
Because the compiler is (usually) unable to analyze the code of an external library to determine whether it does or does not perform I/O or volatile access, third-party library calls also aren't affected by optimization. However, standard library calls may be replaced by other calls, eliminated, or added to the program during optimization.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
You can help to correct and verify the translation. Click here for instructions.
Programmi con un comportamento indefinito, ad esempio per accedere a un array fuori dai limiti, la modifica di un oggetto const, ordine di valutazione violazioni, ecc, sono liberi dal come-se regola: spesso cambiare il comportamento osservabile quando ricompilato con diverse impostazioni di ottimizzazione. Ad esempio, se un test per firmato integer overflow si basa sul risultato di tale overflow, ad esempio if(n+1 < n) abort();, it is removed entirely by some compilers perché troppopieno firmato è un comportamento indefinito e l'ottimizzatore è libero di assumere non accade mai e il test è superfluo.
Original:
Programs with undefined behavior, e.g. due to access to an array out of bounds, modification of a const object, ordine di valutazione violations, etc, are free from the as-if rule: they often change observable behavior when recompiled with different optimization settings. For example, if a test for signed integer overflow relies on the result of that overflow, e.g. if(n+1 < n) abort();, it is removed entirely by some compilers because troppopieno firmato è un comportamento indefinito and the optimizer is free to assume it never happens and the test is redundant.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
You can help to correct and verify the translation. Click here for instructions.
Copia elisione è l'unica ben definita deroga alla regola come-se.
Original:
Copia elisione is the only well-defined exception from the as-if rule.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
You can help to correct and verify the translation. Click here for instructions.
[modifica] Esempio
int& preinc(int& n) { return ++n; } int add(int n, int m) { return n+m; } // volatile input to prevent constant folding volatile int input = 7; // volatile output to make the result a visible side-effect volatile int result; int main() { int n = input; // using built-in operators would invoke undefined behavior // int m = ++n + ++n; // but using functions makes sure the code executes as-if // the functions were not overlapped int m = add(preinc(n), preinc(n)); result = m; }
Output:
# full code of the main() function as produced by the GCC compiler
# x86 (Intel) platform:
movl input(%rip), %eax # eax = input
leal 3(%rax,%rax), %eax # eax = 3 + eax + eax
movl %eax, result(%rip) # result = eax
xorl %eax, %eax # eax = 0 (the return value of main())
ret
# PowerPC (IBM) platform:
lwz 9,LC..1(2)
li 3,0 # r3 = 0 (the return value of main())
lwz 11,0(9) # r11 = input;
slwi 11,11,1 # r11 = r11 << 1;
addi 0,11,3 # r0 = r11 + 3;
stw 0,4(9) # result = r0;
blr
# Sparc (Sun) platform:
sethi %hi(result), %g2
sethi %hi(input), %g1
mov 0, %o0 # o0 = 0 (the return value of main)
ld [%g1+%lo(input)], %g1 # g1 = input
add %g1, %g1, %g1 # g1 = g1 + g1
add %g1, 3, %g1 # g1 = 3 + g1
st %g1, [%g2+%lo(result)] # result = g1
jmp %o7+8
nop
# in all cases, the side effects of preinc() were eliminated, and the
# entire main() function was reduced to the equivalent of result = 2*input + 3;
