Cross-What?

In our work we often have a specific requirement:

The project must be cross platform across following operating systems...

Every time that we meet this requirement, we see at least one developer that doesn't know what it means, or what we should do.

Consider programs like MySQL, LibreOffice, Git, etc. These programs can run in different operating systems. They works on Windows (many version of it), on Linux and on OSX, at least. It means that they are built for different operating systems.

The problem is that usually we have different compilers for different operating systems, and they take commands in a different way. In Windows, we usually use the Visual Studio IDE, in OSX we use XCode, while in Linux we mostly use GCC (or Clang, in these days) and the IDE/editor that we like. Visual Studio manage project with its solution (.sln) files, XCode use its own format, while we mostly use makefiles when we build on GCC (or we use the project format of the preferred IDE).

If we want to develop a program that works on all platforms, we need to find a way for unifying them.

One solution is to create a format that can be handled everywhere. This is the solution performed by Qt libraries, with they .pro project files. It seems to work, but what happens if we don't want to use Qt? Or if we don't have them installed on our system?

One Project for Rule Them All

Here is where CMake arises. Instead of creating many project, we create a single one, a CMake one. Writing project in CMake is simple.

But CMake is not a compiler. When we create a CMake project, we don't build the program directly on it. CMake translate its project to a target project. We can decide to build a CMake project for Visual Studio. In this case CMake will create a Visual Studio project. If we need to build the project in Linux, CMake will create the corresponding makefiles, and so on. CMake is a tool for creating project for various compilers, using a common base. This is great, because this allows, for example:

1. Create project only once and use them everywhere;
2. Allow many developers to use different operating systems in order to build the project. I can develop in Windows while another one can develop it in Ubuntu.

Some Example

Let's see an example.

We want to create a fantastic C++ program. This is the source code:

#include <iostream>
int main(int argc, char* argv[]) {
  std::cout << "This program is awesome!!!" << std::endl;
  return 0;
}

Now, we need to create a CMake project. a CMake project consists in a CMakeLists.txt file (or one for every source code directory). In this file we'll define our project. In this case we can write:

cmake_minimum_required (3.1.0)
project (veryimportantproject)
add_executable (${PROJECT_NAME} main.cpp)

• cmake_minimum_required (VERSION 3.1.0): This line says the minimum version of CMake that we should use. This line must be always present and the version number can change depending on the features required.
• project (veryimportantproject): This line defines the name of the project. This should also be the name of the executable/library built with the CMake project.
• add_executable (${PROJECT_NAME} main.cpp): this line create the executable. It creates an executable file, named like the name of the project, using the source file that we provide. ${PROJECT_NAME} is a variable containing the name of the project defined with the previous row. If needed (but why?) we can change this name to another one.

In order to build the project, we must run cmake. Usually we build cmake in another folder, just to avoid to pollute the project folder. If we have the project in the folder sample01 and we want to build it in the folder build (at the same level) wen ca write:

$ cd /path/to/build
$ cmake ../sample01

Some CMake messages appears now, depending on compiler found. With no options, CMake will find the default compiler set by your environment. If you want to specify the compiler you need to use the -G flag

$cmake -G"Visual Studio 14 2015 Win64" ../sample01

When the command is executed, we'll have the project file (in this case, a .sln file with some projects). At this point we can build the project:

1. We can build the project file using the target IDE/Compiler that we have set;
2. Build the project using cmake --build . that will build the project using the target IDE/compiler.

At the end we'll have the executable file, that can be run.

Conclusions

We have introduced the CMake tool that allow us to build a project for many platforms. Obviously the power of the tool is much greater than we've seen here, We'll see in other articles specific features of CMake and how to solve specific problems that can arise in some case.

Add comment