Enviado em 31/12/2022 - 15:44h
Normalmente você divide os arquivos da seguinte forma:
• a interface, que é o que o compilador precisa conhecer para que o programador possa usar a sua biblioteca sem produzir erros de compilação, vai no(s) arquivo(s) de cabeçalhos (tipicamente com sufixo “.h”), que permanece(m) em formato de código fonte e é (são) lido(s) a cada nova compilação de código que use sua biblioteca;
• a implementação, que é o que o
linker precisa conhecer para poder viabilizar a execução daquilo que a sua biblioteca se propõe a fazer, geralmente reside em um ou mais arquivos já compilados, quer como arquivos avulsos com código objeto (sufixo “.o” ou “.po” no mundo Unix, ou “.OBJ” no mundo Microsoft) quer em arquivos de bibliotecas estáticas (sufixo “.a” ou “.LIB”) ou dinâmicas (sufixo “.so” ou “.DLL”).
Um arquivo de cabeçalhos em C geralmente não provoca emissão de código objeto, porque contém apenas declarações de objetos (variáveis e funções) e de tipos incompletos, e definições de tipos (
struct s,
union s,
typedef s,
enum s), macros (i.e.
#define s) e constantes na forma de
labels de enumerações.
Em C++, cabeçalhos podem conter também outras definições de tipo (
class es,
enum class ,
enum struct ,
using ),
templates (mas não seu instanciamento),
concepts , e muitas pessoas admitem também definições de constantes de tipos nativos (por exemplo: “const int NUMBER=5;”) e funções
inline (explicitamente ou implicitamente, quando possível) porque, embora estas duas últimas possam provocar emissão de código, em C++ tais definições de constantes têm ligação interna, ao contrário do C, em que teriam ligação externa. No caso de
templates que possuam código C++ mais extenso, é comum (o GCC, por exemplo, faz isso) separar a parte mais declarativa, que permanece no arquivo com sufixo “.h”, da parte que contém os algoritmos dos
templates de funções ou funções-membros de classes, que é movida para arquivos com sufixo “.tcc”, fazendo com que o arquivo “.h” tenha um
#include do arquivo “.tcc”. Note, porém, que o arquivo “.tcc” não provoca imediatamente emissão de código objeto no momento da compilação, pois ele contém apenas a definição dos algoritmos de
templates ; a emissão de código correspondente somente ocorre quando o
template é instanciado.
A implementação daquilo que é descrito nos arquivos de cabeçalho geralmente reside em um ou mais arquivos com sufixos “.c” (para linguagem C) ou “.C”, “.cc”, “.cpp” ou “.cxx” (para C++), e incluem a definição de objetos (variáveis e funções), a definição de tipos incompletos e o possível instanciamento de
templates . Tais arquivos fontes são então compilados para o formato de código objeto, como acima mencionado, e são distribuídos diretamente nessa forma, ou, principalmente quando há múltiplos arquivos com código objeto, podem ser aglutinados na forma de bibliotecas estáticas e/ou dinâmicas (apenas um arquivo para cada versão).
Para exemplificar essa divisão, seguem alguns trechos de uma biblioteca que eu fiz para extração de dados a partir de uma fonte na rede (não posso publicar na íntegra por enquanto), ilustrando a divisão em “.h”, “.tcc” e “.cc”.
// Arquivo my_lib.h
// Arquivo my_lib.tcc
// Arquivo my_lib.cc
No Linux, a biblioteca estática se produz a partir o arquivo objeto.
g++ -Wall -Werror -pedantic-errors -O2 -std=c++11 -c my_lib.cc
Já a biblioteca dinânima pode ser gerada a partir de um objeto compilado com opção de gerar código relocável (
position independent code ).
g++ -Wall -Werror -pedantic-errors -O2 -std=c++11 -fPIC -c my_lib.cc -o my_lib.lo
Para usar num programa, o código fonte em C++ precisa incluir o cabeçalho.
#include "my_lib.h"
E o executável gerado tem de fazer referência a uma das bibliotecas acima (por exemplo, usando a biblioteca estática).
g++ -Wall -Werror -pedantic-errors -O2 -std=c++11 -o test test.cc libmy_lib.a
... Então Jesus afirmou de novo: “(...) eu vim para que tenham vida, e a tenham plenamente.” (João 10:7-10)
