Usamos CMake para gerar os arquivos do Visual Studio de nossas fontes em nosso SVN. Agora minha ferramenta requer que alguns arquivos DLL estejam na mesma pasta que o executável. Os arquivos DLL estão em uma pasta ao lado da fonte.

Como posso alterar o meu de CMakeLists.txtmodo que o projeto do Visual Studio gerado já tenha os arquivos DLL específicos nas pastas de liberação / depuração ou os copie durante a compilação?

Eu usaria add_custom_commandpara conseguir isso junto com cmake -E copy_if_different.... Para informações completas, corra

cmake --help-command add_custom_command
cmake -E

Portanto, no seu caso, se você tiver a seguinte estrutura de diretório:

/CMakeLists.txt
/src
/libs/test.dll

e seu destino CMake ao qual o comando se aplica é MyTest, então você pode adicionar o seguinte ao seu CMakeLists.txt:

add_custom_command(TARGET MyTest POST_BUILD        # Adds a post-build event to MyTest
    COMMAND ${CMAKE_COMMAND} -E copy_if_different  # which executes "cmake - E copy_if_different..."
        "${PROJECT_SOURCE_DIR}/libs/test.dll"      # <--this is in-file
        $<TARGET_FILE_DIR:MyTest>)                 # <--this is out-file path

Se você deseja apenas todo o conteúdo do /libs/diretório copiado, use cmake -E copy_directory:

add_custom_command(TARGET MyTest POST_BUILD
    COMMAND ${CMAKE_COMMAND} -E copy_directory
        "${PROJECT_SOURCE_DIR}/libs"
        $<TARGET_FILE_DIR:MyTest>)

Se você precisar copiar dlls diferentes dependendo da configuração (Release, Debug, por exemplo), você pode tê-los em subdiretórios nomeados com a configuração correspondente:, /libs/Releasee /libs/Debug. Em seguida, você precisa injetar o tipo de configuração no caminho para a dll na add_custom_commandchamada, assim:

add_custom_command(TARGET MyTest POST_BUILD
    COMMAND ${CMAKE_COMMAND} -E copy_directory
        "${PROJECT_SOURCE_DIR}/libs/$<CONFIGURATION>"
        $<TARGET_FILE_DIR:MyTest>)

Coloquei essas linhas em meu arquivo CMakeLists.txt de nível superior. Todas as bibliotecas e executáveis ​​compilados pelo CMake serão colocados no nível superior do diretório de compilação para que os executáveis ​​possam encontrar as bibliotecas e seja fácil executar tudo.

set (CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})

Observe que isso não resolve o problema do OP de copiar binários pré-compilados do diretório de origem do projeto.

Tive esse problema hoje quando tentei fazer uma compilação do meu programa para Windows. E acabei fazendo algumas pesquisas sozinho, uma vez que todas essas respostas não me satisfizeram. Havia três problemas principais:

• Queria que compilações de depuração fossem vinculadas a versões de depuração de bibliotecas e compilações de lançamento fossem vinculadas a compilações de lançamento de bibliotecas, respectivamente.

• Além disso, eu queria que as versões corretas dos arquivos DLL (Debug / Release) fossem copiadas para os diretórios de saída.

• E eu queria conseguir tudo isso sem escrever scripts complexos e frágeis.

Depois de navegar alguns manuais do CMake e alguns projetos multiplataforma no github, encontrei esta solução:

Declare sua biblioteca como um destino com o atributo "IMPORTED", faça referência a sua depuração e libere os arquivos .lib e .dll.

add_library(sdl2 SHARED IMPORTED GLOBAL)
set_property(TARGET sdl2 PROPERTY IMPORTED_IMPLIB_RELEASE "${SDL_ROOT_PATH}/lib/SDL2.lib")
set_property(TARGET sdl2 PROPERTY IMPORTED_LOCATION_RELEASE "${SDL_ROOT_PATH}/bin/SDL2.dll")
set_property(TARGET sdl2 PROPERTY IMPORTED_IMPLIB_DEBUG "${SDL_ROOT_PATH}/lib/SDL2d.lib")
set_property(TARGET sdl2 PROPERTY IMPORTED_LOCATION_DEBUG "${SDL_ROOT_PATH}/bin/SDL2d.dll")

Vincule este destino ao seu projeto como de costume

target_link_libraries(YourProg sdl2 ...)

Faça uma etapa de compilação personalizada para copiar o arquivo dll para seu destino se ele tiver sido alterado de alguma forma desde a compilação anterior

add_custom_command ( TARGET YourProg POST_BUILD
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
    $<TARGET_FILE:sdl2> $<TARGET_FILE_DIR:YourProg>
)

Um adendo à resposta aceita, adicionado como uma resposta separada para obter a formatação do código:

Se você estiver construindo suas dlls no mesmo projeto, elas geralmente estarão nos diretórios Release, Debug, etc. Você terá que usar as variáveis ​​de ambiente do Visual Studio para copiá-las corretamente. por exemplo:

"${PROJECT_BINARY_DIR}/your_library/\$\(Configuration\)/your_library.dll"

para a fonte e

"${CMAKE_CURRENT_BINARY_DIR}/\$\(Configuration\)/your_library.dll"

para o destino. Observe o escape!

Você não pode usar a variável CMake CMAKE_BUILD_TYPE para a configuração, pois ela é resolvida no momento da geração do projeto VS e sempre será o padrão.

Você também pode usar o comando find_library:

find_library(<some_var> NAMES <name_of_lib> PATHS "<path/to/lib>")

Com um EXECUTABLE_PATH definido, por exemplo:

set(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)

você pode mover os arquivos .dll de que seu executável precisa, com

file(COPY ${<some_var>}
    DESTINATION ${EXECUTABLE_OUTPUT_PATH})

Isso é útil para um deles

SET(CMAKE_ARCHIVE_OUTPUT_DIRECTORY
    ${PROJECT_SOURCE_DIR}/lib CACHE
    PATH "Directory where all the .lib files are dumped." FORCE)
SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY
    ${PROJECT_SOURCE_DIR}/bin CACHE
    PATH "Directory where .exe and .dll files are dumped." FORCE)

Você provavelmente precisará adicionar um destino personalizado e torná-lo dependente de um de seus destinos executáveis.

Para copiar o arquivo usando a função acima, use:

COMMAND ${CMAKE_PROGRAM} -E copy_if_different ${CMAKE_BINARY_DIR}/path/to/file.dll ${CMAKE_BINARY_DIR}/where/to/put/file.dll`

Sou um iniciante em CMake, mas ainda assim queria compartilhar minha experiência. No meu caso, eu precisava de uma cópia pós-instalação para que todos os meus binários estivessem dentro. No caso de binários de terceiros que podem ser importados dentro do CMake, o seguinte funciona para mim:

find_package( dependency REQUIRED )
if( MSVC ) 
    # If done properly and if the dependency has a correct config file, IMPORTED_LOCATION_RELEASE should be defined
    get_target_property( DEP_SHARED_LIB_PATH dependency IMPORTED_LOCATION_RELEASE )
    # Create a bin directory in the install folder
    add_custom_command(TARGET BGS POST_BUILD COMMAND ${CMAKE_COMMAND} -E make_directory  ${CMAKE_INSTALL_PREFIX}/bin/)
    # Copy the shared lib file
    add_custom_command(TARGET BGS POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${DEP_SHARED_LIB_PATH} ${CMAKE_INSTALL_PREFIX}/bin/)
endif()

Obviamente, IMPORTED_LOCATION_RELEASE pode ter variantes, dependendo de como a biblioteca compartilhada foi construída / instalada. Pode ser IMPORTED_LOCATION_DEBUG.

Talvez haja uma maneira melhor de obter esse nome de propriedade, não sei.

Movendo arquivos durante a construção usando install

Tive esse problema ao tentar seguir o tutorial oficial do CMake na Etapa 9 . Este era o local do arquivo que eu queria mover:

src
 |_build
    |_Debug
       - `MathFunctions.dll`

Este era o local onde eu queria que o arquivo estivesse:

src
 |_build
    |_install
         |_bin
             - `MathFunctions.dll`

Uma vez que esta DLL foi gerado como uma biblioteca compartilhada, tudo o que fiz foi a de incluir esta linha no CMakeLists.txtno subdiretório que continha o código fonte para a bibliotecasrc/Mathfunctions/CMakeLists.txt

install(FILES ${PROJECT_BINARY_DIR}/$<CONFIG>/MathFunctions.dll
DESTINATION bin)

Graças às suas respostas, pude pensar sobre este. É apenas uma linha, então acho que está tudo bem. O $<CONFIG>pode ter dois valores Debug ou Release Dependendo de como o projeto é construído, conforme a pergunta original exigia.