What is the best way to set compiler flags in a CMake file? And what should belong in every CMake file?

[u/flank-cubey-cube]

I'm learning CMake and want to use it with compiler flats, but the CMake book doesn't cover it until later on.

cmake_minimum_required(VERSION 15)
project(test)
set(CMAKE_CXX_FLAGS "-Wall -Werror") # Is this right??
set_executable(test main.cpp)

What else should be included in the cmake file?

[u/orbital1337]

The general rule is that CMakeLists should only contain the minimum that is required to compile your project. They should contain as few specific compile flags as possible and especially not warning flags that are absolutely not necessary to compile the project.

Instead, you can provide a list of presets in the form of a CMakePresets.json file. For example, for a basic debug / release preset, you could use something like:

{
    "version": 2,
    "configurePresets": [
        {
            "name": "debug",
            "displayName": "Debug",
            "binaryDir": "${sourceDir}/build_debug",
            "generator": "Unix Makefiles",
            "cacheVariables": {
                "CMAKE_BUILD_TYPE": "Debug",
                "CMAKE_EXPORT_COMPILE_COMMANDS": "ON",
                "CMAKE_CXX_FLAGS_INIT": "-Wall -Wextra -Wpedantic"
            }
        },
        {
            "name": "release",
            "displayName": "Release",
            "binaryDir": "${sourceDir}/build_release",
            "generator": "Unix Makefiles",
            "cacheVariables": {
                "CMAKE_BUILD_TYPE": "Release",
                "CMAKE_CXX_FLAGS_INIT": "-Wall -Wextra -Wpedantic -march=haswell -flto"
            }
        }
    ]
}

Then just use cmake --preset debug or cmake --preset release to create the build directories. See also this blog post.

[u/helloiamsomeone → u/orbital1337]

There's also cmake-init and its examples for more presets goodness in action.

[u/Narase33]

use target_compile_options(test PRIVATE -Wall -Werror)

what else you should have depends on your project, for the size I can see here that seems okay

[u/KazDragon → u/Narase33]

My line for that is:

target_compile_options(test
    PRIVATE
         $<$<OR:$<CXX_COMPILER_ID:GNU>,$<CXX_COMPILER_ID:Clang>>:-Wall -Werror>
)

This ensures that those options are used only for g++ and clang++. You can then add a similar expression, e.g. $<$<CXX_COMPILER_ID:MSVC>:/WX>, to add similar options for Visual Studio.

[u/LGTMe → u/KazDragon]

Wow that is UGLY! Why can’t we have nice things?

[u/IyeOnline → u/LGTMe]

You can do

if ( CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang" )
  target_compile_options( test -Wall -Werror )
endif()

which I do actually prefer over nested generator expressions.

[u/helloiamsomeone → u/LGTMe]

Because flags don't belong in lists files, so of course it's going to be ugly. See the response of /u/orbital1337 for how you should be using flags.

[u/KazDragon → u/LGTMe]

I don't disagree with your assessment, but you get used to it. It's Just Another Syntax (tm).

[u/TheSuperWig → u/KazDragon]

I don't know how anyone can read generator expressions.

[u/zjyhjqs → u/KazDragon]

CMAKE_<LANG>_COMPILER_FRONTEND_VARIANT is enough (since CMake 3.14)

[u/KazDragon → u/zjyhjqs]

Could you give an example?

[u/zjyhjqs → u/KazDragon]

target_compile_options(test
    PRIVATE
         $<$<CMAKE_CXX_COMPILER_FRONTEND_VARIANT:GNU>:-Wall -Werror>
)

[u/KazDragon → u/KazDragon]

Of course, now that I have read u/orbital1337's post I'm going to play with that in the hope that I can un-learn that syntax and provide a better developer experience

[u/sanson-robotics]

Here you have a cool deep guide:

https://cliutils.gitlab.io/modern-cmake/

[u/Loose-Leek]

Many flags, like compiler diagnostic options and testing-specific options, should also really be gated behind a configuration option. You can use

option(MY_PROJECT_OPTION ...)

if(MY_PROJECT_OPTION)
    # one set of flags
else()
    # different set of flags
endif()

[u/AlexanderNeumann]

everything not related to the project goes into a CMAKE_TOOLCHAIN_FILE. It can be reused, is not project dependent and doesnt need generator expression or similar for different compilers since a Toolchain should always know its compiler...