A minimal C++ development environment

Any Linux system comes with a bash-like shell, so probably no need to do anything.

I prefer to work from the command line (or at least do some kind of tasks on the command line), because it is so much easier to automate them, once you notice you are repeating the same sequence of commands multiple times.

With GUI it is also possible to automate many tasks, but often you need external programs, they might be slow as they need the GUI to update the shown content, and are not as easy to automate.

Unfortunately, Windows does not provide such an environment out of the box, but there is a very good port: cygwin.

The biggest limitation is that programs compiled with cygwin should be executed from a cygwin shell.

The compiler is GCC.

Note that most distributions also provide Clang, and as it has the same interface, using GCC or Clang won’t make any difference.

I would recommend git because

While not necessary for development, a revision control system helps to save and organize your work and can help you in the future once you start collaborating with other people for fun or professionally.

While it is possible to build programs by invoking the compiler by hand, it is best to leave this task to a build system.

CMake has the advantage of supporting many platforms and is already used by many projects.

Make is the de facto build system on POSIX systems and for many open-source projects, but it is not as easy to use, and it does not work well on Windows-like systems (even if there are ports for Windows).

An IDE that supports debugging and the build system out-of-the-box would be better, but I have not found anything that I would recommend over anything else.

For the beginning, and a minimal environment, it might be better to compile from the command line, thus an editor is sufficient, but it should at least support syntax highlighting. I believe most graphical editors can do that (except notepad.exe) considering that even command line-based editors support it.

C++ and C are languages with many rules.

They have a lot of gotchas and undefined behavior.

This means that an incorrect program seems to work correctly, and unrelated changes can break parts of the program, like adding or removing a comment.

It is crucial to avoid such type of errors as soon as possible.

There are many static analyzers, which are tools that can find logical errors in your source code.

For example, most compilers support optional diagnostics that can be enabled.

For GCC, a good starting point would be -Wall -Wextra -pedantic.

There are lot of other useful warnings, unfortunately, those are not enabled by default, and it can take some time to find the most useful.

Another static analyzer easy to use (even with a GUI for those who feel more conformable) and multiplatform, is Cppcheck. The biggest advantage is that it can be used with no configuration on nearly every project, and does not depend on the build system.

The easiest way to get confident with source code is by experimenting with it.

Test suites like Catch2 make this task easy.

As already mentioned, C++ is a complex language.

The best way to start is with a good book that explains the basics, a little bit of the background of the language, and provides some exercises.

Make sure to pick a "recent" book, since C++11 the language has changed a lot and continues to evolve.

Some good books are

A good book, no matter how good, can only help you so much.

When encountering cryptic compiler errors, or strange bugs, or if you have some fundamental questions about how some things work, a browser and a search engine (or a chat/forum/…​) will help you to find the solution faster.

The difficult part is distinguishing between good resources and bad resources.

Some sites that probably everyone working with C++ should be aware of (in no particular order):

The environment I’ve presented is portable in the sense that most programs have been ported to all systems.

This makes it easier to give advice to people working in different Linux distributions and Windows versions.

Restricting oneself to a subset of tools working in all environments is not a very productive approach, but it is useful for getting started.

Once one has got the basics, it’s time to expand the toolbox and take advantage of platform and system-specific tools.

For example, if working on a GNU/Linux machine, I would absolutely recommend Valgrind.

Like Cppcheck, it normally does not require any setup.

I would like to recommend it to everyone, but it does not work on Windows systems!