Gerenciamento de dependência semelhante ao Maven para C ++? [fechadas]

Digamos que eu tenha um projeto C ++ dividido em vários subprojetos. Todos os subprojetos produzem uma DLL e diferentes equipes de desenvolvedores trabalham em cada um dos subprojetos. Agora, se eu quiser construir o projeto principal, há uma maneira de evitar ter que construir todos os subprojetos sozinho?

Resumindo, estou procurando algo que faça o gerenciamento de dependências (ou seja, para arquivos binários e cabeçalhos) de maneira semelhante ao que o Maven faz para Java.

Na verdade, eu tentei usar o Maven para isso, mas isso é um pouco complicado porque tenho que criar os pacotes manualmente e com bastante frequência, o Maven deixa de selecionar as alterações mais recentes. Além disso, executar a compilação é um pouco complicado, pois tenho que chamar o NAnt de dentro do Maven (eu uso o recurso do NAnt para construir soluções do Visual Studio diretamente).

Alguma dica e ideia de como fazer isso?

Resposta inicial : Eu sugeriria o uso do CMake. É um gerador de arquivos multiplataforma (também gera projetos Visual Studio ou Eclipse CDT).

http://www.cmake.org/

Eu fiz uma experiência muito boa com isso. A melhor coisa que gosto nisso é a capacidade de produzir uma estrutura de projeto genérica. Portanto, você pode incluir genericamente a pesquisa de subprojetos para testes de unidade, etc., sem alterar o script todas as vezes.

Eles também têm muitos módulos sobre como encontrar bibliotecas de compilação pré-instaladas, necessárias para o projeto (como Boost, QT etc.)

Atualização : nesse meio tempo, houve algum esforço para introduzir o gerenciamento de pacotes para C ++. Alguns projetos que vale a pena conferir:

• conan.io integra-se com as principais ferramentas de construção:
  • CMake
  • Estúdio visual
  • Makefile
  • XCode
  • ...
• cpm com base no CMake ( observe que o CPM não está sendo mantido ativamente.)
• Buckaroo

Nota, conforme apontado por @RAM nos comentários, cpm não é mais mantido ativamente.

Para o gerenciamento de dependências, existe um novo projeto (é uma empresa startup) que está implementando este tipo de ferramenta: https://github.com/biicode (um gerenciador de dependências C ++). Você pode adicionar suas dependências e deve funcionar.

Atualmente, o nome do projeto é conan.io , eles foram adquiridos pela JFrog .

ATUALIZAÇÃO: O projeto está morto ... Infelizmente, parece que a inicialização não conseguiu clientes pagantes premium suficientes, mas o servidor parece estar funcionando bem ...

ATUALIZAÇÃO2: Parece que existe um projeto substituto: conan.io (obrigado @mucaho)

Eu recomendo os seguintes sistemas de construção de alto nível:

• Plug-in Maven Nar: Usando Maven para projetos C / C ++
• Plugin cpp do Gradle : É a maneira mais fácil, mas está incubando, aqui estão os principais recursos e um roteiro .
• Conan é uma abordagem mais C ++, é multi-plataforma e suporta a maioria dos sistemas de construção C ++ comuns.

Se você quer apenas gerenciamento de dependências, experimente o Ivy , ele se integra perfeitamente ao Ant (e eu suponho que o NAnt possa fazer o mesmo com base neste blog , que tem um link do site do Ivy).

Também existe o Byldan , uma versão .Net do Maven. Não sei se isso funcionará bem para você.

Make e GCC são uma ótima combinação para uma verificação de dependência realmente boa.

O GCC pode gerar arquivos de dependência 'make' automaticamente (opção de linha de comando -MD), de modo a ser capaz de reconstruir todos os arquivos de origem que dependem de um determinado cabeçalho, por exemplo.

Eu tenho algumas regras simples que recorte e colo em meus makefiles:

# compile c files   
%.o:    %.c
    ${CC} ${CFLAGS} -c $< -MD -MF $(<:%.c=%.dep) -o $@

# compile c++ files
%.opp:  %.cpp
    ${CPP} ${CPPFLAGS} -c $< -MD -MF $(<:%.cpp=%.dep) -o $@

Agora, se seus arquivos objeto são declarados em uma lista OBJ_C e OBJ_CPP:

.PHONY: cleandep
cleandep:
    rm -f $(OBJ_C:%.o=%.dep) $(OBJ_CPP:%.opp=%.dep)

-include $(OBJ_C:%.o=%.dep) $(OBJ_CPP:%.opp=%.dep)

O Make pode, é claro, rastrear dependências com outros projetos e outros, por exemplo, reconstruindo uma biblioteca compartilhada conforme necessário.

Por exemplo, se suas outras equipes sempre colocam suas DLLs mais recentes em alguma pasta compartilhada:

myapp: ${SRC_CPP} ${LIB_DIR}other_team.lib
  ...

${LIB_DIR}other_team.lib: /shared_folder/latest/other_team.lib
  cp /shared_folder/latest/other_team.lib ${LIB_DIR}other_team.lib

Editar:

Biicode está obsoleto

Alternativa: Conan.io

Eu recomendo o conan , que eu estava usando atualmente. É muito poderoso manter todas as bibliotecas e binários dependentes em seu projeto.

Você pode criar o pacote NuGet para bibliotecas usadas e usar o NuGet para gerenciamento de dependências.

Veja também, NuGet para C ++

Há uma série de ferramentas no topo do SCons, fornecendo funcionalidade de nível superior semelhante à do Autotools que estão tentando tornar a vida do desenvolvedor mais fácil (por exemplo, WAF, SNOCS). Infelizmente, o próprio SCons tem a maior desvantagem - maior tempo de compilação para grandes projetos.

Recomendo experimentar SNOCS (que é um SCons invertido) para aqueles que procuram um gerenciamento de dependência fácil e escolhem opções de compilação em um único comando (compilador, x86 / x64, Debug / Release, bibliotecas estáticas / compartilhadas, teste / instalar alvos, etc.).

SNOCS também tenta resolver o problema de longo tempo de compilação, armazenando a saída de configuração do projeto em arquivos separados, o que permite que as compilações subsequentes ignorem a fase de configuração e vão direto para a fase de construção (o último recurso está em construção agora)

A configuração do CMake se torna tediosa em soluções maiores, então a manutenção do sistema de construção leva uma grande fração do tempo do desenvolvedor. Felizmente como o Martijn já mencionou, existe o biicode que "usa o CMake para gerar seu projeto com suas dependências".

Experimente SCons

SCons é uma ferramenta de construção de software de código aberto - ou seja, uma ferramenta de construção de última geração. Pense no SCons como um substituto de plataforma cruzada aprimorado para o utilitário Make clássico com funcionalidade integrada semelhante ao autoconf / automake e caches de compilador como o ccache. Resumindo, o SCons é uma maneira mais fácil, confiável e rápida de criar software.

Eu recomendo usar a mãe de todos os sistemas de dependência de construção: make.

Experimente scons, você ficará viciado. Make é desatualizado, difícil e caro de manter.