Quando devo escrever a palavra-chave 'inline' para uma função / método?

Quando devo escrever a palavra-chave inlinepara uma função / método em C ++?

Depois de ver algumas respostas, algumas perguntas relacionadas:

• Quando não devo escrever a palavra-chave 'inline' para uma função / método em C ++?

• Quando o compilador não sabe quando criar uma função / método 'inline'?

• Importa se um aplicativo é multithread quando se escreve 'inline' para uma função / método?

Oh cara, uma das minhas irritações.

inlineé mais staticou externmenos uma diretiva dizendo ao compilador para incorporar suas funções. extern, static, inlineSão directivas de ligação, usado quase que exclusivamente pelo vinculador, não o compilador.

Diz-se que inlinesugere ao compilador que você acha que a função deve estar embutida. Isso pode ter sido verdade em 1998, mas uma década depois o compilador não precisa dessas dicas. Sem mencionar que os seres humanos geralmente estão errados quando se trata de otimizar código, portanto a maioria dos compiladores ignora a 'dica'.

• static- o nome da variável / função não pode ser usado em outras unidades de tradução. O Linker precisa garantir que não use acidentalmente uma variável / função definida estaticamente de outra unidade de tradução.

• extern- use este nome de variável / função nesta unidade de tradução, mas não reclame se não estiver definido. O vinculador irá resolvê-lo e garantir que todo o código que tentou usar algum símbolo externo tenha seu endereço.

• inline- esta função será definida em várias unidades de tradução, não se preocupe. O vinculador precisa garantir que todas as unidades de conversão usem uma única instância da variável / função.

Nota: Geralmente, declarar modelos não inlinefaz sentido, pois eles já têm a semântica de ligação inline. No entanto, especialização explícita e instanciação de modelos precisaminline ser usadas.

Respostas específicas para suas perguntas:

• Quando devo escrever a palavra-chave 'inline' para uma função / método em C ++?

  Somente quando você deseja que a função seja definida em um cabeçalho. Mais exatamente, apenas quando a definição da função pode aparecer em várias unidades de tradução. É uma boa idéia definir funções pequenas (como em um liner) no arquivo de cabeçalho, pois fornece ao compilador mais informações para trabalhar enquanto otimiza seu código. Também aumenta o tempo de compilação.

• Quando não devo escrever a palavra-chave 'inline' para uma função / método em C ++?

  Não adicione inline apenas porque você acha que seu código será executado mais rapidamente se o compilador o incorporar.

• Quando o compilador não sabe quando criar uma função / método 'inline'?

  Geralmente, o compilador poderá fazer isso melhor do que você. No entanto, o compilador não tem a opção de incorporar código se não tiver a definição de função. No código otimizado ao máximo, geralmente todos os privatemétodos são incorporados, independentemente de você solicitar ou não.

  Como um aparte para impedir a inclusão no GCC, use __attribute__(( noinline ))e no Visual Studio, use __declspec(noinline).

• Importa se um aplicativo é multithread quando se escreve 'inline' para uma função / método?

  O multithreading não afeta o inlining de forma alguma.

Eu gostaria de contribuir para todas as ótimas respostas neste tópico com um exemplo convincente para dispersar qualquer mal-entendido restante.

Dados dois arquivos de origem, como:

• inline111.cpp:

  #include <iostream>
  
  void bar();
  
  inline int fun() {
    return 111;
  }
  
  int main() {
    std::cout << "inline111: fun() = " << fun() << ", &fun = " << (void*) &fun;
    bar();
  }

• inline222.cpp:

  #include <iostream>
  
  inline int fun() {
    return 222;
  }
  
  void bar() {
    std::cout << "inline222: fun() = " << fun() << ", &fun = " << (void*) &fun;
  }

• Caso A:

  Compilar :

  g++ -std=c++11 inline111.cpp inline222.cpp

  Saída :

  inline111: fun() = 111, &fun = 0x4029a0
  inline222: fun() = 111, &fun = 0x4029a0

  Discussão :

  1. Mesmo que você deva ter definições idênticas de suas funções embutidas, o compilador C ++ não o sinaliza se esse não for o caso (na verdade, devido à compilação separada, não há como verificar). É seu próprio dever garantir isso!

  2. O Linker não reclama da regra de definição única , como fun()é declarado inline. No entanto, como inline111.cpp é a primeira unidade de conversão (que na verdade chama fun()) processada pelo compilador, o compilador instancia fun()seu primeiro encontro de chamada no inline111.cpp . Se o compilador decidir não expandir fun()sua chamada de qualquer outro lugar no seu programa ( por exemplo, de inline222.cpp ), a chamada para fun()sempre será vinculada à sua instância produzida a partir de inline111.cpp (a chamada para fun()dentro de inline222.cpptambém pode produzir uma instância nessa unidade de tradução, mas permanecerá desvinculada). De fato, isso é evidente nas &fun = 0x4029a0impressões idênticas .

  3. Por fim, apesar da inlinesugestão ao compilador de expandir o one-liner fun(), ele ignora completamente sua sugestão, o que é claro porque fun() = 111nas duas linhas.

• Caso B:

  Compilar (observe a ordem inversa) :

  g++ -std=c++11 inline222.cpp inline111.cpp

  Saída :

  inline111: fun() = 222, &fun = 0x402980
  inline222: fun() = 222, &fun = 0x402980

  Discussão :

  1. Neste caso, afirma que foram discutidos em Caso A .

  2. Observe um ponto importante: se você comentar a chamada real fun()em inline222.cpp ( por exemplo, comentar completamente a coutdeclaração em inline222.cpp ), então, apesar da ordem de compilação de suas unidades de tradução, fun()será instanciado no seu primeiro contato em inline111.cpp , resultando na impressão do caso B como inline111: fun() = 111, &fun = 0x402980.

• Caso C:

  Compilar (aviso -O2) :

  g++ -std=c++11 -O2 inline222.cpp inline111.cpp

  ou

  g++ -std=c++11 -O2 inline111.cpp inline222.cpp

  Saída :

  inline111: fun() = 111, &fun = 0x402900
  inline222: fun() = 222, &fun = 0x402900

  Discussão :

  1. Conforme descrito aqui , a -O2otimização incentiva o compilador a expandir realmente as funções que podem ser incorporadas (observe também que -fno-inlineé o padrão sem as opções de otimização). Como é evidente na cópia impressa aqui, fun()ela foi realmente expandida em linha (de acordo com sua definição nessa unidade de tradução específica ), resultando em duas impressões diferentes fun() . Apesar disso, ainda existe apenas uma instância globalmente vinculada fun()(conforme exigido pelo padrão), como é evidente em impressões idênticas &fun .

Você ainda precisa alinhar explicitamente sua função ao fazer a especialização de modelo (se a especialização estiver no arquivo .h)

1) Hoje em dia, praticamente nunca. Se for uma boa ideia incorporar uma função, o compilador fará isso sem a sua ajuda.

2) sempre. Veja # 1.

(Editado para refletir que você dividiu sua pergunta em duas perguntas ...)

Quando não devo escrever a palavra-chave 'inline' para uma função / método em C ++?

Se a função for declarada no cabeçalho e definida no .cpparquivo, você não deve escrever a palavra-chave.

Quando o compilador não sabe quando criar uma função / método 'inline'?

Não existe tal situação. O compilador não pode tornar uma função embutida. Tudo o que pode fazer é alinhar algumas ou todas as chamadas para a função. Não é possível fazer isso se não tiver o código da função (nesse caso, o vinculador precisa fazê-lo, se puder).

Importa se um aplicativo é multithread quando se escreve 'inline' para uma função / método?

Não, isso não importa.

• Quando o compilador não sabe quando criar uma função / método 'inline'?

Isso depende do compilador usado. Não confie cegamente que hoje em dia os compiladores sabem melhor do que os humanos como incorporar e você nunca deve usá-lo por motivos de desempenho, porque é a diretiva de ligação e não a dica de otimização. Embora eu concorde que ideologicamente esses argumentos sejam corretos, encontrar a realidade pode ser uma coisa diferente.

Depois de ler vários threads, tentei, por curiosidade, os efeitos do inline no código que estou trabalhando e os resultados foram que eu obtive uma aceleração mensurável para o GCC e nenhuma aceleração para o compilador Intel.

(Mais detalhes: simulações matemáticas com poucas funções críticas definidas fora da classe, GCC 4.6.3 (g ++ -O3), ICC 13.1.0 (icpc -O3); adicionar inline a pontos críticos causou + 6% de aceleração com o código GCC).

Portanto, se você qualificar o GCC 4.6 como um compilador moderno, o resultado é que a diretiva inline ainda será importante se você escrever tarefas intensivas da CPU e souber exatamente onde está o gargalo.

Na realidade, praticamente nunca. Tudo o que você está fazendo é sugerir que o compilador faça uma determinada função embutida (por exemplo, substitua todas as chamadas para essa função / com seu corpo). Não há garantias, é claro: o compilador pode ignorar a diretiva.

O compilador geralmente fará um bom trabalho ao detectar + otimizar coisas como esta.

Por padrão, o gcc não alinha nenhuma função ao compilar sem a otimização ativada. Não conheço o visual studio - deft_code

Eu verifiquei isso no Visual Studio 9 (15.00.30729.01) compilando com / FAcs e observando o código do assembly: O compilador produziu chamadas para funções-membro sem a otimização habilitada no modo de depuração . Mesmo se a função estiver marcada com __forceinline , nenhum código de tempo de execução embutido será produzido.

Você deseja colocá-lo no início, antes do tipo de retorno. Mas a maioria dos compiladores ignora. Se ele estiver definido e tiver um bloco de código menor, a maioria dos compiladores o considerará em linha de qualquer maneira.

A menos que você esteja escrevendo uma biblioteca ou tenha motivos especiais, você pode esquecer inlinee usar a otimização do tempo do link . Isso elimina o requisito de que uma definição de função deva estar em um cabeçalho para ser considerada como embutida nas unidades de compilação, e é exatamente isso que inlinepermite.

(Mas consulte Existe algum motivo para não usar a otimização do tempo do link? )

A palavra-chave inline solicita que o compilador substitua a chamada de função pelo corpo da função, ele primeiro avalia a expressão e depois passa. Reduz a sobrecarga da chamada de função, pois não há necessidade de armazenar o endereço de retorno e a pilha de memória não é necessária para a função. argumentos.

Quando usar:

• Para melhorar o desempenho
• Para reduzir a sobrecarga de chamadas.
• Como é apenas uma solicitação ao compilador, certas funções não serão incorporadas * funções grandes
  • funções com muitos argumentos condicionais
  • código recursivo e código com loops etc.

C ++ inline é totalmente diferente de C inline .

#include <iostream>
extern inline int i[];
int i [5];
struct c {
  int function (){return 1;} //implicitly inline
  static inline int j = 3; //explicitly inline
};
int main() {
  c j;
  std::cout << i;
}

inlinepor si só afeta o compilador, montador e vinculador. É uma diretiva para o compilador dizendo que apenas emite um símbolo para esta função / dados se for usado na unidade de tradução e, se for, como os métodos de classe, diga ao assembler para armazená-los na seção .section .text.c::function(),"axG",@progbits,c::function(),comdatou .section .bss.i,"awG",@nobits,i,comdatpara dados. As instanciações de modelo também entram em seus próprios grupos de comdat.

Isto segue .section name, "flags"MG, @type, entsize, GroupName[, linkage]. Por exemplo, o nome da seção é .text.c::function(). axGsignifica que a seção é alocável, executável e em um grupo, ou seja, um nome de grupo será especificado (e não há sinalizador M, portanto, nenhum tamanho será especificado); @progbitssignifica que a seção contém dados e não está em branco; c::function()é o nome do grupo e o grupo possuicomdatlinkage, o que significa que em todos os arquivos de objeto, todas as seções encontradas com esse nome de grupo marcadas com comdat serão removidas do executável final, exceto 1, isto é, o compilador garante que haja apenas uma definição na unidade de tradução e, em seguida, pede ao assembler para colocar em seu próprio grupo no arquivo de objeto (1 seção em 1 grupo) e, em seguida, o vinculador garantirá que, se algum arquivo de objeto tiver um grupo com o mesmo nome, inclua apenas um no .exe final. A diferença entre etc pelo montador devido a suas diretivas.inlinee não usar inlineagora é visível para o montador e, como resultado, o vinculador, porque não é armazenado no arquivo regular .dataou.text

static inlineem uma classe significa que é uma definição de tipo e não declaração (permite que um membro estático seja definido na classe) e torne-o inline; agora se comporta como acima.

static inlineno escopo do arquivo afeta apenas o compilador. Isso significa para o compilador: somente emita um símbolo para esta função / dados se for usado na unidade de tradução e faça isso como um símbolo estático comum (armazene em.text /.data sem a diretiva .globl). Para o montador, agora não há diferença entre staticestatic inline

extern inlineé uma declaração que significa que você deve definir esse símbolo na unidade de tradução ou gerar erro do compilador; se estiver definido, trate-o como regular inlinee para o montador e vinculador não haverá diferença entre extern inlinee inline, portanto, este é apenas um protetor de compilador.

extern inline int i[];
extern int i[]; //allowed repetition of declaration with incomplete type, inherits inline property
extern int i[5]; //declaration now has complete type
extern int i[5]; //allowed redeclaration if it is the same complete type or has not yet been completed
extern int i[6]; //error, redeclaration with different complete type
int i[5]; //definition, must have complete type and same complete type as the declaration if there is a declaration with a complete type

O conjunto acima, sem a linha de erro, é recolhido inline int i[5]. Obviamente, se você fez extern inline int i[] = {5};entãoextern seria ignorado devido à definição explícita através da atribuição.

inlineem um espaço para nome, veja isso e isso

Ao desenvolver e depurar código, deixe de inlinefora. Isso complica a depuração.

O principal motivo para adicioná-los é ajudar a otimizar o código gerado. Normalmente, isso troca maior espaço de código por velocidade, mas às vezes inlineeconomiza espaço em código e tempo de execução.

Gastar esse tipo de pensamento sobre otimização de desempenho antes da conclusão do algoritmo é otimização prematura .

Quando alguém deve alinhar:

1.Quando alguém deseja evitar a sobrecarga de coisas que acontecem quando a função é chamada como passagem de parâmetro, transferência de controle, retorno de controle etc.

2.A função deve ser pequena, frequentemente chamada e tornar inline é realmente vantajosa, pois, de acordo com a regra 80-20, tente tornar inline a função que tenha maior impacto no desempenho do programa.

Como sabemos, o inline é apenas uma solicitação para o compilador semelhante ao registro e isso custará o tamanho do código do objeto.

A função embutida C ++ é um conceito poderoso que é comumente usado com classes. Se uma função estiver embutida, o compilador coloca uma cópia do código dessa função em cada ponto em que a função é chamada em tempo de compilação.

Qualquer alteração em uma função embutida pode exigir que todos os clientes da função sejam recompilados porque o compilador precisaria substituir todo o código novamente, caso contrário, continuará com a funcionalidade antiga.

Para embutir uma função, coloque a palavra-chave embutida antes do nome da função e defina a função antes que sejam feitas chamadas para a função. O compilador pode ignorar o qualificador em linha, caso a função definida seja mais do que uma linha.

Uma definição de função em uma definição de classe é uma definição de função embutida, mesmo sem o uso do especificador embutido.

A seguir, é apresentado um exemplo, que utiliza a função embutida para retornar no máximo dois números

#include <iostream>

using namespace std;

inline int Max(int x, int y) { return (x > y)? x : y; }

// Main function for the program
int main() {
   cout << "Max (100,1010): " << Max(100,1010) << endl;

   return 0;
}

para mais informações veja aqui .