Как установить cmake на windows

Картинка с сайта: terminalroot.com

CMake is a system to automate compilation tasks of code files created in C and C++.

On Unix type systems we can say that it is a “Makefile” generator. He is classified as a SCons.

We already made a brief introduction here on the blog about CMake, but it is also possible to generate Makefiles in Windows, although CMake also generates files for Visual Studio.

Today we will see how to install CMake on Windows.

Dependencies

As in this example we will use GCC, it is important that you have it installed on your Windows via MinGW, see here how to do it.

Now let’s go step by step!

Installation

01. Download CMake by clicking the button below:

Download CMake for Windows 64-bit

After downloading, double-click on the downloaded file: cmake-3.26.0-rc6-windows-x86_64.msi and give administrator permissions to start the installation setup.

02. Setup presentation

Just click on Next.

Картинка с сайта: terminalroot.com

03. Accept the license terms

And then click Next.

Картинка с сайта: terminalroot.com

04. Add CMake to your PATH

Check the Add CMake to the system PATH for all users option for the command to be available to all system users. And then click on Next.

Картинка с сайта: terminalroot.com

05. Select installation path

Hint: Keep what already appears and click Next.

Картинка с сайта: terminalroot.com

06. Start the installation

Click on Install and wait for the installation to finish.

Картинка с сайта: terminalroot.com

Installing:

Картинка с сайта: terminalroot.com

Once finished, click on Finish:

Картинка с сайта: terminalroot.com

Testing CMake

Open PowerShell or CMD and type the command:

cmake --version

If the output is similar to the image below, everything is right and installed perfectly:

Картинка с сайта: terminalroot.com

Compiling with CMake

• Create a folder, for example MyProject, enter it (by CMD or PowerShell, cd MyProject) and inside it do:

• Create a file named CMakeLists.txt with your Preferred Code Editor or IDE and fill it with the code below:

cmake_minimum_required(VERSION 3.10)
project(HelloWorld)
add_executable(hello main.cpp)

Картинка с сайта: terminalroot.com

• Also create a main.cpp file with a basic code, example:

#include <iostream>

auto main(int argc, char** argv) -> int {
   std::printf("CMake is working on Windows!\n");
   return EXIT_SUCCESS;
}

Картинка с сайта: terminalroot.com

At the end your MyProject folder will have 2 files: CMakeLists.txt and main.cpp as shown in the image below:

Картинка с сайта: terminalroot.com

• Now run the command:

cmake -G "Unix Makefiles" -B build

It will create a folder called build inside your project. If you don’t say -G "Unix Makefiles" it will prepare files for Visual Studio, in which case we want a Unix-like Makefile.

The output will be similar to the image below:

Картинка с сайта: terminalroot.com

• Once finished, enter the build folder (cd build) and run the make command (if this command does not exist, it is because you did not rename the MinGW file to that name as mentioned in the article about MinGW cited above, then most likely the command will be mingw32-make). And then run the final binary: hello:

Картинка с сайта: terminalroot.com

That’s it, now you can compile your C and C++ code with CMake!

Useful links

• https://cmake.org/
• https://cmake.org/download/
• https://github.com/Kitware/CMake/

cmake

windows

This article explains how CMake handles complex build processes. Earthly provides robust caching mechanisms to improve on CMake’s efficiency. Learn more about Earthly.

CMake is an open source multiplatform tool that you can use to help with build automation, testing, packaging, and the installation of software. One of the main advantages of CMake is that it supports generating build scripts for a wide variety of platforms including Windows, macOS, and Linux. This gives developers the flexibility they need when building a new project and hopefully helps speed up the build.

In this article, you’ll learn more about CMake and if it’s the right solution for you. You’ll also walk through the process of installing it on Windows.

Pros and Cons of CMake

Картинка с сайта: earthly.dev

There are a number of benefits to using CMake to help build your solutions, including the fact that CMake can run on all major platforms, including Windows, Linux, and macOS. This means that a team of developers who are using different operating systems can still have common development tools.

Using CMake for projects, instead of something like Visual Studio projects, helps you avoid being locked into one integrated development environment (IDE). A team can create a project using CMake, and then each developer can use their preferred IDE to work on it. CMake integration is supported by a variety of IDE tools, including CLion, Atom, and Visual Studio.

It may be useful for some developers and software architects to understand what dependencies are within their projects and the nature of the dependency. CMake can create a visualization of any dependencies within the project, that you can use to create documentation.

While many would assume that CMake’s active development is an advantage (which it is!), it also has its downsides: Not everyone within a developer team will be running the same version of CMake. However, to help reduce this issue, CMake has introduced policies that define how certain CMake features should behave. This means your team can set a common policy regardless of what version people are using.

Another disadvantage of CMake is the lack of information available for some versions. It can be hard to find accurate information to resolve an issue or answer a question.

When to Use CMake

As you can see, CMake can be a useful build system. Developers using CMake can quickly check performance on different build backends and easily move between them.

CMake can also help to keep your source code folder clean. It can separate the build system, intermediaries, and output files from the source code, keeping your code clean for the future.

Install CMake on Windows

There are several ways to install CMake on Windows. The first option is to use pre-compiled binaries as either the Windows Installer file (MSI) or the compressed version (ZIP) files. You just have to download the files and then walk through the interactive installation wizard.

The second option is to download and build CMake from the source, and CMake even includes a source release download option.

The third option is to use a package manager tool, such as Windows Package Manager or Chocolatey. This can be especially convenient if you already have either installed on your machine. We will use the package manager method you’ll use for your installation here.

If you’re using Windows Package Manager, run the following command to install CMake:

winget install kitware.cmake

If you’re using Chocolatey, use the following command:

Install a CMake Extension with Visual Studio

Once you’ve finished installing CMake on Windows, you need to install an extension that lets you integrate the functionality of CMake into your IDE (Visual Studio is used here).

To install the CMake extension, you need to select Start and then open the Visual Studio Installer from the menu:

Картинка с сайта: earthly.dev

Once the Visual Studio Installer loads, select Modify:

Картинка с сайта: earthly.dev

Under Workloads, locate Desktop development with C++, which can be found under Desktop & Mobile:

Картинка с сайта: earthly.dev

On this same page, you also need to find and select the Linux and embedded development with C++ component. This component ensures you have cross-platform CMake development capabilities:

Картинка с сайта: earthly.dev

Once you’ve selected both, select Modify again, and the additional tools will be installed.

Integrate an IDE

Now that you’ve installed CMake and a few components, it’s time to use them. Start a new project by opening Visual Studio and selecting Create a new project > CMake project:

Картинка с сайта: earthly.dev

After selecting CMake project, Visual Studio, and CMake will create a directory and a file called CMakeLists.txt, which is a set of instructions describing certain settings within the project, such as source files and targets.

When Visual Studio detects that there is a CMakeLists.txt file within a project that’s been opened, it adds CMake items to the Project menu, which gives you access to commands for viewing and editing CMake scripts:

Картинка с сайта: earthly.dev

Configure CMake Projects

CMake supports two files that let you specify build and test options. These files are CMakePresets.json and CMakeUserPresets.json. Microsoft recommends that you use CMakePresets.json.

To ensure that Visual Studio uses the CMakePresets.json file, you need to enable it. You can do so via Tools > Options > CMake > General. Please ensure that the Always use CMake Presets option is selected:

Картинка с сайта: earthly.dev

If Visual Studio can’t find a CMakePresets.json file, it will fall back to using the default configure presets.

There are three key settings within your CMakePresets.json file: target systems, configure presets, and build presets. The target system is the system on which CMake is invoked to configure and build your project. You can use systems installed on your local machine, SSH connections, and all Windows Subsystem for Linux (WSL) installations.

The configure preset option is used when CMake is invoked to generate the project build system. Depending on your target system, the options for this will change. So if you are using Ubuntu as your target system, your configure preset could be Linux debug.

The build preset value is used when CMake is invoked to build the project and should align with the configure preset. If Visual Studio can’t find any build presets that are associated with the configure preset, then it will provide the default build preset.

As you can see, there are a lot of options available to configure your CMake projects to suit your needs and project. If you’re looking for even more information on how to configure your projects, check out this Visual Studio documentation.

Build CMake Projects on Visual Studio

When you’re ready, Visual Studio gives you several options to build your CMake projects, including the toolbar or the Solution Explorer.

If you want to use the toolbar, you need to find the Startup Item drop-down:

Картинка с сайта: earthly.dev

Select your preferred target to build, and either press F5 or choose Run.

If you want to use the Solution Explorer, navigate to the Solution Explorer on the right-hand side of your screen. By default, it will be set to the Folder View:

Картинка с сайта: earthly.dev

You need to change the Folder View to the CMake Targets View. To do this, select the view icon:

Картинка с сайта: earthly.dev

Then select CMake Targets View:

Картинка с сайта: earthly.dev

Then right-click on CMake Target and select Build from the context menu:

Картинка с сайта: earthly.dev

Lastly, you can select Build > Build All from the main menu of Visual Studio to build your CMake project:

Картинка с сайта: earthly.dev

After completing either one of these options, you can find the build results within the Output window and Error List:

Картинка с сайта: earthly.dev

Debug CMake Projects

As you know, when writing code, it’s never perfect the first time, which is why you’ll need to be able to debug your code.

To debug your CMake project using Visual Studio, start by selecting one of the targets shown in the Startup Item drop-down within the toolbar:

Картинка с сайта: earthly.dev

Then select Debug > Start Debugging from the main toolbar:

Картинка с сайта: earthly.dev

If any changes have been made since the last time you built the project, the debug command will build it first before the debugging can take place.

The launch.vs.json file can be used to customize your CMake debugging session. This file can be used to input any environment variables or command line arguments that you might want to pass into the program during debugging.

Conclusion

CMake is a versatile tool that aids in build automation, testing, packaging, and software installation. It integrates with many IDEs, giving developers the flexibility to stick with their preferred IDE. It ensures your application’s compatibility across any platform. While CMake isn’t for everyone, it can be a robust solution for the right developer or project.

And if you’re looking to optimize your builds further, you might want to give Earthly a shot for its efficient caching and straightforward syntax.

To set up CMake on Windows, you can follow these general steps:

1. Download the CMake installer from the official website.
2. Run the installer and follow the on-screen instructions to install CMake on your computer.
3. Once the installation is complete, open a command prompt and type cmake —version to verify that CMake has been successfully installed.
4. To use CMake in your projects, create a CMakeLists.txt file in the root directory of your project and define your project configuration settings in this file.
5. Generate build files for your project by running cmake . in the command prompt from the directory where your CMakeLists.txt file is located.
6. Use the generated build files to compile and build your project using a build tool like Visual Studio or MinGW.
7. You can also set up a build directory to separate your source code from the build files by creating a new directory and running cmake path/to/source/code from that directory.
8. Modify the CMakeLists.txt file as needed to add dependencies, specify compiler flags, or configure other project settings.
9. Build your project by running the build tool (e.g. Visual Studio) using the generated build files.

What is CMake build directory on Windows?

The CMake build directory on Windows is the location where CMake generates the build system files (such as Makefiles or Visual Studio project files) and where the project is built by the selected build system. By default, CMake creates a directory called «build» in the root directory of the project to store these build files and build artifacts. However, the build directory can be customized using the CMake configuration options.

What is CMake generator in Windows?

CMake generator in Windows is a tool that allows CMake to generate native build configurations for different operating systems and build environments. It determines the type of project files that CMake will generate, such as Visual Studio solutions, makefiles, or Xcode projects. The generator specifies the build system to use when building the software. Some common CMake generators for Windows include Visual Studio, Ninja, and MinGW Makefiles.

How to specify output directories in CMake on Windows?

To specify output directories in CMake on Windows, you can use the SET command to define the output directory for the different types of build outputs, such as libraries, executables, and object files. Here’s an example of how you can specify output directories in CMake on Windows:

1
2
3
4
5
6
7
8

# Set the output directory for libraries
SET(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)

# Set the output directory for executables
SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)

# Set the output directory for object files
SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/obj)

You can customize the output directories based on your project’s structure and requirements by modifying the paths in the SET commands. Make sure to add this code to your CMakeLists.txt file before any other project settings or targets are defined. After adding these commands, CMake will generate project files that output the build results to the specified directories on Windows.

How to create CMakeLists.txt file in Windows?

To create a CMakeLists.txt file in Windows, you can follow these steps:

1. Open a text editor such as Notepad or Visual Studio Code.
2. Start by defining the minimum required version of CMake at the top of the file. For example:
   cmake_minimum_required(VERSION 3.10)
3. Next, add the project name using the project() command followed by the project name. For example:
   project(MyProject)
4. Add any additional configuration settings or options for your project. This can include setting variables, including directories, enabling/disabling features, etc.
5. Specify the source files and dependencies for your project using the add_executable() or add_library() commands. For example:
   add_executable(MyExecutable main.cpp)
6. If your project requires external libraries or packages, you can use the find_package() command to locate and include them.
7. Lastly, specify any additional build steps or configuration settings such as compiler flags, include directories, etc.
8. Save the file with the name “CMakeLists.txt” in the root directory of your project.

Once you have created the CMakeLists.txt file, you can run CMake to generate build files for your project. This can be done using the CMake GUI or by running the cmake command in the terminal.

What is CMake binary directory on Windows?

The CMake binary directory on Windows is the directory where the compiled binary files of a CMake project are stored. By default, CMake places the binary files in a subdirectory called «build» in the root directory of the CMake project. The binary directory is where the executables, libraries, and other output files generated by CMake during the build process are located.

How to add include directories in CMake on Windows?

To add include directories in CMake on Windows, you can use the include_directories command in your CMakeLists.txt file.
Here’s an example of how you can add include directories to your CMake project:

1
2
3
4
5
6

# Specify the include directories
include_directories(
  ${CMAKE_SOURCE_DIR}/include
  ${CMAKE_SOURCE_DIR}/external
  ${CMAKE_SOURCE_DIR}/thirdparty
)

In this example, we have specified three include directories: include, external, and thirdparty. You can add as many include directories as needed by adding additional lines to the include_directories command.

Make sure to replace ${CMAKE_SOURCE_DIR} with the actual path to your project’s source directory.

After adding the include directories, you can use the target_include_directories command to specify additional include directories for specific targets, if needed:

1
2

# Specify include directories for a specific target
target_include_directories(my_target PUBLIC ${CMAKE_SOURCE_DIR}/my_library)

This will add the my_library directory to the include directories for the my_target target.

Remember to re-run CMake to regenerate the build files after making changes to the CMakeLists.txt file.