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)
Related
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.
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've created a static library using CMake and I'm installing the public headers in /usr/local/include/. The library and its tests compile fine on their own, but when using the library in another project I get an error:
/usr/local/include/weftworks/common/network/tcp/acceptor.hpp:28:10: fatal error: utility.hpp: No such file or directory
#include "utility.hpp"
where both acceptor.hpp and utility.hpp are public headers.
This is the related folder structure:
root/
├ cmake/
├ external/
├ library/
│ ├─ include/
│ │ ├─ network/
│ │ │ └─ tcp/
│ │ │ └─ acceptor.hpp
│ │ └─ utility.hpp
│ ├─ src/
│ └─ CMakeLists.txt
├ test/
└ CMakeLists.txt
./library/CMakeLists.txt:
# ./library/CMakeLists.txt
# Required CMake version
cmake_minimum_required(VERSION 3.13)
include(GNUInstallDirs)
# Project details
project(
weftworks-common-library
VERSION 0.4.0
DESCRIPTION "Internal Weftworks Common Library project."
)
# Library target sources
list(APPEND WEFTWORKS_COMMON_LIBRARY_PRIVATE_SOURCES)
list(APPEND WEFTWORKS_COMMON_LIBRARY_PUBLIC_SOURCES)
list(APPEND WEFTWORKS_COMMON_LIBRARY_INTERFACE_SOURCES)
include(src/CMakeLists.txt)
# A static library target
add_library(weftworks-common-library STATIC)
# Required compiler features
target_compile_features(
weftworks-common-library
PUBLIC
cxx_auto_type
cxx_constexpr
cxx_defaulted_functions
cxx_deleted_functions
cxx_final
cxx_lambdas
cxx_noexcept
cxx_override
cxx_range_for
cxx_static_assert
cxx_std_17
cxx_strong_enums
cxx_trailing_return_types
cxx_uniform_initialization
cxx_variadic_macros
)
target_compile_options(
weftworks-common-library
PRIVATE
-Wall
-Wextra
-pedantic
)
target_include_directories(
weftworks-common-library
PUBLIC
"$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
"$<INSTALL_INTERFACE:include>"
)
target_link_libraries(
weftworks-common-library
PUBLIC
Boost::boost
Boost::system
Boost::program_options
spdlog::spdlog
Threads::Threads
)
target_sources(
weftworks-common-library
PUBLIC ${WEFTWORKS_COMMON_LIBRARY_PUBLIC_SOURCES}
INTERFACE ${WEFTWORKS_COMMON_LIBRARY_INTERFACE_SOURCES}
PRIVATE ${WEFTWORKS_COMMON_LIBRARY_PRIVATE_SOURCES}
)
# Create alias target
add_library(weftworks::common-library ALIAS weftworks-common-library)
# Install library target
install(
TARGETS weftworks-common-library
EXPORT weftworks-common-library-config
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
)
install(
EXPORT weftworks-common-library-config
NAMESPACE weftworks::
DESTINATION ${CMAKE_INSTALL_LIBDIR}/weftworks/common-library
)
# Install public headers
install(
DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/include/
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/weftworks/common
)
Now I don't know what I need to do to make this work. I'd like to avoid having the "library prefix" in the project structure i.e. library/include/weftworks/common/ to keep it simple.
You need to include "weftworks/common/network/utility.hpp".
This will also ensure that you actually include your header not some other header which someone has written with the very generic name "utility.hpp".
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".