CMake: inclure les dépendances de la bibliothèque dans une bibliothèque statique

Je suis la construction d'un statique bibliothèque dans CMake, qui dépend de beaucoup d'autres bibliothèques statiques. Je voudrais tous d'être inclus dans la sortie .lib/.un fichier, si je peux juste navire un gros fichier lib pour les clients. Dans Visual Studio; 2010, il est une option, "Bibliothèque de liens de Dépendances", qui fait exactement cela.

Mais je ne trouve pas comment faire dans CMake. Pouvez-vous définir ce drapeau via CMake, ou d'obtenir le même résultat d'une autre façon? J'ai essayé target_link_libraries(...) et aussi add_dependencies(...), mais CMake semble tout simplement ignorer cette ligne pour les bibliothèques statiques.

Avez-vous des versions statiques des bibliothèques qui doivent être liés à l'encontre? Ou pensez-vous que vous avez partagé versions?
j'ai des versions statiques
Donc quand vous dites que ce n'est pas de les inclure dans votre statique, est-il en essayant de lier votre bibliothèque statique contre les autres bibliothèques partagées?
j'ai seulement les bibliothèques statiques, et j'essaye de construire une bibliothèque statique, donc pas de liaison est mis en place. Le problème est lorsqu'une troisième partie souhaite utiliser mes libs et avoir de lien à beaucoup d'autres choses également

InformationsquelleAutor Rolle | 2013-01-07

c++cmake

15

Bon, alors j'ai une solution. D'abord il est important de reconnaître que les bibliothèques statiques n'ont pas de lien d'autres bibliothèques statiques dans le code. Une bibliothèque combinée doit être créé, qui sur Linux peut être fait avec ar. Voir Reliant les bibliothèques statiques à d'autres bibliothèques statiques pour plus d'info, il y.

Tenir compte de deux fichiers source:

test1.c:
```
 int hi()
 {
   return 0;
 }
```
test2.c:
```
int bye()
{
  return 1;
}
```
La CMakeLists.txt fichier est de créer deux bibliothèques, puis de créer une bibliothèque combinée ressemble:
```
project(test)

    add_library(lib1 STATIC test1.c)
    add_library(lib2 STATIC test2.c)

    add_custom_target(combined ALL
      COMMAND ${CMAKE_AR} rc libcombined.a $<TARGET_FILE:lib1> $<TARGET_FILE:lib2>)
```
Les options de la ar commande dépend de la plateforme, dans ce cas, bien que la CMAKE_AR variable est indépendant de la plateforme. Je vais fouiner pour voir si il ya une façon plus générale pour ce faire, mais cette approche fonctionne sur les systèmes qui utilisent ar.

Basé sur Comment puis-je configurer les options de CMAKE_AR?, il semble que la meilleure façon de le faire serait:
```
add_custom_target(combined ALL
   COMMAND ${CMAKE_CXX_ARCHIVE_CREATE} libcombined.a $<TARGET_FILE:lib1> $<TARGET_FILE:lib2>)
```
Cela devrait être indépendant de la plateforme, parce que c'est la structure de commande utilisée pour créer des archives en interne par CMake. À condition bien sûr les seules options que vous souhaitez passer votre commande archive sont rc comme ceux-ci sont programmés dans les CMake pour la ar commande.
- Merci, la façon de le faire sur Windows pour ajouter une commande personnalisée "lib.exe entrée /SORTIE:combiné.lib 1.lib 2.lib"
- Après l'utilisation de ce pour un peu, j'ai remarqué que le "ar" de la commande est très sommaire et produit combiné libs qui ne fonctionne pas, au moins dans certaines versions de gcc. Je pense que nous sommes juste mieux de ne pas essayer de lier statiquement de cette façon.
- Pour moi seule la add_custom_target de commande comme décrit d'abord travaillé.
- Pour le rendre totalement indépendant de la plateforme, le nom de fichier doit être le suivant: ${CMAKE_STATIC_LIBRARY_PREFIX}combined${CMAKE_STATIC_LIBRARY_SUFFIX}
InformationsquelleAutor tpg2114
8

J'aimerais améliorer les autres solutions en fournissant mon CMakeLists.txt fichier qui fonctionne réellement aussi en termes de construction de dépendances.

Solution abusant de CMake
```
cmake_minimum_required(VERSION 2.8)

add_library(lib1 test1.cpp)
add_library(lib2 test2.cpp)
include_directories(${CMAKE_CURRENT_DIR})
add_executable(mainexec main.cpp)
target_link_libraries(mainexec combinedLib)  # Important to place before add_custom_target

set(LIBNAME "combinedLib.lib")

add_custom_command(
    OUTPUT ${LIBNAME}
    COMMAND lib.exe /OUT:${LIBNAME} $<TARGET_FILE:lib1> $<TARGET_FILE:lib2>
    DEPENDS lib1 lib2
    COMMENT "Combining libs..."
)

add_custom_target(combinedLib
    DEPENDS ${LIBNAME}
)
```
Noter que cette solution fonctionne tellement bien avec Visual Studio, mais je pense que ça peut être fait multi-plateforme compatible. J'imagine que la version suivante pourrait fonctionner pour les plateformes Unix:
```
set(LIBNAME "libCombinedLib.a")

add_custom_command(
    OUTPUT ${LIBNAME}
    COMMAND ar -rcT ${LIBNAME} $<TARGET_FILE:lib1> $<TARGET_FILE:lib2>
    DEPENDS lib1 lib2
    COMMENT "Combining libs..."
)
```
Noter que ces solutions en quelque sorte une mauvaise utilisation de CMake comme il allait se plaindre au sujet d'une cible de type UTILITAIRE (au lieu de STATIQUE ou PARTAGÉ) si vous placez le target_link_libraries l'appel après l' add_custom_target déclaration.

CMake la cible de la déclaration de solution conforme

À faire CMake conforme, vous pouvez remplacer le "target_link_libraries' appel par
```
target_link_libraries(mainexec ${LIBNAME})
add_dependencies(mainexec combinedLib)
```
Dans mon cas, il n'est pas entièrement satisfaisante, car mainexec a à savoir sur combinedLib bien qu'il s'attend que toutes les dépendances soient traitées par le target_link_libraries appel.

Solution Alternative avec moins de couplage

Regardant un peu plus loin vers importé des objectifs, j'ai finalement trouvé une solution qui résout mon dernier problème:
```
cmake_minimum_required(VERSION 2.8)

add_library(lib1 test1.cpp)
add_library(lib2 test2.cpp)
include_directories(${CMAKE_CURRENT_DIR})
add_executable(mainexec main.cpp)

set(LIBNAME "combinedLib.lib")

add_custom_command(
    OUTPUT ${LIBNAME}
    COMMAND lib.exe /OUT:${LIBNAME} $<TARGET_FILE:lib1> $<TARGET_FILE:lib2>
    DEPENDS lib1 lib2
    COMMENT "Combining libs..."
)

add_custom_target(combinedLibGenerator
    DEPENDS ${LIBNAME}
)

add_library(combinedLib STATIC IMPORTED)
set_property(TARGET combinedLib PROPERTY IMPORTED_LOCATION ${LIBNAME})
add_dependencies(combinedLib combinedLibGenerator)

target_link_libraries(mainexec combinedLib)
```
Si vous avez l'intention de modulariser l'ensemble de l'ajouter GLOBAL après STATIC IMPORTED pour faire la cible importé monde visible.

Portable CMake solution

Avec le courant de CMake versions CMake fournit un support complet pour les dépendances transitives et les bibliothèques d'interface. Une bibliothèque d'interface peut alors "lien" contre d'autres bibliothèques et cette interface de la bibliothèque peuvent, à leur tour, être "lié" à l'encontre. Pourquoi des guillemets? Bien que cela fonctionne bien, cela ne fait pas de créer un physique, bibliothèque combinée, mais crée plutôt une sorte d'alias pour l'ensemble de "sous-libs". Encore c'était la solution que nous avons éventuellement nécessaires, c'est pourquoi j'ai voulu l'ajouter ici.
```
add_library(combinedLib INTERFACE)
target_link_libraries(combinedLib INTERFACE lib1 lib2)

target_link_libraries(mainexec combinedLib)
```
Que c'est!

InformationsquelleAutor Roland Sarrazin

Vous devez vous connecter pour publier un commentaire.

test1.c:

test2.c: