How to structure CMake projects - cmake

Question

I started using CMake but am not sure how to use it in the following setup.
I have some library-cmake-projects (source code), which might depend on each other.
Libs
-A
-B
-C
(Lets say A depends on C and B depends on C)
How to make cmake be aware of the needed modules in the other directories?

Answer 1

With regards to add_subdirectory, you should structure it like your source code is structured.
So, Let's say your folder structure looks like this:
/
-- App
-- libs
-- A
-- B
-- C
Then you would put CMakeLists.txt like this:
/
-- CMakeLists.txt
-- App
-- CMakeLists.txt
-- libs
-- CMakeLists.txt
-- A
-- CMakeLsts.txt
-- B
-- CMakeLists.txt
-- C
-- CMakeLists.txt
/CMakeLists.txt
add_subdirectory(App)
add_subdirectory(libs)
/App/CMakeLists.txt
add_executable(App ...)
target_link_libraries(App A B)
/libs/CMakeLists.txt
add_subdirectory(A)
add_subdirectory(B)
add_subdirectory(C)
/libs/A/CMakeListst.txt
add_library(A ...)
target_link_libraries(A C)
/libs/B/CMakeListst.txt
add_library(B ...)
target_link_libraries(B C)
/libs/C/CMakeListst.txt
add_library(C ...)
It's not good to think about add_subdirectory as having anything to with dependency management, it is about how your source and build files are organized. It also has scoping, but most of the time you don't need to worry about it. You don't necessarily need the /libs/CMakelists.txt if you directly put all three add_subdirectory calls in the top-level CMakeLists.txt but it can help with organizing.
I would refrain from using add_subdirectory to include a neighboring folder, for example. Assume the target is there and include from somewhere higher up.
Note that this is what I would recommend in general because it seems to be what the designers had in mind, but if you need something else for some reason, or have different opinion about what is correct design, then feel free to structure it differently.

Answer 2

Is add_subdirectory the correct way to do this?
No, add_subdirectory() is used to traverse to other CMakeLists.txt files within your CMake project. It doesn't specify dependencies. In modern CMake, you really only need target_link_libraries to specify dependencies, as suggested in this answer.
How to add C to A to make this build in one call possible?
I do not want to add C directly to App.
You can make A depend on C by linking the previously-defined target C to A
add_library(C SHARED ... )
...
add_library(A SHARED ... )
target_link_libraries(A PUBLIC C)
Note, the use of PUBLIC here ensures C is added to the link interface of A, so it will be propagated to consuming targets. Now, when you link A to App, you will get C along with it, and there is no need to specify C explicitly.
# Link A (and C) to App.
target_link_libraries(App PRIVATE A)
How to handle the case that App also depends on B? With add_subdirectory and no caution this would try to define C twice. Are include guards the correct solution?
In my experience, this hasn't been an issue, and the linker was able to figure out the duplicated linked C library. If it does become an issue, you can simply make the scope of the B dependency PRIVATE. This way, C will not be propagated to App through B:
target_link_libraries(B PRIVATE C)
...
target_link_libraries(App PRIVATE B A)
I encourage you to read through the linked target_link_libraries() documentation, which has many examples for recommended CMake usage with these types of dependencies.