Como usar bibliotecas

Por alguma razão, nunca consigo usar bibliotecas externas em qualquer idioma. Estou procurando instruções / explicações de como usar bibliotecas externas, bem como como elas funcionam. Quando procuro on-line, recebo fragments que nunca parecem se aplicar a qualquer biblioteca que eu baixe e tente usar. Eu trabalho em um mac e um pc, e exemplos de C ++ estão bem. Eu uso eclipse IDE com o plug-in C ++. Se há instruções que se aplicam a todas as bibliotecas que seria ótimo.

Digamos que você tenha uma class Unuseful definida da seguinte forma:

Arquivo Unuseful.h :

 class Unuseful { public: void printUnusefulStatement(); }; 

Arquivo Unuseful.cpp :

 #include "unuseful.h" #include  void Unuseful::printUnusefulStatement() { std::cout << "Hello world!" << std::endl; } 

Agora, você tem outra class que precisa imprimir instruções inúteis:

 Unuseful u; u.printUnusefulStatement(); 

Isso significa que você deseja usar uma biblioteca externa contendo a implementação específica ( printUnusefulStatement ) que deseja include em seu código.

Você pode usar essa biblioteca de duas maneiras:

  1. Fornecendo o código-fonte para o compilador
  2. Fornecendo um arquivo binário (que havia sido compilado anteriormente para sua arquitetura), para o vinculador

Caso 1: usando uma biblioteca em tempo de compilation

Este é o caso mais simples. Você tem o código fonte da biblioteca que você tem que usar e você simplesmente tem que compilá-lo junto com seu código existente (digamos main.cpp file). Normalmente você é o autor e usuário da biblioteca (uma class que realiza uma tarefa que você precisa).

Compilando com este comando:

 g++ main.cpp unuseful.cpp 

permite que você use a implementação que você precisa no seu arquivo main.cpp .

Caso 2: vinculando uma biblioteca

Mais frequentemente do que o Caso 1 , você não possui o código-fonte da biblioteca que deseja usar. Você só tem o arquivo de header ( Unuseful.h , para continuar com o exemplo) e uma biblioteca estática ou compartilhada (provavelmente [*] arquivos libunuseful.so e libunuseful.so , respectivamente).

A biblioteca estática é um arquivo de arquivos de object ( *.o ) que são vinculados dentro de seus executáveis ​​finais, as bibliotecas compartilhadas são carregadas dinamicamente - em tempo de execução (veja esta página para uma melhor compreensão da diferença).

Bibliotecas estáticas são criadas simplesmente arquivando os arquivos *.o com o programa ar :

 # Create the object files (only one here) g++ -c unuseful.cpp # Create the archive (insert the lib prefix) ar rcs libunuseful.a unuseful.o 

Bibliotecas compartilhadas são criadas com a opção g++ -shared :

 # Create the object file with Position Independent Code[**] g++ -fPIC -c unuseful.cpp # Crate the shared library (insert the lib prefix) g++ -shared -o libunuseful.so unuseful.o 

Vamos supor que agora você tenha o arquivo Unuseful.h e a biblioteca compartilhada (arquivo libunuseful.so ) e tenha um arquivo main.cpp que instancie um object Unuseful e chame o método printUnusefulStatement .

Se você tentar compilar este arquivo ( g++ main.cpp ), o vinculador irá reclamar porque não pode encontrar o símbolo printUnusefulStatement .

Está na hora de usar a biblioteca:

 g++ main.cpp -L. -lunuseful 

A opção -L diz ao vinculador onde procurar por arquivos de biblioteca e o sinalizador -l informa ao vinculador o nome das bibliotecas a serem usadas (sem o prefixo lib ).

Agora o executável ( a.out , porque não especifiquei um nome diferente) é criado e você usou uma biblioteca para implementar uma funcionalidade que precisava ( printUnusefulStatement ).

Como a biblioteca compartilhada é carregada em tempo de execução, a execução do executável a.out pode falhar porque o sistema não consegue localizar a biblioteca. Normalmente, isso pode ser resolvido configurando adequadamente uma variável de ambiente indicando quais caminhos usar para procurar por bibliotecas dinâmicas:

 # Set the LD_LIBRARY_PATH [*] export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:. 

Feito, agora seu executável foi compilado e será capaz de executar e carregar a biblioteca que precisa.

Conclusão

Esta é uma visão geral rápida das bibliotecas, que espero que possa ajudá-lo a entender como elas são usadas e fornecidas a outras pessoas.

Há muitos aspectos que devem ser investigados com mais detalhes, se você estiver interessado: opções de g++ ao criar bibliotecas compartilhadas, opções de ar , variables ​​de ambiente, o formato de bibliotecas compartilhadas e assim por diante.

[*]: Em um ambiente Unix

[**]: Se suportado pela máquina de destino, emitir código independente de posição, adequado para vinculação dinâmica e evitar qualquer limite no tamanho da tabela de deslocamento global. Esta opção faz diferença no m68k, no PowerPC e no SPARC. Código independente de posição requer suporte especial e, portanto, funciona somente em determinadas máquinas. [Da página de manual do g ++]

Aqui é onde você começa http://en.wikipedia.org/wiki/Library_(computing)

Basicamente, uma ‘biblioteca’ é uma coleção de funções compiladas e declarações de classs.

Em um Mac existem também “frameworks” que são um pouco semelhantes às unidades de Pascal e contêm tanto as declarações quanto o código compilado.

Em linguagens gerenciadas, como Java ou C #, existem pacotes e assemblies. Ambos estão intimamente relacionados às bibliotecas.

Para usar bibliotecas em C ou C ++, é necessário ter um arquivo .lib (ou um arquivo .a para a maioria dos compiladores baseados em conjuntos de ferramentas POSIX ou GCC) e os protótipos das funções que são compilados no arquivo .lib. Dependendo do seu ambiente de desenvolvimento (para o Eclipse você provavelmente está usando o compilador GCC e o toolchain GNU com o LD linker), basta especificar os arquivos da biblioteca (.lib ou .a) como input para o vinculador. Na maioria das vezes, a biblioteca é acompanhada de arquivos de header que contêm as definições de protótipos de function.

Mesmo que você não saiba sobre o link, o que é estranho o suficiente, as bibliotecas ainda são usadas implicitamente em seu programa – o std :: cout está na libstdc ++ ou na biblioteca C Run-Time.

Como um exemplo de uma biblioteca enorme e um conjunto útil de classs C ++, você pode querer olhar para o Boost.

Para escrever GUI no Windows, você pode usar o WinAPI, que é descrito no MSDN.

Para escrever GUI no Mac, você pode usar o Carbon API, que é um pouco semelhante ao WinAPI, mas agora está obsoleto. A única maneira de escrever GUI “legit” para MacOS é usar Cocoa e Objective-C.

Para escrever interface gráfica entre plataformas, você pode usar muitas bibliotecas: Qt, wxWidgets, GTK entre elas.

Por último, mas não menos importante. C ++ não é a melhor linguagem para GUI.