Define preprocessor macro through CMake?

How do I define a preprocessor variable through CMake?

The equivalent code would be #define foo.

For a long time, CMake had the add_definitions command for this purpose. However, recently the command has been superseded by a more fine grained approach (separate commands for compile definitions, include directories, and compiler options).

An example using the new add_compile_definitions:

add_compile_definitions(OPENCV_VERSION=${OpenCV_VERSION})
add_compile_definitions(WITH_OPENCV2)

Or:

add_compile_definitions(OPENCV_VERSION=${OpenCV_VERSION} WITH_OPENCV2)

The good part about this is that it circumvents the shabby trickery CMake has in place for add_definitions. CMake is such a shabby system, but they are finally finding some sanity.

Find more explanation on which commands to use for compiler flags here: https://cmake.org/cmake/help/latest/command/add_definitions.html

Likewise, you can do this per-target as explained in Jim Hunziker's answer.

To do this for a specific target, you can do the following:

target_compile_definitions(my_target PRIVATE FOO=1 BAR=1)

You should do this if you have more than one target that you're building and you don't want them all to use the same flags. Also see the official documentation on target_compile_definitions.

> The other solutions proposed on this page are useful for some versions of Cmake > 3.3.2. Here the solution for the version I am using (i.e., 3.3.2). Check the version of your Cmake by using $ cmake --version and pick the solution that fits your needs. The cmake documentation can be found on the official page.

With CMake version 3.3.2, in order to create

#define foo

I needed to use:

add_definitions(-Dfoo)   # <--------HERE THE NEW CMAKE LINE inside CMakeLists.txt
add_executable( ....)
target_link_libraries(....)

and, in order to have a preprocessor macro definition like this other one:

#define foo=5

the line is so modified:

add_definitions(-Dfoo=5)   # <--------HERE THE NEW CMAKE LINE inside CMakeLists.txt
add_executable( ....)
target_link_libraries(....)

PLEASE NOTE (as @squareskittles suggests in one of the comment): "if you are using CMake 3.3.2, you have to use add_definitions() or target_compile_definitions(). The more modern command, add_compile_definitions(), was not added until CMake 3.12."

i'd like to recommend use target_*** operations instead of add_*** operations when your solution include many projects.

1.) target_compile_definitions

If you are using CMake 3.X your first choice for adding a preprocessor macro should be target_compile_definitions.

The reason you should prefer this approach over any other approach is because it granularity is target based. IE the macro will only be added to your exe/library.

Here is a common example:

if (WIN32)
    target_compile_definitions(my_lib PRIVATE	
       # Prevents Windows.h from adding unnecessary includes	
       WIN32_LEAN_AND_MEAN	
       # Prevents Windows.h from defining min/max as macros	
       NOMINMAX	
    )	
endif()	

2.) add_compile_definitions

New in version 3.12.

Find more explanation on which commands to use for compiler flags here: https://cmake.org/cmake/help/latest/command/add_definitions.html

add_compile_definitions applies macros to any targets that are defined after the call.

Here is the same logic as above with add_compile_definitions.

add_compile_definitions(WIN32_LEAN_AND_MEAN NOMINMAX)
add_library(my_lib)

If you use this approach be careful if you are the top level project. Otherwise if users consume your library using add_subdirectory they may have issues.

3.) The other less recommended ways

These approaches really aren't recommended anymore. Due to not being modular, not scaling well, not supporting generator expressions, etc.

• add_definitions
• CMAKE_LANG_FLAGS

Why is target_compile_definitions better/preferred?

• It's much more clear to readers of your CMake code how it works.
• Allows usage of PRIVATE/PUBLIC/INTERFACE if needed. Which can make life easier for consumers of your library.
• It's much more modular.

Applying pre-processor flags (Or any compiler flag) globally can create hidden dependencies in your build.

Essentially think of add_compile_definitions as globals in C/C++. Sometimes you need them, but be careful.

here is an example where you can pass values from CMAKE to C++ code. Say, you want to pass:

• flag, here: BOOST ("true" or "false")
• software version string (e.g.: "1.0.0")

I recommend to pass them as strings. So, when you build software with CMAKE, you can pass parameters like for example if it was built using boost library, software version pulled from CMAKE variable (so that you change that number only in one place) See below.

In CMakeLists.txt:

add_compile_definitions( BOOST="${BOOST}" Software_VERSION="${PROJECT_VERSION}" )

In your .cpp code:

std::cout << "Software version is: " << Software_VERSION << " BOOST: " << BOOST << "\n";

Hope this helps. Regards.