É uma boa prática fazer getters e setters inline?

StackOverflow https://stackoverflow.com/questions/3017264

Pergunta 

public:
     inline int GetValue() const {
          return m_nValue;
     }
     inline void SetValue(int nNewValue) {
          this -> m_nValue = nNewValue;
     }

Sobre Aprenda C ++, eles disseram que isso funcionaria mais rápido. Então, eu pensei que seria ótimo usar em getters e setters. Mas talvez haja algumas desvantagens nisso?

Foi útil?

Solução

Eu não incluí nada até que um perfilador tenha me dito especificamente que não está inline está resultando em um problema de desempenho.

O compilador C ++ é muito inteligente e quase certamente incluirá uma função tão simples como essa para você. E normalmente é mais inteligente do que você e fará um trabalho muito melhor em determinar o que deve ou não estar inlinado.

Eu evitaria pensar sobre o que embalar ou focar na solução. Adicionando o inline A palavra -chave posteriormente (que não é uma garantia de BTW em linha) é muito fácil de fazer e os locais em potencial podem ser encontrados prontamente com um perfilador.

Outras dicas

Se você os escrever dentro da definição, eles são considerados inline por padrão.

Isso significa que eles serão permitidos em várias unidades de compilação (já que as próprias definições de classe geralmente aparecem em várias unidades de compilação), não que eles realmente vão ser inlined.

Essa é uma prática ruim na API pública de qualquer alteração nessas funções, requer recompilação de todos os clientes.

No geral Ter getters e setters está mostrando baixa abstração, não faça isso. Se você está constantemente indo para os dados brutos em outra classe, provavelmente precisará organizar suas classes; em vez disso, considere como deseja manipular os dados de uma classe e fornecer métodos apropriados para fazê -lo.

Pontos negativos:

  1. O compilador é livre para ignorá -lo.

  2. Qualquer alteração nessas funções requer recompilação de todos os clientes.

  3. De qualquer maneira, um bom compilador embalará funções não enlutadas quando for apropriado.

Eu também gostaria de acrescentar que, a menos que você esteja realizando milhões de getas/conjuntos por quadro, é praticamente irrelevante se estes estão inlinados ou não. Honestamente, não vale a pena perder o sono.

Além disso, lembre -se de que, apenas porque você coloca a palavra 'inline' na frente da sua definição de declaração+, não significa que o compilador compre seu código. Ele usa várias heurísticas para descobrir se faz sentido, o que geralmente é o comércio clássico da velocidade versus do tamanho. No entanto, existe a palavra -chave '__forceinline' da força bruta, no contrato de arrendamento no VC ++ (não tenho certeza do que é no GCC), que pisa nas heurísticas extravagantes dos compiladores. Eu realmente não recomendo nada e, além de que você porta para uma arquitetura diferente, provavelmente estará incorreto.

Tente colocar todas as definições de função no arquivo de implementação e deixe as declarações puras para os cabeçalhos (a menos que você seja o modelo metaprograma (STL/Boost/etc), nesse caso, praticamente tudo está nos cabeçalhos;))

Um dos lugares clássicos que as pessoas gostam de embalar (pelo menos nos videogames, que é de onde eu sou), está em cabeçalhos de matemática. Produtos cruzados/pontos, comprimentos de vetor, limpeza da matriz etc. geralmente são colocados no cabeçalho, o que eu acho desnecessário. 9/10 Não faz diferença para o desempenho e, se você precisar fazer um loop apertado, como transformar uma grande matriz vetorial por alguma matriz, provavelmente é melhor fazer manualmente a matemática em linha ou até melhor codificar -a em assembler específico da plataforma.

Ah, e outro ponto, se você acha que realmente precisa de uma classe para ser mais dados do que código, considere o uso de boa estrutura antiga, que não traz a bagagem de abstração OO, é para isso que está lá. :)

Desculpe, não quis continuar tanto, mas acho que ajuda a considerar casos de uso do mundo real e não se enforcar demais nas configurações do compilador pedante (confie em mim, já estive lá;))

Boa sorte.

Shane

O código compilará um pouco mais e você perderá o encapsulamento. Tudo depende do tamanho do projeto e de sua natureza. Na maioria dos casos, não há problema em fazer com que eles não tivessem lógica complexa.

Btw, você pode pular inline Se você implementar diretamente na definição de classe.

Ao colocar o código no cabeçalho, você está expondo seu funcionamento da classe interna. Os clientes podem ver isso e fazer suposições sobre como sua classe funciona. Isso pode tornar mais difícil alterar sua classe posteriormente sem quebrar o código do cliente.

Eu diria que você não precisa se preocupar com isso. Leia o Seção de perguntas frequentes sobre o inline.

Não há necessidade, comece a confiar nos compiladores, pelo menos para essas otimizações!
"Mas não sempre"

A palavra -chave embutida não tem sentido no seu caso

O compilador incluirá sua função, se puder e quiser, independentemente da palavra -chave.

A palavra -chave está afeta a ligação e não o inline. É um pouco confuso, mas leia isso.

Se a definição estiver em uma unidade de compilação diferente (arquivo de origem após o pré -processador, basicamente) do que a chamada, apenas será possível se a otimização de projeto inteiro e a geração de código de tempo de link estiverem ativados. Permitir aumenta muito o tempo de vinculação (já que praticamente recilita tudo no vinculador), mas obviamente pode melhorar o desempenho. Não tenho certeza se está ligado ou desativado por padrão no GCC e vs.

Eu tenho que dizer que não tenho a forte aversão a essa prática que outras pessoas neste tópico parecem ter. Concordo que o ganho de desempenho com o inline é insignificante em todos os casos mais usados. (E sim, eu tenho Encontrei esses casos na prática.) Onde eu faço esse tipo de inline, faço isso por conveniência e, geralmente, apenas para linhas como essa. Na maioria dos meus casos de uso, a necessidade de evitar a recompilação no lado do cliente, se eu os alterar, simplesmente não é tão forte.

Sim, você pode soltar o inline, como está implícito na colocação da implementação.

Além disso, estou um pouco surpreso com a veemência contra os acessores. Você dificilmente pode espirrar em uma aula em qualquer idioma OO sem soprar alguns down, e eles são afinal uma técnica válida para abstrair a implementação da interface, por isso é um pouco masoquista reivindicá -los como uma prática ruim do OO. Isto é Bons conselhos para não escrever acessadores indiscriminadamente, mas também aconselho você a não se empolgar com o zelo para erradicá -los.

Pegue isso, puristas. :-)

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top