A correção constante pode melhorar o desempenho?

Eu li várias vezes que impor a correção constante em seu código C ou C ++ não é apenas uma boa prática com relação à capacidade de manutenção, mas também pode permitir que seu compilador execute otimizações. No entanto, também li o oposto - que não afeta o desempenho de forma alguma.

Portanto, você tem exemplos em que const exatidão pode ajudar seu compilador a melhorar o desempenho do programa?

consta correção não pode melhorar o desempenho porque const_caste mutableestá na linguagem e permite que o código viole as regras de maneira conforme. Isso fica ainda pior em C ++ 11, onde seus constdados podem, por exemplo, ser um ponteiro para a std::atomic, o que significa que o compilador deve respeitar as alterações feitas por outras threads.

Dito isso, é trivial para o compilador olhar o código que ele gera e determinar se ele realmente grava em uma determinada variável e aplicar as otimizações de acordo.

Dito isso, a constcorreção é uma coisa boa no que diz respeito à sustentabilidade. Caso contrário, os clientes de sua classe podem quebrar os membros internos dessa classe. Por exemplo, considere o padrão std::string::c_str()- se não pudesse retornar um valor const, você seria capaz de mexer com o buffer interno da string!

Não use constpor motivos de desempenho. Use-o por motivos de manutenção.

Sim pode.

A maioria dos programas consté puramente para o benefício do programador e não ajuda o compilador a otimizar porque é legal descartá-los e, portanto, eles não informam ao compilador nada de útil para a otimização. No entanto, alguns consts não podem ser (legalmente) descartados e fornecem ao compilador informações úteis para otimização.

Como exemplo, o acesso a uma variável global definida com um consttipo pode ser sequencial, enquanto outra sem um consttipo não pode ser sequencial porque pode ser alterada em tempo de execução.

https://godbolt.org/g/UEX4NB

C ++:

int foo1 = 1;
const int foo2 = 2;

int get_foo1() {
    return foo1;
}

int get_foo2() {
    return foo2;
}

asm:

foo1:
        .long   1
foo2:
        .long   2
get_foo1():
        push    rbp
        mov     rbp, rsp
        mov     eax, DWORD PTR foo1[rip] ; foo1 must be accessed by address
        pop     rbp
        ret
get_foo2():
        push    rbp
        mov     rbp, rsp
        mov     eax, 2 ; foo2 has been replaced with an immediate 2
        pop     rbp
        ret

Em termos práticos, tenha em mente que, embora constpossa melhorar o desempenho, na maioria dos casos não vai ou vai, mas a mudança não será perceptível. A principal utilidade do constnão é a otimização.

Steve Jessop dá outro exemplo em seu comentário sobre a questão original, que traz algo que vale a pena mencionar. Em um escopo de bloco, é possível para um compilador deduzir se uma variável será mutada e otimizar de acordo, independentemente de const, porque o compilador pode ver todos os usos da variável. Em contraste, no exemplo acima, é impossível prever se ele foo1sofrerá mutação, pois pode ser modificado em outras unidades de tradução. Suponho que um ultracompilador senciente hipotético poderia analisar um programa inteiro e determinar se ele é válido para acesso embutido a foo1... mas compiladores reais não podem.

na minha experiencia nao

Para variáveis ​​escalares, o compilador é capaz de determinar quando o valor é alterado e realizar a otimização necessária por si mesmo.

Para ponteiros de array, const exatidão não é garantia de que os valores sejam realmente constantes na presença de possíveis problemas de aliasing. Portanto, o compilador não pode usar o modificador const sozinho para realizar otimizações

se você estiver procurando por otimização, deve considerar __restrict__ou modificadores / atributos de funções especiais: http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html

Um pouco antigo, mas ainda se aplica: http://www.gotw.ca/gotw/081.htm E mais alguns: http://cpp-next.com/archive/2009/08/want-speed-pass-by -valor/