Author: cpptutor

It’s often interesting to see just how much can be accomplished with just one line of code; this mini-article has been written to demonstrate a solution to an age-old problem: How to convert *argv[] into something usable in (Modern) C++.

Any seasoned C programmer will be quick to tell you there are two forms to the main() function, the empty parentheses variant and the one specifying argc (number of arguments) and argv (a pointer to an array of pointer to char).

If your head hurts if you try to determine whether there’s any difference to declaring argv as const char **argv or const char *argv[] you’re probably not alone. (No, there isn’t a difference, is the answer.) In Modern C++ we hardly want to be messing around with a single const char * if we can help it, never mind an array of them. So, how to construct and populate a vector of string views in one line? Here is the code (line 12 is the one-line magic):

This article aims to summarize the current status as regards Modules and the import keyword with modern compilers, in particular accessing the Standard Library without the need for #include <iostream> and similar.

At the time of writing, two of the most popular C++ compilers (Visual Studio 2022 and Clang) offer full support for modules including importing the Standard Library as a module, while GCC g++ offers some support for writing modules, as detailed below:

It’s difficult to imagine even a simple program which doesn’t use something from the std namespace, so most C++ programmers are introduced to namespaces early on. Namespaces use the same double-colon syntax as static members of structs and classes, so sometimes it’s not clear to user code which is which. Consider the following code fragment:

Something is wrong with the following code, can you spot what it is? (If in doubt, try compiling it.)

enum class Color { red = 1, green = 2, blue =  4 };
auto yellow = Color::red | Color::green;

As you may have found out, the compiler complains with a message such as: error: no match for 'operator|' (operand types are 'Color' and 'Color'). The simplistic solution is to remove the class keyword, and use the “plain” enum type, where the enumerators are implicitly convertible to and from int.

This article aims to show that switching on string values and matching them with string-valued case labels is both practical and possible in Modern C++ (since C++17), with a minimal amount of boilerplate code being necessary. The C++ switch statement is almost unchanged since the days of C, apart from the availability of the [[fallthrough]]; attribute to allow a non-empty case to fall through to the next, and the possibility of preceding the switch expression with an initializer. Importantly, case labels can still be only of integral type (from char up to long long).

The steps needed are as follows:

1. Create a hashing function that generates an integral hash from a string (we’ll use C++17’s std::string_view as the source type)
2. Make sure this function can be declared constexpr (again, this needs C++17)
3. Write an operator"" function (again constexpr) which calls the hashing function

So we all know assert() from C’s Standard Library, right? If we implemented it ourselves as a macro, it might look something like this:

#define assert(x, msg) \
    if(!(x)) { fprintf(stderr, "Fatal error: %s\n", msg); abort(); }

With C++, any type that has operator! defined is compatible with this macro. We can then write:

std::ifstream infile("myfile.txt");
assert(infile, "could not open file");

The Python language does not have an iteration-based for-loop in the style of C and C++; instead it uses a Python list (or tuple) in conjunction with the keywords for and in. Python 2 uses the helper function range() to create a suitable list, while Python 3 implements this function as an iterator class (to avoid a potential delay before the first iteration of the loop due to populating a very large list). If we were to implement this in C++, we could populate a std::vector and iterate over that, but this could potentially suffer from the space-and-time overheads of the Python 2 version. So instead we’ll choose to use iterators in the style of the STL containers (actually, if you know your Standard Library iterator categories, it’s forward iterators we want to emulate, however I haven’t used the actual iterator types available because of only wanting to be compatible with range-for, not the standard containers).

Just in case you weren’t already aware, a part of the upcoming C++20 Standard is a text formatting library (based upon the popular, free, third-party {fmt} library). It looks like being a great addition to the Standard Library, providing ease-of-use, performance and type-safety.

Before we put the <iomanip> and <cstdio> C++ headers into the museum however, lets look at something which is also possible in Modern C++, using a printf()-style format string to construct a std::string. The prototype of this function is therefore:

std::string string_printf(const char *fmt,...);

A classic course assignment is to write a program that prints out an arbitrarily-long decimal number in units, thousands, millions… and so on. This article looks at how to implement this efficiently in Modern C++, using head recursion. This is where the logic of a function is generalized so that it can usefully call itself a (finite) number of times. The more commonly found (and simpler to understand) form of recursion is tail recursion, where the result of the function (the return value) can be used to compute the final required value. In case you’re not up to speed on tail recursion, the classic example is a function which computes n! (that is, the factorial function from Mathematics).

This site contains an original, self-contained guide to learning the fundamentals of Modern C++, intended to be the basis of a self-study course. Some Chapters depend upon material presented in earlier ones, so studying them linearly is recommended. There are also regular posts (accessible from the front page) which cover topics or areas of C++ not covered in the course.

If you have any queries or suggestions, please leave a comment. The course materials are in a completed state and are made freely available here as well as being hosted on GitHub:

0. About this Tutorial
1. String and Character Literals
2. Variables, Scopes and Namespaces
3. Conditions and Operators
4. Functions
5. Arrays, Pointers and Loops
6. Enums and Structs
7. Strings, Containers and Views
8. Files and Formatting
9. Classes, Friends and Polymorphism
10. Templates, Exceptions, Lambdas, Smart Pointers

• Download the code examples (as a zipfile) or browse them on GitHub.
• View details (as a sitemap) of the course topics.
• Suggested coding assignments for each Chapter.
• New! Download the whole Tutorial as a set of interactive Jupyter notebooks (as a zipfile), intended for use with self-hosted JupyterLab.

Last update: 2026/07/28 – update to code in Chapter 4