programar - ¿Cómo puedo construir un proyecto de C++ con múltiples subdirectorios interdependientes?

codigos de c++ y sus funciones

Question

Tengo un proyecto de C ++ en el que he usado directorios como un elemento más de la organización, la forma en que uno podría usar paquetes en Java o directorios en PHP. Los directorios no pretenden ser elementos autosuficientes, sino simplemente una forma de organizar todo el proyecto y evitar que las fuentes lo abrumen. ¿Cómo puedo construir mis archivos CMakeLists.txt para manejar esto? Hacer las bibliotecas de directorios no parece encajar aquí, ya que todas son interdependientes y no están destinadas a ser utilizadas de esa manera.

Como cuestión relacionada, la mayoría de los ejemplos que he visto de múltiples subdirectorios en CMake (y no son muchos) han ignorado o pasado por alto el tema de establecer include_directories , que es algo con lo que he tenido problemas con . A falta de peinar mis archivos fuente para determinar qué archivo depende de qué directorio y en qué directorio, de todos modos hay que configurar todos los directorios en /src/ como potenciales incluir directorios y dejar que CMake determine cuáles son realmente dependientes.

Aquí hay una estructura de ejemplo:

--src
  --top1
    --mid1
      --bot1
        --src1.cpp
        --hdr1.h
      --bot2
        --src2.cpp
        --hdr2.h
    --mid2
      --bot3
        --src3.cpp
        --src4.cpp
        --hdr3.h
  --top2
    --mid3
      --src5.cpp
      --hdr4.h

Y así sucesivamente. ¿Cómo puedo estructurar mis archivos CMakeLists.txt para manejar este tipo de estructura?

Answer 1

No soy un experto en CMake, pero como no hay otras respuestas, echaré un vistazo al documental y lo probaré. Organizar fuentes e incluir archivos en diferentes directorios es prácticamente la norma.

Parece que CMake le permite proporcionar una lista de directorios de inclusión: http://www.cmake.org/cmake/help/cmake-2-8-docs.html#command:include_directories

Entonces algo así como:

include_directories("src/top1/mid1/bot1" "src/top1/mid1/bot2/" ... )

Estos se pasan al compilador para que pueda encontrar los archivos de encabezado y se pasarán para cada uno de los archivos fuente. Por lo tanto, cualquiera de sus archivos fuente debe poder incluir cualquiera de los archivos de encabezado (que creo que es lo que está pidiendo).

De manera similar, debería poder enumerar todos sus archivos fuente en el comando add_executable :

add_executable(name "src/top1/mid1/bot1/src1.cpp" "src/top1/id1/bot2/src2.cpp" ...)

Entonces esta sería una forma ingenua de hacer que todo se construya. Cada archivo fuente se compilará y buscará encabezados en todos esos directorios y luego los archivos del objeto se vincularán entre sí. Considere si hay alguna forma de simplificar esto, de modo que no necesite tantas carpetas de inclusión, quizás haya solo unos pocos archivos de encabezado comunes a los que todos los archivos fuente deban hacer referencia. Si las cosas se vuelven más complejas, puede crear sub-jerarquías en bibliotecas, etc. También considere separar los archivos fuente y los encabezados (por ejemplo, en src e incluir).

Answer 2

Dado que la estructura de directorios de su proyecto está ahí para mantener sus archivos organizados, un enfoque es tener un CMakeLists.txt que encuentre automáticamente todos los archivos de fuentes en el directorio src y también agregue todos los directorios como directorios de inclusión que tengan un archivo de encabezado en ellos . El siguiente archivo CMake puede servir como punto de partida:

cmake_minimum_required(VERSION 3.0)

project (Foo)

file(GLOB_RECURSE Foo_SOURCES "src/*.cpp")
file(GLOB_RECURSE Foo_HEADERS "src/*.h")

set (Foo_INCLUDE_DIRS "")
foreach (_headerFile ${Foo_HEADERS})
    get_filename_component(_dir ${_headerFile} PATH)
    list (APPEND Foo_INCLUDE_DIRS ${_dir})
endforeach()
list(REMOVE_DUPLICATES Foo_INCLUDE_DIRS)

add_executable (FooExe ${Foo_SOURCES})
target_include_directories(FooExe PRIVATE ${Foo_INCLUDE_DIRS})

Los dos file(GLOB_RECURSE ... comandos file(GLOB_RECURSE ... determinan el conjunto de archivos de origen y encabezado. El bucle foreach calcula el conjunto de directorios de inclusión de la lista de todos los archivos de encabezado.

Una desventaja de la computación del conjunto de archivos fuente es que CMake no detectará automáticamente cuando se agreguen nuevos archivos a su árbol fuente. Usted tiene que volver a crear manualmente sus archivos de compilación entonces.