I have a repository with 2 Projects, which both link a single (self-made) library which is also contained in the repository. I also include some dependencies, which both projects use.
The project structure is as follows:
repo/
├─ dependencies/
│ ├─ audeo/
│ ├─ argparse/
│ ├─ json
├─ my-library/
│ ├─ CMakeLists.txt
│ ├─ ...
├─ projet2/
│ ├─ CMakeLists.txt
│ ├─ ...
├─ projet1/
│ ├─ CMakeLists.txt
│ ├─ ...
├─ CMakeLists.txt
I don't know how to utilize this. I already tried to set up a project, but I ran into numerous problems, which I don't want to further go into detail about.
My question is whether there are examples of this kind of project structure or if you have good practice advice, or if this problem has a common name that I can research.
Edit:
I will post my CMake files and the link to the current state of the source code (Disclaimer: the second project is not already included).
Content of repo/CMakeLists.txt:
cmake_minimum_required(VERSION 3.11)
project(root)
set(CMAKE_CXX_STANDARD 20)
# dependencies
add_subdirectory(dependencies/dep1)
add_subdirectory(dependencies/dep2)
add_subdirectory(dependencies/dep3)
# sub-projects
add_subdirectory(my-library)
add_subdirectory(project1)
add_subdirectory(project2)
Content of my-library/CMakeLists.txt:
cmake_minimum_required(VERSION 3.11)
project(my-library)
set(CMAKE_CXX_STANDARD 20)
add_library(my-library STATIC
src/World.cpp include/World.h
include/Player.h
include/Position.h
include/Audio/Effect.h
include/Audio/Music.h
include/Audio/Audio.h)
target_link_libraries(my-library PRIVATE
dep1::dep1
dep2::dep2)
Content of projet1/CMakeLists.txt:
cmake_minimum_required(VERSION 3.11)
project(project1)
set(CMAKE_CXX_STANDARD 20)
add_executable(project1 main.cpp)
target_link_libraries(project1 PRIVATE
dep1::dep1
dep3::dep3
)
Content of projet2/CMakeLists.txt:
cmake_minimum_required(VERSION 3.11)
project(project2)
set(CMAKE_CXX_STANDARD 20)
add_executable(project2 main.cpp)
target_link_libraries(project2 PRIVATE
dep2::dep2
)
Since my source code is open source anyway I will post the link to my repository. But please note that the names of the projects may differ as well as the structure.
Problem
My Problem is, that I cannot include one dependency (warning! this is a translation):
fatal error: dep1/dep1.hpp: file or directory not found
11 | #include <dep1/dep1.hpp>
And I want to be able to include my library in Angle-bracket form.
Related
I'm writing a C++ library which has the following structure:
my_project
├── include
├── lib
├── src
│ ├── sourceA.cpp
│ └── sourceB.cpp
├── test
│ ├── test.cpp
│ └── CMakeLists.txt
└── CMakeLists.txt
Now I have multiple questions:
How can I layout CMake files in a way so that I can build a test app that uses it from within the library? Here's what I've got so far:
test/CMakeLists.txt
cmake_minimum_required(VERSION 3.12)
project(supabase VERSION 0.2.0.0 LANGUAGES C CXX)
add_subdirectory(..)
add_executable(test test.cpp)
target_link_libraries(test PRIVATE mylib)
MakeLists.txt
add_library(mylib)
target_include_directories(mylib PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include");
But CMake complains that
directory "C:/dev/myproject" is not a subdirectory of "C:/dev/myproject/test"
So I could of course create a top level CMakeLists.txt that contains the project information and builds test.cpp. BUT: Of course don't want other developers to build the test routines when they just want to build the lib. Which leads me to question number..
Is there a standardised way to layout the project structure so that it satisfies the following requirements:
I can build testscripts from within library and use it at the same time
Other devs can just include my top level CMakeLists.txt and build the library without baggage.
What is best practice here?
I have a project with structure like this:
project/
├─ src/
│ ├─ main.cpp
│ ├─ CMakeLists.txt
├─ lib/
│ ├─ libapi.so
├─ CMakeLists.txt
├─ dep/
│ ├─ api/
│ │ ├─ api_types.h
In the main CMakeLists I have:
add_subdirectory(dep)
add_executable("my_${PROJECT_NAME}")
add_subdirectory(src)
And in CMakeLists inside src folder:
target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
add_library(api SHARED IMPORTED)
set_property(TARGET api PROPERTY IMPORTED_LOCATION "${CMAKE_SOURCE_DIR}/lib/libapi.so")
target_sources("my_${PROJECT_NAME}" PRIVATE main.cpp)
In main.cpp I do #include <api_types.h> but I get this error during compile:
api_types.h: No such file or directory
How can I fix it?
First - add_subdirectory in fact just looks for CMakeLists.txt in
the specified directory to apply the sub-set of the rules to the
parent project. If the specified folder doesn't contain any
CMakeLists.txt this command does nothing (i.e. the command
add_subdirectory(dep)).
Second - target_include_directories expects a target object to link against (not the project name). Assuming ${PROJECT_NAME} is not a name of any of your targets (and the code given in the question reveals only two targets my_${PROJECT_NAME} and api) the command target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}) does nothing sensible.
Last - you don't specify path to your actual headers anywhere. CMAKE_CURRENT_SOURCE_DIR refers to the current folder CMakeLists.txt is located in. You should specify path to the folder the headers are located in.
Putting all the said info together, the desired content for the top-level CMakeLists.txt should be something like that:
cmake_minimum_required(VERSION 3.20)
set(PROJECT_NAME Hello)
project(${PROJECT_NAME})
add_executable(my_${PROJECT_NAME})
add_subdirectory(src)
And for src's file it's apparently something like that:
target_include_directories(my_${PROJECT_NAME} PUBLIC ${PROJECT_SOURCE_DIR}/dep/api)
target_sources(my_${PROJECT_NAME} PRIVATE main.cpp)
This solution, however, doesn't resolve another mistake in your code - the CMake files you provided don't link the library itself to the executable target. However this is not the question asked, and with respect to the members of the community, I suggest referring to answers to another related question here.
target_include_directories requires your executable as target, in this case my_${PROJECT_NAME}.
You can try
target_include_directories(my_${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
As alternative I would recommend following structure
project/
├─ src/
│ ├─ main.cpp
├─ lib/
│ ├─ libapi.so
├─ CMakeLists.txt
├─ include/
│ ├─ api/
│ │ ├─ api_types.h
with following CMakeList.txt
add_executable(my_${PROJECT_NAME} src/main.cpp)
target_include_directories(my_${PROJECT_NAME} PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>)
link_directories(${CMAKE_SOURCE_DIR}/lib)
target_link_libraries(my_${PROJECT_NAME} libapi)
I have a project where I need to run one application on multiple boards. To do this I have two exectuables that share a main.c, but are compiled with a different board.c. The directory tree is as follows:
CMakeLists.txt
src/
├─ board/
│ ├─ board_a/
│ │ ├─ board.c
| | ├─ CMakeLists.txt
│ ├─ board_b/
│ │ ├─ board.c
| | ├─ CMakeLists.txt
├─ app/
│ ├─ main.c
├─ lib/
│ ├─ somelib/
│ │ ├─ somelib.h
│ │ ├─ somelib.c
In an attempt to make the root CMakeLists.txt smaller and more maintainable, I've created a CMakeLists.txt for both boards, and would like to compile each board as an object library for the main executable in the root CMakeLists.txt to add_subdirectory on and link in.
My problem is that board.c (as well as main.c) depends on somelib. How can I add this dependency to the subdirectory CMakeLists.txt? Is there a way I can do that without hard-coding a path to somelib? My feeling is that I should create a CMakeLists.txt in somelib, and I feel this would be easy if I were handling the library linking from the root CMakeLists.txt, but my confusion is that board is adjacent to lib. I'm relatively new to CMake and am not sure how to best structure these dependencies.
My problem is that board.c (as well as main.c) depends on somelib. How can I add this dependency to the subdirectory CMakeLists.txt? Is there a way I can do that without hard-coding a path to somelib? My feeling is that I should create a CMakeLists.txt in somelib, and I feel this would be easy if I were handling the library linking from the root CMakeLists.txt, but my confusion is that board is adjacent to lib. I'm relatively new to CMake and am not sure how to best structure these dependencies.
This is very straightforward start by linking each board_<X> to somelib's target.
# in each board_<X>/CMakeLists.txt
add_library(board_<X> OBJECT ...)
target_link_libraries(board_<X> PUBLIC proj::somelib)
then create the target for somelib:
# src/lib/somelib/CMakeLists.txt
add_library(somelib somelib.c)
add_library(proj::somelib ALIAS somelib)
target_include_directories(
somelib PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>")
As long as the top-level CMakeLists.txt includes these subdirectories via add_subdirectory (multiple levels is fine), then other targets can #include <somelib.h> and CMake will handle linking.
I have the following project structure:
project/
├─ CMakeLists.txt
├─ src/
├─ libraries/
│ ├─ directxtk/
│ │ ├─ CMakeLists.txt
│ ├─ zlib/
│ │ ├─ CMakeLists.txt
project/CMakeLists.txt is my main executable. I want to utilize zlib in it.
In this CMakeLists.txt, i have the following lines:
target_include_directories(Project PUBLIC ${EXTERNAL_HEADERS_DIR})
add_subdirectory("${LINK_LIBRARY_DIR}/zlib")
add_subdirectory("${LINK_LIBRARY_DIR}/directxtk")
target_link_libraries(Project LINK_PUBLIC zlib)
target_link_libraries(Project LINK_PUBLIC DirectXTK)
EXTERNAL_HEADERS_DIR and LINK_LIBRARY_DIR both point to Project/Libraries.
I include zlib the following way: #include <zlib/zlib.h>
When I try to build and run now, I receive the following compile error:
...\Project\Libraries\zlib/zlib.h(34): fatal error C1083: Cannot open include file: 'zconf.h': No such file or directory
apparently, CMake seems to rename zconf.h to zconf.h.included!?
How can I properly build this whole thing?
Edit: I have copy&paste'd zlib/CMakeLists.txt from the public website of zlib
I'm trying to learn CMake, but I can't get to grips with the tutorials that are available.
Let's say my project has the structure below, and I want to make my_lib available through its CMakeLists file and use it in my main.cpp, what would my CMakeLists files look like?
├── CMakeLists.txt
├── externals
│ └── my_lib
│ └── src
│ ├── CMakeLists.txt
│ ├── MyClass.h
│ └── MyClass.cpp
└── main.cpp
Should I use include_directories or add_subdirectory?
To match the directory structure you indicated, your CMakeLists.txt files could look like this:
/CMakeLists.txt:
cmake_minimum_required(VERSION 3.0)
project(Main)
add_subdirectory(externals/my_lib/src)
add_executable(my_main main.cpp)
target_link_libraries(my_main my_lib)
/externals/my_lib/src/CMakeLists.txt:
cmake_minimum_required(VERSION 3.0)
project(MyLib)
add_library(my_lib MyClass.cpp MyClass.h)
target_include_directories(my_lib PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
Using PUBLIC in the target_include_directories call means that not only does your library have this as an "include path", but so does any target linking to it.
The downside with this setup however is that you're also going to expose any internal headers of my_lib to consuming targets too. Say you also have an "Internal.h" as part of my_lib which you don't want to expose. You can do this by moving the intentionally-public headers into a separate folder, e.g. "include":
├── CMakeLists.txt
├── externals
│ └── my_lib
│ ├── CMakeLists.txt
│ ├── include
│ │ └── MyClass.h
│ └── src
│ ├── Internal.h
│ └── MyClass.cpp
└── main.cpp
Your top-level CMakeLists.txt wouldn't change, but /externals/my_lib/CMakeLists.txt (which has moved up a level) now reads:
cmake_minimum_required(VERSION 3.0)
project(MyLib)
add_library(my_lib src/MyClass.cpp src/Internal.h include/MyClass.h)
target_include_directories(my_lib
PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
)
Now, since your library's "src" folder is PRIVATE to my_lib, main.cpp won't be able to #include "Internal.h".