The GNU Make and C++ Programmer's Primer

Name: The GNU Make and C++ Programmer's Primer
Rating: 4.1 (61 reviews)

Creating Makefiles, Applications, and Libraries using the GNU Tool Set

Created byMr. Randall Nagy

Last updated 6/2023

English

What you'll learn

Understand how to use GNU `make` to manage common software development activities.
Learn the "critical path" options most frequently required to build C++ applications.
Use GNU's `dbg` and `xxgdb` tools to perform stack-based debugging.
Create libraries designed to be shared between multiple C++ applications.
Understand the difference between static & dynamic library types.
Discover how GNU's `make` uses rules, dependencies, recipes, and macros to create software.
Learn how to include, inspect, and remove source code from your debugging sessions.

Course content

1 section • 11 lectures • 58m total length

Introduction & Overview2:30
Enjoy an overview of what will be covered in this presentation.
Makefile Concepts8:18
Complete an introductory "Make" activity that requires no C/C++ programming.

Discover what GNU is, as well how to run GNU's tools on Window, Linux, and OS X. Learn what `make` is, as well as the key artifacts required & naming conventions required. Understand how to write a basic makefile "rule," how rules operate, as well as what a programmer's "delta" is.
Making C++4:29
Create a simple C++ console application designed to be managed & built by another Makefile activity.

Understand how to create a Makefile macro, as well as why using macros can save allot of time.
The Program Compilation Process3:47
Review how the GNU c++ / g++ compilation process operates. Compile and link an executable program. Learn how to rename the default `a.out` compiler result so as to create more meaningful program names.
Basic System Signals & Make Integration5:42
Discover the difference between external & internal programs. Review the operation of command "shells," as well as how to use basic `bash` operations to combine command-line operations. Learn how to execute alternative commands based upon previous command success or failure. Discover how to update a Makefile so as to create a test case that can terminate any `make` process.
More C++ Options3:28
Review the most common set of command-line options used to manage the creation of C++ applications. Understand the peculiar library-naming conventions used to link GNU libraries into our applications. Discover how to enable and / or remove warnings., as well as the common macros often used to manage the C/C++ software creation process.
Library Creation & Management8:10
Review how to add classic line-logging to any operating environment. Learn how to make the "era Namespace," as well as how to create specific targets by using command-line targets. Review the most common "best practice" targets, as well as how to clean-up after Makefile activities.
C/C++ Logging5:55
Download, make, & review the operation of an Open Source project. Learn how to build specific targets, as well as how to clean and otherwise manage test applications and libraries.
Graphical GNU Debugging9:45
Review how xxgdb allows us to review the most common debugging operations. (GNU's graphical xxgdb debugging tool does not have to be installed.)
GNU Console Debugging4:17
Apply what we have learned while reviewing an actual gdb console debugging session. See how to set & remove breakpoints, temporary breakpoints, inspect variables, step over "stack frames," as well as return to a calling context.

Update the Makefile so as to add debugging symbols. Discover how start a debugging session, inspect stack frames, as well as how to manage an "inferior session."

Learn how to strip source code / symbols after debugging has been completed.
Handy Options & Resources1:57
For further study, discover an inspiring set of additional command line features, built-in macros, as well as more resources available around the Internet.

Requirements

Students must be able to start & exit a "command line" or "console" user interface.
Students should be able to run GNU's `make` from a `bash` shell, or from Cygwin.
GNU's C++ Tool Set must also be installed.

Description

In our increasingly competitive marketplace, software developers often need to demonstrate superior software development expertise. In a world full of software development choices, discovering how to create high-performance software also remains an increasingly important part of what every software developer needs to understand.

Why GNU Make?

When it comes to creating vendor-independent soft-wares, the "GNU's Not Linux" (or `GNU`) `Make` and `Makefile` team remain the most popular go-to technologies. Like many, I've used GNU to reliably re-make projects that have been building for decades. -Well after other tools fail to 'make things' like they did once, GNU's Make and other tools continue to 'just work.' Guaranteed.

Make Many!

Unsurprisingly then, no matter if we are creating new software or re-building legacy applications, understanding how to use a Makefile to manage just about any creation activity is a highly sought-after skill set. From dynamically creating documents, websites as well as software, the first step in creating blazingly fast software very often requires using Make!

Why C/C++?

Yet another forever go-to technology, discovering how to create high-performance software often involves using some part - if not all - of the C/C++ programming standard. Not only does every operating system rely upon some part of the C/C++ standardization effort, but every modern, popular operating system supports both C/C++ as well as the GNU Tool-set. -Almost all other programming languages also support, if not directly rely upon the free & open C/C++ community!

From popular applications, robotics, and operating systems to the Cloud itself then at some point in time everything relies upon software written in C/C++.

What Else Will I Learn?

Demonstrating how to compile, link & test a basic C++ program, the training will also cover the most common set of g++ / c++ operations. Students will create a C++ application, related Makefile, as well as library. GNU's basic compiler, linker, and program-creation process, artifacts, and naming conventions will be reviewed.

Bug Busting

Because GNU's debugger is important to understand, the operation of both gdb, as well as the graphical xxgdb tools will be explored. Demonstrating how to both include, as well as remove, source code & symbols from your application is also presented.

Symbols
Finally, students will also learn what `name mangling` is, as well as how to use GNU's tool-set to decipher "decorated" classes and function names.

You'll also enjoy practicing what you have learned by completing many hands-on activities!

And yes, you will understand all of this - and more - in less than a video-hour!

Who this course is for:

First-time C/C++ software developers on Linux, macOS, or Cygwin on Microsoft Windows.
New software professionals who are interested in learning how to make static and dynamic libraries.
Students who have never used the classic GNU "MAKE," "LINK," "GPP," and / or related produce suite.
Software professionals interested in creating common variables, targets, and other "Recipe" coventions for GNU Make.