Uma função embutida definida em dois arquivos CPP separados pode criar símbolos duplicados durante a ligação?

Question

Encontro muitos recursos on -line sobre como inline (e até mesmo __attribute__((always_inline)) ou __forceinline) não force o compilador (por exemplo, GCC ou Visualc ++) a embrulhar a função. Mas quando exatamente em linha não será aplicado? Existe um exemplo de brinquedo?

Talvez não necessariamente a mesma pergunta, quando uma função marcada com inline Incluído em dois arquivos CPP diferentes criam problemas durante a ligação? Ou seja, gerar símbolos duplicados?

Aqui está uma caixa de areia de concreto para tentar quebrar o compilador em preenchimento e gerar um símbolo duplicado:

Dentro myinline.h:

inline int myinline()
{
  // code that cannot be inlined...
  ...
}

Dentro aux.cpp:

#include "myinline.h"
int aux()
{
  return my_inline();
}

Dentro main.cpp:

#include "myinline.h"
int aux();
int main()
{
  return aux() + my_inline();
}

Então, por exemplo, no caso do GCC, existe algum código (mínimo) para myinline Isso causará um símbolo duplicado ao compilar e vincular com:

g++ -o aux.o -c aux.cpp
g++ -o main.o -c main.cpp
g++ -o example aux.o main.o

?

Answer 1

"Inlining" e "Duplicate Symbols" são coisas diferentes. o inline As palavras-chave permitem explicitamente várias definições (ou seja, isenta você da regra de uma definição); portanto, a plataforma (compilador e vinculador) deve saber como lidar e desduplicar isso.

(Isso acontece o tempo todo para as funções de membro da classe que são definidas nos cabeçalhos.)

Se você só quer geração de código Para acontecer, você pode armazenar o endereço da função em algum lugar:

auto fp = my_inline;

Dessa forma, o compilador deve gerar uma definição da função, para poder fornecer um endereço. Mas mesmo se você fizer isso em todas as unidades de tradução, não receberá um erro de vinculador, pois isso será deduplicado no horário do link. O requisito de que todas as definições sejam idênticas garante que isso seja bem definido.