The as-if rule
Da cppreference.com
 |
This page has been machine-translated from the English version of the wiki using Google Translate.
The translation may contain errors and awkward wording. Hover over text to see the original version. You can help to fix errors and improve the translation. For instructions click here. |
Permite a qualquer e todas as transformações de código que não alteram o comportamento observável do programa
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.
Índice |
[editar] Explicação
O compilador C + + é permitido realizar quaisquer alterações ao programa, desde que o seguinte permanece verdadeira:
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.
- Acessos (lê e escreve) para os objetos voláteis ocorrem na mesma ordem escrita.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.
- Ao término do programa, os dados gravados todos os arquivos é exatamente como se o programa foi executado como escrito.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.
- Todas as operações de entrada e de saída ocorrem na mesma ordem e com o mesmo conteúdo que, se o programa foi executado como escrito.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.
[editar] Notas
Porque o compilador é (geralmente) incapaz de analisar o código de uma biblioteca externa para determinar se ele tem ou não realizar o acesso de E / S ou volátil, de terceiros chamadas de biblioteca também não são afetados pela otimização. No entanto, as chamadas de biblioteca padrão pode ser substituído por outras chamadas, eliminados, ou adicionado ao programa durante a otimização.
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.
Programas com comportamento indefinido, por exemplo, devido ao acesso a uma série de limites, a modificação de um objeto const, ordem de avaliação violações, etc, estão livres da regra como-se: muitas vezes mudar o comportamento observável quando recompilado com diferentes configurações de otimização. Por exemplo, se um teste para a assinatura transbordamento de inteiros baseia-se no resultado da referida descarga, por exemplo, if(n+1 < n) abort();, it is removed entirely by some compilers porque estouro assinado é um comportamento indefinido eo otimizador é livre para assumir isso nunca acontece eo teste é redundante.
Original:
Programs with undefined behavior, e.g. due to access to an array out of bounds, modification of a const object, ordem de avaliação 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 estouro assinado é um comportamento indefinido 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.
Elisão cópia é a única exceção bem definida a partir da regra de como-se.
Original:
Elisão cópia 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.
[editar] Exemplo
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; }
Saída:
# 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;
