Rafal Swidzinski - Modern CMake for C++: Discover a better approach to building, testing and packaging your software

Copyright 2022 Packt Publishing

All rights reserved. No part of this book may be reproduced, stored in a retrieval system, or transmitted in any form or by any means, without the prior written permission of the publisher, except in the case of brief quotations embedded in critical articles or reviews.

Every effort has been made in the preparation of this book to ensure the accuracy of the information presented. However, the information contained in this book is sold without warranty, either express or implied. Neither the author, nor Packt Publishing, and its dealers and distributors will be held liable for any damages caused or alleged to be caused directly or indirectly by this book.

Packt Publishing has endeavored to provide trademark information about all of the companies and products mentioned in this book by the appropriate use of capitals. However, Packt Publishing cannot guarantee the accuracy of this information.

Early Access Publication: Modern CMake for C++

Early Access Production Reference: B17205

Published by Packt Publishing Ltd.

Livery Place

35 Livery Street

Birmingham

B3 2PB, UK

ISBN: 978-1-80107-005-8

Welcome to Packt Early Access. Were giving you an exclusive preview of this book before it goes on sale. It can take many months to write a book, but our authors have cutting-edge information to share with you today. Early Access gives you an insight into the latest developments by making chapter drafts available. The chapters may be a little rough around the edges right now, but our authors will update them over time. Youll be notified when a new version is ready.

This title is in development, with more chapters still to be written, which means you have the opportunity to have your say about the content. We want to publish books that provide useful information to you and other customers, so well send questionnaires out to you regularly. All feedback is helpful, so please be open about your thoughts and opinions. Our editors will work their magic on the text of the book, so wed like your input on the technical elements and your experience as a reader. Well also provide frequent updates on how our authors have changed their chapters based on your feedback.

You can dip in and out of this book or follow along from start to finish; Early Access is designed to be flexible. We hope you enjoy getting to know more about the process of writing a Packt book. Join the exploration of new topics by contributing your ideas and see them come to life in print.

1. First Steps with CMake
2. The CMake Language
3. Setting up Your First CMake Project
4. Working with Targets
5. Compiling C++ Sources with CMake
6. Linking with CMake
7. Managing Dependencies with CMake
8. Testing Frameworks
9. Program Analysis Tools
10. Generating Documentation
11. Installing and Packaging
12. Creating your Professional Project
13. Appendix: Miscellaneous Commands

There is something magical about turning source code into a working application. Not only the effect itself: a working mechanism that we devised and brought to life, but the very process, the very act of exercising the idea into existence.

As programmers we work in this loop: designing-coding-testing. We invent changes, we phrase them in a language that the compiler understands and we check if they work as intended. To create a proper, high-quality application from our source code we need to meticulously execute repetitive, error-prone tasks: invoking right commands, checking syntax, linking binary files, running tests, reporting issues and so on.

It takes effort to remember every step all the time. Instead, we want to stay focused on the actual coding, and delegate everything else to the automated tooling. Ideally - this process would be started with a single button, right after we changed our code. It would be smart, fast, extensible and work the same way across different operating systems and environments. It would be supported by multiple IDEs, but also by Continuous Integration pipelines which test our software after a change is submitted to a shared repository.

CMake is the answer to many such needs, but it requires a bit of work to configure and use correctly. This is not because CMake is unnecessarily complex, but because the subject that we're dealing with here is. Don't worry. We'll do with this whole learning process very methodically, and before you know it - you will become a building guru.

I know you're eager to rush off, and start writing your own CMake projects, and I applaud your attitude. Since your projects will be primarily for users (yourself included), it's important that you understand that perspective as well.

Let's start with just that: becoming a CMake power user. Well go through a few basics: what is this tool, how it works in principle and how to install it. Then we'll do a deep-dive on the command line and modes of operation. Finally, we'll wrap up with purposes of different files in a project and we'll touch on using CMake without one.

In this chapter were going to cover the following main topics:

• Understanding the basics
• Installing CMake on different platforms
• Mastering the Command Line
• Navigating the Project Files
• Discovering Scripts and Modules

You can find the code files present in this chapter on GitHub at https://github.com/PacktPublishing/Modern-CMake-for-Cpp

Compilation of C++ source code seems like a fairly straightforward process. When we take a small program like a classic hello.cpp:

All we need to do to get an executable is to run a single command. We call the compiler with a file name as an argument:

Our code is correct so the compiler will silently produce an executable binary file that our machine can understand. We can run it by calling its name:

However, as our projects grow we quickly understand that keeping everything in a single file is simply not possible. Clean code practices recommend that files should be kept small and in well-organized structures. Manual compilation of every file will be a tiresome and fragile process. There must be a better way.

Lets say we automate building by writing a script that goes through our project tree and compiles everything. To avoid unnecessary compilation our script will detect if the source was modified since last time. Now wed like a convenient way to manage arguments that are passed to the compiler for each file - preferably do that based on configurable criteria. Our script should also know how to link all the compiled files in a binary, or even better: build whole solutions that can be reused, and incorporated as modules in bigger projects.

The more features we will add the more we will get to a full-fledged solution. Building software is a very versatile process and can span multiple different aspects:

• Compiling executables and libraries
• Managing dependencies
• Testing
• Installing
• Packaging