Como usar o comando ar do Linux para criar bibliotecas estáticas

Use Linux ar comando para criar bibliotecas de funções quando você está desenvolvendo software. Este tutorial mostrará como criar uma biblioteca estática, modifique-o e use-o em um programa, completo com código de amostra.

a ar Command é um verdadeiro veterano, existe desde 1971. O nome ar refere-se ao uso pretendido original da ferramenta, que foi para criar arquivos de arquivo. Um arquivo é um único arquivo que atua como um contêiner para outros arquivos. As vezes, para muitos outros arquivos. Os arquivos podem ser adicionados, deletar ou extrair do arquivo. Pessoas que procuram esse tipo de funcionalidade não recorrem mais a ar. Esse papel foi assumido por outras empresas de serviços públicos, como tar.

a ar Apesar disto, o comando ainda é usado para alguns propósitos especializados. ar usado para criar bibliotecas estáticas. Eles são usados ​​no desenvolvimento de software. E ar ele também é usado para criar arquivos de pacote, como arquivos “.deb” usado na distribuição Debian Linux e seus derivados, como Ubuntu.

Vamos revisar as etapas necessárias para criar e modificar uma biblioteca estática e demonstrar como usar a biblioteca em um programa. Fazer isso, precisamos de um requisito para a biblioteca estática atender. O objetivo desta biblioteca é codificar strings de texto e decodificar texto codificado.

Observe que este é um hack rápido e sujo para fins de demonstração. Não use essa criptografia para nada de valor. É o mais simples do mundo criptografia substituta, onde A se torna B, B se torna C, e assim por diante.

RELACIONADO: Como compactar e extrair arquivos usando o comando tar no Linux

As funções cipher_encode () y cipher_decode ()

Vamos trabalhar em um diretório chamado “biblioteca” e então vamos criar um subdiretório chamado “prova”.

Temos dois arquivos neste diretório. Em um arquivo de texto chamado cipher_encode.c, temos o cipher_encode() Função:

void cipher_encode(char * text)
{
 para (int i = 0; texto[eu] != 0x0; i ++) {
   texto[eu]++;
 }

} // fim de cipher_encode

O respectivo cipher_decode() A função está em um arquivo de texto chamado cipher_decode.c:

void cipher_decode(char * text)
{
 para (int i = 0; texto[eu] != 0x0; i ++) {
   texto[eu]--;
 }

} // fim de cipher_decode

Os arquivos que contêm instruções de programação são chamados de arquivos de código-fonte.. Vamos criar um arquivo de biblioteca chamado libcipher.a. Ele conterá as versões compiladas desses dois arquivos de código-fonte. Também criaremos um arquivo de texto curto chamado libcipher.h. Este é um arquivo de cabeçalho que contém as definições das duas funções em nossa nova biblioteca.

Qualquer pessoa com a biblioteca e o arquivo de cabeçalho poderá usar as duas funções em seus próprios programas. Eles não precisam reinventar a roda e reescrever as funções; eles apenas fazem uso das cópias em nossa biblioteca.

Compile os arquivos cipher_encode.c e cipher_decode.c

Para compilar os arquivos de código-fonte, usaremos gcc, a compilador GNU padrão. a -c (compilar, ligação de pecado) opção diz gcc para compilar os arquivos e então parar. Produz um arquivo intermediário para cada arquivo de código-fonte denominado arquivo-objeto. a gcc O vinculador geralmente pega todos os arquivos de objeto e os vincula para criar um programa executável. Pulamos essa etapa usando o -c opção. Precisamos apenas dos arquivos objeto.

Vamos verificar se temos os arquivos que achamos que temos.

ls -l

Os dois arquivos de código-fonte estão presentes neste diretório. Vamos usar gcc para compilá-los em arquivos-objeto.

gcc -c cipher_encode.c

gcc -c cipher_decode.c

Não deve haver saída de gcc se tudo correr bem.

Isso gera dois arquivos de objeto com o mesmo nome dos arquivos de código-fonte, mas com extensões “.o”. Estes são os arquivos que devemos adicionar ao arquivo de biblioteca.

ls -l

Criação da biblioteca libcipher.a

Para criar o arquivo de biblioteca, que é na verdade um arquivo de arquivo, usaremos ar.

Estamos usando o -c (Criar) opção para criar arquivo de biblioteca, a -r (adicionar com substituir) para adicionar os arquivos ao arquivo da biblioteca, e a -s (índice) opção de criar um índice dos arquivos dentro do arquivo de biblioteca.

Vamos chamar o arquivo de biblioteca de libcipher.a. Fornecemos esse nome na linha de comando, junto com os nomes dos arquivos de objeto que vamos adicionar à biblioteca.

ar -crs libcipher.a cipher_encode.o cipher_decode.o

Se listarmos os arquivos no diretório, veremos que agora temos um arquivo libcipher.a.

ls -l

Se usarmos o -t (Tabela) opção com ar podemos ver os módulos dentro do arquivo de biblioteca.

ar -t libcipher.a

Crie o arquivo de cabeçalho libcipher.h

O arquivo libcipher.h será incluído em qualquer programa que use a biblioteca libcipher.a.. O arquivo libcipher.h deve conter a definição das funções que estão na biblioteca.

Para criar o arquivo de cabeçalho, devemos escrever as definições de função em um editor de texto como o gedit. Nomeie o arquivo "libcipher.h" e salve-o no mesmo diretório do arquivo libcipher.a.

void cipher_encode(char * text);
void cipher_decode(char * text);

Usando a biblioteca libcipher

A única maneira segura de testar nossa nova biblioteca é escrever um pequeno programa para usá-la.. Primeiro, vamos criar um diretório chamado test.

teste mkdir

Vamos copiar a biblioteca e os arquivos de cabeçalho para o novo diretório.

cp libcipher. * ./test

Vamos mudar para o novo diretório.

teste de cd

Vamos verificar se nossos dois arquivos estão aqui.

ls -l

Precisamos criar um pequeno programa que possa usar a biblioteca e demonstrar que funciona conforme o esperado. Escreva as seguintes linhas de texto em um editor. salvar o conteúdo do editor para um arquivo chamado “teste.c” no prova diretório.

#incluir <stdio.h>
#incluir <stdlib.h>

#incluir "libcipher.h"

int principal(int argc, char * argv[])
{
 texto char[]="How-To Geek adora Linux";

 coloca(texto);

 cipher_encode(texto);
 coloca(texto);

 cipher_decode(texto);
 coloca(texto);

 saída (0);

} // fim do principal

O fluxo do programa é muito simples:

• Inclui o arquivo libcipher.h para que você possa ver as definições das funções da biblioteca.
• Crie uma string chamada “texto” e armazena as palavras “How-To Geek adora Linux” nele.
• Imprima aquela string na tela.
• ligar para cipher_encode() função para codificar a string, e imprimir a string codificada na tela.
• Lama cipher_decode() para decodificar a string e imprimir a string decodificada na tela.

Para gerar o test Programa, precisamos compilar o programa test.c e o link na biblioteca. a -o (Saída) opção diz gcc como chamar o programa executável que ele gera.

gcc test.c libcipher.a -o test

E gcc silenciosamente retorna para o prompt de comando, tudo está bem. Agora vamos testar nosso programa. Momento da verdade:

./teste

E vemos a saída esperada. a test O programa imprime o texto simples, imprime o texto criptografado e, em seguida, imprime o texto descriptografado. Você está usando as funções de nossa nova biblioteca. Nossa biblioteca está funcionando.

Sucesso. Mas, Por que parar aí?

Adicionar outro módulo à biblioteca

Vamos adicionar outra função à biblioteca. Adicionaremos uma função que o programador pode usar para exibir a versão da biblioteca que está usando. Precisamos criar a nova função, compile-o e adicione o novo arquivo de objeto ao arquivo de biblioteca existente.

Escreva as seguintes linhas em um editor. Salve o conteúdo do editor em um arquivo chamado cipher_version.c, no Biblioteca diretório.

#incluir <stdio.h>

void cipher_version(vazio)
{
 coloca("How-To Geek :: Biblioteca de cifras MUITO INSEGURA");
 coloca("Versão 0.0.1 alfa");

} // fim de cipher_version

Precisamos adicionar a definição da nova função ao arquivo de cabeçalho libcipher.h. Adicione uma nova linha no final desse arquivo, para fazer com que pareça assim:

void cipher_encode(char * text);
void cipher_decode(char * text);
void cipher_version(vazio);

Salve o arquivo libcipher.h modificado.

Precisamos compilar o arquivo cipher_version.c para que tenhamos um arquivo objeto cipher_version.o.

gcc -c cipher_version.c

Isso cria um arquivo cipher_version.o. Podemos adicionar o novo arquivo de objeto à biblioteca libcipher.a com o seguinte comando. a -v (detalhado) torna a opção geralmente silenciosa ar diga-nos o que você fez.

ar -rsv libcipher.a cipher_version.o

O novo arquivo de objeto é adicionado ao arquivo de biblioteca. ar confirmação de impressão. o “uma” Isso significa “agregar”.

Podemos usar o -t (Tabela) opção para ver quais módulos estão dentro do arquivo de biblioteca.

ar -t libcipher.a

Agora, existem três módulos em nosso arquivo de biblioteca. Vamos usar a nova função.

Usando a função cipher_version ().

Vamos remover a biblioteca acima e o arquivo de cabeçalho do diretório de teste, vamos copiar os novos arquivos e depois voltar para o diretório de teste.

Removeremos as versões anteriores dos arquivos.

rm ./test/libcipher.*

Vamos copiar as novas versões no diretório de teste.

cp libcipher. * ./test

Vamos mudar para o diretório de testes.

teste de cd

E agora podemos modificar o programa .c teste para usar a nova função de biblioteca.

Precisamos adicionar uma nova linha ao programa de teste.c que chama cipher_version() Função. Vamos colocar isso antes do primeiro puts(text); linha.

#incluir <stdio.h>
#incluir <stdlib.h> 

#incluir "libcipher.h" 

int principal(int argc, char * argv[]) 
{
 texto char[]="How-To Geek adora Linux"; 

 // new line added here
 cipher_version(); 

 coloca(texto); 
 
 cipher_encode(texto); 
 coloca(texto); 
 
 cipher_decode(texto); 
 coloca(texto); 

 saída (0); 

} // fim do principal

Guarde isso como um teste.c. Agora podemos compilá-lo e testar que o novo recurso está operacional.

gcc test.c libcipher.a -o test

Vamos executar a nova versão de test:

O novo recurso está funcionando. Podemos ver a versão da biblioteca no início da saída de test.

Mas pode haver um obstáculo.

Substituição de um módulo na biblioteca

esta não é a primeira versão da biblioteca; é o segundo. Nosso número de versão está incorreto. A primeira versão não tinha cipher_version() função nele. Este sim.. Então esta deve ser a versão “0.0.2”. Precisamos substituir o cipher_version() função na biblioteca com um corrigido.

Felizmente, ar torna muito fácil de fazer.

Primeiro, vamos editar o arquivo cipher_version.c no Biblioteca diretório. Alterar o texto “Versão 0.0.1 Alfa” uma “Versão 0.0.2 Alfa”. Deve ser assim.:

#incluir <stdio.h>

void cipher_version(vazio)
{
 coloca("How-To Geek :: Biblioteca de cifras MUITO INSEGURA");  
 coloca("Versão 0.0.2 alfa"); 

} // fim de cipher_version

Salve este arquivo. Precisamos compilá-lo novamente para criar um novo arquivo de objeto cipher_version.o.

gcc -c cipher_version.c

Agora vamos substituir o objeto cipher_version.o existente na biblioteca com nossa versão recém-compilada.

Nós usamos o -r (adicionar com substituir) antes, para adicionar novos módulos à biblioteca. Quando o usamos com um módulo que já existe na biblioteca, ar irá substituir a versão antiga pela nova. a -s Opção (índice) irá atualizar o índice da biblioteca e -v (detalhado) a opção irá ar diga-nos o que você fez.

ar -rsv libcipher.a cipher_version.o

Desta vez ar relata que substituiu o módulo cipher_version.o. o “r” significa substituído.

Usando a função cipher_version () Atualizada

Devemos usar nossa biblioteca modificada e verificar se funciona.

Vamos copiar os arquivos da biblioteca para o diretório de teste.

cp libcipher. * ./test

Vamos mudar para o diretório de testes.

cd ./test

Precisamos compilar nosso programa de teste novamente com nossa nova biblioteca.

gcc test.c libcipher.a -o test

E agora podemos testar nosso programa.

./teste

O resultado do programa de teste é o que esperávamos. O número da versão correto é exibido na string da versão e as rotinas de criptografia e descriptografia estão funcionando.

Excluir módulos de uma biblioteca

Parece uma pena depois de tudo isso, mas vamos remover o arquivo cipher_version.o do arquivo de biblioteca.

Para fazer isso, nós vamos usar o -d (excluir) opção. Também usaremos o -v opção (detalhado), de modo que ar nos conta o que ele fez. Também incluiremos o -s (índice) opção para atualizar o índice no arquivo de biblioteca.

ar -dsv libcipher.a cipher_version.o

ar relata que você removeu o módulo. o “d” Isso significa “removido”.

Se perguntarmos ar para listar os módulos dentro do arquivo de biblioteca, veremos que estamos de volta a dois módulos.

ar -t libcipher.a

Se você estiver excluindo módulos de sua biblioteca, lembre-se de deletar sua definição do arquivo de cabeçalho da biblioteca.

Compartilhe seu código

As bibliotecas tornam o código compartilhável de maneira prática, mas privada. Qualquer pessoa a quem você fornecer o arquivo de biblioteca e o arquivo de cabeçalho pode usar sua biblioteca, mas o seu código-fonte real permanece privado.