Porque hei-de usar o código inline?

Desempenho

Como foi sugerido em respostas anteriores, o uso da palavra-chave {[[4]} pode tornar o código mais rápido através da introdução de chamadas de funções, muitas vezes à custa de aumento de executáveis. "Inlining function calls" significa simplesmente substituir a chamada para a função alvo com o código real da função, depois de preencher os argumentos em conformidade.

Declarar funções inline explicitamente para o bem do ganho de desempenho é (quase? sempre desnecessário!

No entanto, declarar uma função incorporada usando a palavra-chave inline tem outros efeitos, e pode realmente ser necessário para satisfazer a regra de uma definição (ODR): esta regra na norma c++ diz que um dado símbolo pode ser declarado várias vezes, mas só pode ser definido uma vez. If the link editor (=linker) encontra várias definições de símbolos idênticos, irá gerar um erro.

Uma solução para este problema é garantir que uma unidade de compilação não exporta um dado símbolo, dando-lhe uma ligação interna, declarando-o static.

Um exemplo, considere o seguinte programa:

// header.hpp
#ifndef HEADER_HPP
#define HEADER_HPP

#include <cmath>
#include <numeric>
#include <vector>

using vec = std::vector<double>;

/*inline*/ double mean(vec const& sample) {
    return std::accumulate(begin(sample), end(sample), 0.0) / sample.size();
}

#endif // !defined(HEADER_HPP)

// test.cpp
#include "header.hpp"

#include <iostream>
#include <iomanip>

void print_mean(vec const& sample) {
    std::cout << "Sample with x̂ = " << mean(sample) << '\n';
}

// main.cpp
#include "header.hpp"

void print_mean(vec const&); // Forward declaration.

int main() {
    vec x{4, 3, 5, 4, 5, 5, 6, 3, 8, 6, 8, 3, 1, 7};
    print_mean(x);
}

Note que ambos os ficheiros .cpp incluem o ficheiro header e, portanto, a definição da função de mean. Embora o arquivo seja salvo com guardas de inclusão Dupla, isso resultará em duas definições da mesma função, embora em diferentes unidades de compilação.

Agora, se você tentar ligar essas duas unidades de compilação-por exemplo, usando o seguinte comando:

⟩⟩⟩ g++ -std=c++11 -pedantic main.cpp test.cpp

Se, no entanto, descomentar o modificador inline em frente à definição da função, o código compila e liga correctamente.

os modelos de função são um caso especial: são Sempre alinhados, independentemente de terem sido declarados dessa forma. Isso não significa que o compilador vai ligar para eles., mas não violam a RLL. O mesmo é verdadeiro para as funções membros que são definidas dentro de uma classe ou estrutura.

O código Inline funciona como macros em essência, mas é um código real Real Real Real, que pode ser otimizado. As funções muito pequenas são muitas vezes boas para inlining porque o trabalho necessário para configurar a chamada de função (carregar os parâmetros nos registros apropriados) é caro em comparação com a pequena quantidade de trabalho real que o método faz. Com o inlining, não há necessidade de configurar a chamada de função, porque o código é diretamente "colado" em qualquer método que o usa.

Inlining aumenta o tamanho do Código, que é a sua principal desvantagem. Se o código é tão grande que ele não pode caber no cache do CPU, você pode obter grandes desacelerações. Você só precisa se preocupar com isso em casos raros, uma vez que não é provável que você está usando um método em tantos lugares o código aumentado causaria problemas.

Edit: como outros já salientaram, o inlining é apenas uma sugestão para o compilador. Ele pode ignorá-lo livremente se ele pensa que você está fazendo pedidos estúpidos como inlining um enorme método de 25 linhas.

Há uma grande diferença entre o código" regular " e o código inline?

O código Sim-inline não envolve uma chamada de função, e salvar variáveis de registo para a pilha. Ele usa o espaço de programa cada vez que é 'chamado'. Então, no geral, leva menos tempo para executar porque não há ramificação no processador e economia de Estado, limpeza de caches, etc.

• o código inline é simplesmente uma "forma" de macros?

As Macros e o código inline partilham semelhanças. a grande diferença é que o código inline é formatado especificamente como uma função para que o compilador, e futuros mantenedores, tenham mais opções. Especificamente, ele pode facilmente ser transformado em uma função se você disser ao compilador para otimizar para o espaço de código, ou um futuro mantenedor acaba expandindo-o e usando-o em muitos lugares em seu código.

• Que tipo de troca deve ser feita quando se escolhe inserir o código?
  • Macro: uso de alto código de espaço, execução rápida, difícil para manter se a "função" for longa
  Função
  • : Baixo uso de espaço de código, mais lento de executar, fácil de manter
  • função Inline: utilização de alto código de espaço, execução rápida, fácil de manter

deve-se notar que a gravação do registo e saltar para a função ocupa espaço de código, de modo que para funções muito pequenas uma linha Pode ocupar menos espaço do que uma função.

-Adam

Vantagem: nenhuma chamada de função superior (colocar parâmetros, empurrar o PC actual, Saltar para a função, etc.). Pode ser importante na parte central de um laço grande, por exemplo.

Inconveniente: inflaciona o binário gerado.

Inline difere das macros porque é uma dica para o compilador (compilador pode decidir não alinhar o código!) and macros are source code text generation before the compilation and as such are "forced" to be inlined.

Marcar uma função em linha significa que o compilador tem a opção para incluir em "in-line" onde é chamada, se o compilador optar por fazê-lo; em contraste, uma macro irá sempre ser expandida no local. Uma função incorporada terá os símbolos de depuração adequados configurados para permitir que um depurador simbólico rastreie a origem de onde veio, enquanto que depurar macros é confuso. As funções Inline precisam ser funções válidas, enquanto macros... bem, não o faças.

Decidir declarar uma função inline é um grande espaço de compensação -- o programa será maior se o compilador decide inline (particularmente se ele também não está estático, caso em que pelo menos um não-lineares cópia é necessária para uso de todos os objetos externos); de fato, se a função for grande, isso poderia resultar em uma queda no desempenho menos como o seu código se encaixa em cache. O impulso geral de desempenho, no entanto, é apenas que você está se livrando da sobrecarga da função chamada em si; para um pequeno função chamada como parte de um laço interior, isso é um tradeoff que faz sentido.

Se estiver a marcar o seu código como estando em linha em F. E. C++, também está a dizer ao seu compilador que o código deve ser executado em linha, ou seja. esse bloco de código será" mais ou menos " inserido onde é chamado (removendo assim o empurrão, popping e pulando na pilha). Então, sim... recomenda-se se as funções são adequadas para esse tipo de comportamento.

" inline "é como o equivalente de 2000 a"register". Não se incomode, o compilador pode fazer um trabalho melhor de decidir o que otimizar do que você pode.

Um exemplo clássico de um bom candidato para inlining são getters para classes de concreto simples.

CPoint
{
  public:

    inline int x() const { return m_x ; }
    inline int y() const { return m_y ; }

  private:
    int m_x ;
    int m_y ;

};

Alguns compiladores (por exemplo, VC2005 ) têm uma opção para inlining agressivo, e você não precisaria de especificar a palavra-chave 'inline' ao usar essa opção.

Eu não vou reiterar o acima, mas vale a pena notar que as funções virtuais não serão alinhadas como a função chamada é resolvida no tempo de execução.

O Inlining está normalmente activo no nível 3 de optimização (-O3 no caso do GCC). Pode ser uma melhoria significativa da velocidade em alguns casos (quando possível).

Inlining explícito em seus programas pode adicionar alguma melhoria de velocidade com o custo de um tamanho de código incisivo.

Você deve ver o que é adequado: tamanho de código ou velocidade e decidir se você deve incluí-lo em seus programas.

A resposta de se você inline vem para baixo para a velocidade. Se você está em um loop apertado chamando uma função, e não é uma função super grande, mas uma em que muito do tempo é desperdiçado em chamar a função, em seguida, fazer essa função inline e você vai ter um monte de bang para o seu dinheiro.

Primeiro de tudo inline é um pedido para compilador para inline a função. então é upto compiler para torná-lo inline ou não.

1. Quando utilizar?Quando alguma vez uma função é de muito poucas linhas(para todos os acessores e mutador) mas não para recursivo funções
Vantagem?O tempo necessário para invocar a chamada de função não está envolvido
2. o compilador tem alguma função própria?Sim, quando alguma vez uma função é definida no ficheiro header dentro de uma classe

Se o código está a correr lentamente, saia do seu profiler para encontrar problemas e trabalhar neles.

Deixei de adicionar funções incorporadas aos ficheiros de cabeçalho, isto aumenta o acoplamento, mas dá pouco em troca.

O código Inline é mais rápido. Não há necessidade de realizar uma chamada de função (cada chamada de função custa algum tempo). A desvantagem é que você não pode passar um ponteiro para uma função em linha ao redor, como a função realmente não existe como função e, portanto, não tem ponteiro. Também a função não pode ser exportada para o público (por exemplo, uma função em linha em uma biblioteca não está disponível dentro de binários ligando contra a biblioteca). Outra é que a seção de código em seu binário vai crescer, se você chamar o função de vários lugares (como cada vez que uma cópia da função é gerada em vez de ter apenas uma cópia e sempre pulando lá)

Normalmente não é necessário decidir manualmente se uma função deve ser inline ou não. Por exemplo, o GCC decidirá isso automaticamente dependendo do nível de otimização (-Ox) E dependendo de outros parâmetros. Ele vai levar as coisas em consideração como "Quão grande é a função?"(número de instruções), quantas vezes é chamado dentro do Código, quanto o binário vai ficar maior ao colocá-lo, e algumas outras métricas. E. g. se uma função é estático (assim não exportados de qualquer maneira) e somente uma vez dentro do seu código e você nunca use um ponteiro para a função, as chances são boas de que o GCC vai decidir inline-lo automaticamente, como ele não terá nenhum impacto negativo (o binário não ficar maiores inlining-lo apenas uma vez).