Chris' C++ Programming Notes

AKA - ISO/IEC 14882:1998

AKA - ISO/IEC 14882:2003

Mostly bug fixes and subtle implementation standardization details.

Wikipedia

Published: 2017-12-01

Here is the latest official C++ 2017 Standard - 1622 pages!

As one might expect, this one is still being worked on in 2019.

Like C, make a variable immutable with the const keyword. Hmm, a "read-only variable", like the C++ error messages say, is an oxymoron, right? Still, it is a part of the C++ religion to pray to the const gods at every opportunity.

This is simple in the simple cases. But there is all kinds of mischief that can arise from this. The most absurd to me is the mutable keyword which can make const declarations, uh, less const.

Wait a moment… This just in… I’ve received word that C++11 has introduced a new keyword into the language — don’t act all surprised — the word is constexpr. As far as I can tell, const can be assigned a value (that thence remains constant) at runtime, but constexpr is carved in stone at compile time. I would imagine that things like this are a teensy bit more resource efficient.

The normal const could be applied to things like this.

Here the number of arguments can be different depending on how the program is executed, but once the value is set, argc will be locked for the duration of the execution.

It turns out that constexpr can be used with functions too. This is limited to simply return (maybe with some awful ternary operator tricks). But C++14 expands the potential of constexpr functions. I’m thinking of these like old C preprocessor macros that do simple things during compilation so that the precomputed answers are injected into to the source code. But C++ tries hard to bring that sort of thing into the language proper. The limitation with constexpr functions is that all arguments must also be constexpr for it to be effective. If they are not, it just pushes it out to normal runtime execution. Another fact to understand that helps explain it, is that such pre-computations at compile time will likely make the compiling process take longer.

There is also a C++ specifier called volatile which can be used in very rare situations where you explicitly want the compiler to refrain from performing any optimizations on this "special" memory’s operations.

Note that C++ is more strict about type casting than C.

Variable definitions in C generally must be at the beginning of a block whereas in C++ they can be anywhere in the block.

C++ provides a way to get a runtime check of what kind of type a variable is. This is done with the typedef function and is useful when variables can be any of several types or objects.

C enum values are always sized int whereas in C++ they are a distinct type and can have different sized values. This defines a new user type DOW.

You can do a lot in the definition. Here the type declares a variable (casual) and sets it.

Some people believe that enums should be named as singular nouns and not plural. Although enums may define a collection of possibilities for, say, problem_types, the possibility will just be a problem_type when actually used.

Because C++ is based on C, the spartan techniques of old school C work in C++ too. Note that as in C, double quotes signify strings and single quotes are characters.

Note that in the example that unterminated_rubbish is just that. With no termination, functions like cout just keep reading memory until it finds a null. It can pick up all kinds of wacky stuff. In my example I found that it printed the abc string too until it found its termination byte.

So think carefully about using this style of C character array strings with C++ functions. However the cstring library can be used with this kind of string and it does work fine if done carefully.

That code produced this output.

In C++ the string class is a more elaborate mechanism for working with strings. Strings are generally used like this:

Produces this.

Note that because it is a class (string) it can be initialized like a new object as an initialization function parameter. Subsequent redefinitions use the overloaded = operator to simulate the way normal people would expect a programming language to work.

Member functions for string class include:

For find operations, if the target is not found, it will return string::npos which on my system produced 18446744073709551615 (2^64-1). Checking the return value for this is how you check if something was found.

Need a long line of dashes for something? Just create a string with an integer first argument. Here is some content between two lines of 20 dashes.

There is a function called to_string(non_string) that makes strings out of many things, numbers mostly. One thing I found odd was that it did not seem to have a prototype that accepted char types. You’d think that would be pretty easy. But the answer to that riddle was just covered in the Repeated Characters section above. Just use string(1,mychar).

This is rumored to only work in C++11. Here is how to drop the end N characters in a string. For example, N=4 to get rid of the file extension such as ".txt" in a filename.

Or the equivalent to piping to the Unix rev command. Just define a new string with reverse iterators from the old one.

To show a good example of strings in action, here is a C++ technique to achieve the functionality of Python’s split() function or the Unix cut command.

Here’s a pretty effective way to do simple string substitutions. This replaces globally in the string, not just first. You can also replace with "" and this works as a character deleter too.

Apparently C++11 introduced the char16_t which is a double byte char (the ordinary stuff a classic std::string is made of).

Sometimes you want normal output to go to the standard place, for example, a unix pipe, but you also want to generate some error messages and have them not go to the pipe. To write to /dev/stderr or stream 2 (I think) just use cerr << data << endl; just like you’d use cout.

It seems that cin is good for reading space delimited fields one field at a time (or something like that), but it doesn’t read whole lines.

Here is an example of reading each character of standard input into a string.

Instead of old C stdio.h printf formatting, C++ prefers you to use something called a "manipulator". The classic endl is such a thing. For more complicated manipulations, you’ll need to use <iomanip>.

Depending on how wild you get you may want to preserve stream formatting settings before mucking them up and then restoring them when you’re done. To save a copy of the current settings, use something like this.

To pad with leading zeros (or any character) use something like this.

Here is a lesson about manipulators.

Besides the normal setw, there is also setfill, setprecision, and setbase. In Cpp11 there are some manipulators for money and time. (See here.)

See operator overloading below for examples, of how you can make your own objects do the right thing with cout.

Note that while this does seem to work fine and it illustrates some interesting techniques, it takes 39x longer to run than simply doing ls /tmp. YMMV.

Note also that there is a std::filesystem::directory_iterator (ref) but that required turning on compiler options last I checked.

Need a variable number of arguments? C++ can do that with variadic function parameters. To do this use ... (three periods) as the last parameter "name". Then in the function itself you can refer to some special variables related to the call. Then you can use va_list, va_start, va_arg, va_copy, va_end which are explained here.

There is some typical C++ syntax messiness with this feature. This sentence from the official reference helps one understand what they’re looking at when they come across multifarious syntax for variadic arguments in the wild.

Fortunately that’s all there is to know about ... syntax. Ha! Just kidding! Have a look over at template parameter pack syntax which also uses ...!

Sometimes you might see something like this.

This is a C++11 style which is similar (but superior I’m told) to declaring a private function and then just neglecting to define it. This is to prevent it from being used. This way, by being explicit about it, you can get more sensible compiler errors.

Prefix operators (e.g. ++var) increment the value and then return a reference.

Postfix operators (e.g. var++) create a copy of the variable, increment the value, then return the copied, unincremented value.

Also C++ has += and other such operators as found in Python.

C++ discourages the use of preprocessor complexity. Instead, the idiomatic C++ way to do preprocessor functions is with the keyword inline.

I’m not sure if this is really a real thing or just a way to refer to a kind of usage but I’ll note it here in case it comes up. A functor essentially seems to be a class which includes a ‘type operator()(type arg){ def; }` overload function, i.e. overloading the parentheses that usually signal a function. This gives the class name the ability to look like a function and do this thing defined in the overload. The difference here between other function strategies is this functor can now carry around state in the class’ member variables.

Here’s a simple example of how this might look.

This example shows normal functors, how to use them in a modular interchangeable way and finally how the state features could be used. The TimesLastResult multiplies the supplied argument by whatever the last answer this function supplied was. That’s a strange kind of function, but possibly useful (the classic Fibonacci example might have been more "useful"). Normally a trick like this is just hidden in some big class but the point here is that it doesn’t have to be.

Lambda expressions, also called "function literals", showed up in C++11. Lambda functions are anonymous functions in the same way that 2.5 in x=2.5 might be an anonymous float. Everything a lambda can do can be done other more verbose ways. For normal things that lambdas do, function pointers suffice just fine, however there are some added tricks to lambdas. The apparent similarity of lambdas to function pointers comes from the fact that a lambda creates a class which has a operator() so that it can look like a function and do the job of a function pointer. But this class can do some other things too like "capture" state, optionally by reference. The runtime object of this class is technically called a "closure" and holds the references or copies of the captured variables. The class is called a "closure class". If the capture is empty then the compiler may just create a function pointer. Note that proper function pointers will work anywhere while lambdas are scoped to where they are defined — a bad thing sometimes but usually probably a good thing.

In practice lambdas are mostly used to create little expressions for things like find_if, remove_if, count_if, sort, lower_bound, etc. They’re commonly used in thread programming and for special behavior with shared and unique pointers.

Lambdas can usually be spotted with a distinctive empty capture [].

Nothing too complicated about that except for the capture clause. It is usually empty (capture nothing), but it can get absurdly complex. There are some quirky syntax tricks:

C++14 has even more baroque "features" and syntax.

Note that the scope on the left and right of the = here are different (left x is in the closure, right x is in the code defining the lambda). This is called "generalized lambda capture" and allows one to capture the result of an expression. Looks like a mess to avoid if possible.

A smart pointer was first part of C++98. In C++11, there are now three more types of smart pointers. These have pretty much all of the same functionality as normal pointers but with a lot of baggage to try to help keep things under control.

Note that the function is framed as expired() because testing for it being still valid is tenuous; this is because at any moment (e.g. between you checking and doing something about it) it could expire. You can get that behavior only by creating a std::shared_ptr from the weak one. That is an atomic check and grab which will be null if the std::weak_ptr has expired. Do that like this.

Newish C++ is littered with double ampersands as in this parameter definition: MyClass&& x. What the heck is that all about? These are "rvalue references". They are also sometimes called "forwarding references".

An rvalue (see values below) reference is mostly used to bind to temporary objects in order to make them more efficient. They also are useful in "move semantics" and "perfect forwarding" which is about juggling items in memory in a sensible way. They can only bind to objects for which moving in plausible.

This apparently is very useful in template code. In template argument deduction there is a concept called "universal references" which is subtly different but uses the same double ampersand. There something like MyClass&& x could refer to a reference or the real object. These arcane subtleties are discussed here. One general rule is that if there will be magical type deductions as with auto or templates, then the && syntax is a universal reference and not necessarily constrained to an rvalue reference. An important implication is that if you use this kind of trick it’s best not to make the universal reference an argument of overloaded functions. This will tend to try to fit the universal reference before fitting what you really wanted it to fit. Ah, automagical — not always so auto or magic.

If you want to make sure these automagical helper monkeys stay in their cages, you can use the explicit keyword which will prevent implicit conversions and copy initializations. Another way to get universal references to behave "explicitly" in your overloaded functions is to use what’s called "tag dispatch" this is where you add bogus arguments so that the function signature is certain to be the correct match.

The functions (function templates to be exact) std::move and std::forward are interesting in that they do not move or forward (respectively) anything. They are compile time mechanisms for elaborate casting which I feel is the most important thing to understand about them — they do nothing at runtime. It seems that move should have been named something like rvalue_cast. Since rvalue objects are the kind that can be properly moved, the std::move function does provide a running start to that actual functionality.

So what do they do? The std::move casts an argument to an rvalue. The std::forward does the exact same thing but only in limited cases.

If you’re fighting with these mechanics, also keep in mind std::remove_reference which strips the l- or r-valueness.

Move requests on const objects are silently transformed to copy operations (losing any efficiency you may have envisioned).

The std::forward function (template) is mostly used in a function template taking a universal reference parameter that will be forwarded to another function. Since arguments are lvalues, if you have an argument that needs to stay an rvalue and get passed on as such, that’s what std::forward is good (known) for. The condition it checks for is if the argument it is looking at is an rvalue. If not, then it just passes it on without any exotic casts. In theory the std::move function could always be replaced by the more comprehensive std::forward. But subtle differences in "clarity", I suppose, have produced both.

C++ has a troublesome topic of discussion called the "slicing problem". This has nothing to do with Python slicing. It looks a bit like this.

In this code, b has an alpha and a beta, but a does not have a beta even though it was assigned from an object with one. That beta is considered to have been "sliced" out of the object.

If you have a situation like this

The dump member function probably won’t compile because the compiler can’t be sure that the dump() function won’t mess with the calling object. And since this particular calling object, the_unchanging_thing, is constant, that would be wrong.

The way to handle this is to define the dump() function as a "const Member Function" (that’s the official way to refer to it). Add the const keyword to the end of the declaration and definition.

Sometimes you want to give access to other functions that are actually not part of your class. This is what friend functions can do. Use friend keyword in the declaration, not the definition.

Confusingly, you must put the friend function declaration in the class it doesn’t belong to prefixed with the friend keyword.

This now can go in the MyClass declaration even though it’s not part of MyClass. It’s just a helpful random function that can now access MyClass as if it were a part of it. Note that this example helps for this order of arguments. If the order is reversed, the MyClass operator+ can just be overloaded the normal way. It seems common to use friend functions when overloading operator<<().

Classes can be friends too. By doing something like this.

This type of arrangement will allow Clothes to access Body’s private parts.

The virtual keyword is confusingly used for different purposes depending on context. Here are two of the uses. There may be more.

See Abstract Base Classes for an explanation of "pure virtual functions".

One slightly tricky thing that can plague setups that want to leverage virtual functions is something like the following example where I want to have different backend output systems for some internal data. Simplified for illustrative purposes, here’s a plausible way to set something like this up.

Because I declared the outputEngine variable to be a Backend_HTML, you might expect the do_someformatting() function to produce the HTML version. But it does not. It produces the virtual function’s *The text.*. What is going on? It’s subtle but you must change the function declaration of the function that works with these overridden objects so that they show up as references. Note the &.

Without this, the function insists that the HTML outputEngine object supplied be hammered into the generic base class. By using a reference to the &outputEngine the result is <b>The text.</b>.

One of the many idiosyncratic things about C++ is that it is one of the few languages that allow you to muck about with redefining much of the core syntax. Don’t like how + adds numbers? Well, you can change it. Obviously this can produce horrendous obfuscation, but generally it’s quite handy.

One of the most common uses for operator overloading is to make a function that can allow your custom classes to be included in normal stream operations. In the following example, I have a Block class that I’d like to be able to "print out" using cout.

Note that this is not a member function. This is just a global function. That said, you need to give this global function access to the data it will likely be using from the custom class. That is done with a friend function (see also that section). That looks like this.

I’m not sure that’s technically a proper declaration; it’s more like a decoration referencing a function template that must be spelled out like a declaration. Whatever it is, it does go in the class definition.

Need to worry about postfix vs. prefix? Lucky you! This example is probably wrong, but it’s in the right direction.

The & is optional but almost always present to lighten up the call by making the default argument a reference. Note that there are some things you probably should not think about overloading.

When a base class function is declared virtual its corresponding derived class functions should override it. It turns out that sometimes subtle errors can happen if the derived class has some defect in its correspondence to the base class. To make the errors less subtle and more obvious to the compiler such that sensible errors will be produced, C++11 offers the override declaration. Basic usage looks like this.

One bizarre caveat on the override specifier is that it only is a keyword if it is in a proper place at the end of a member function declaration. This means that if you want a function called override() or a variable or whatever, you can do that. Obviously that’s going to be misleading these days to those in the know — but not to those really in the know. Obfuscated C++ writes itself! Gah!

A similar specifier is final which indicates that the function or class should not be overridden. It is in its final form. Or something like that — smells like Java.

Getting into crazy weird stuff is easy with C++ and my favorite example of "ok, you’ve gone too far" is reference qualifiers. I’m not going to pretend to understand the gory details but essentially you can specify if derived classes can override (not overload) base class functions depending on whether or not the member function is an lvalue or an rvalue.

Clearly that is ridiculous and the whole language should be scrapped if we need to regularly deal with ridiculous error bait like that. But I’m including it for completeness so that I can hopefully recognize this for what it is if I ever stumble across it in the wild. Here’s the syntax that should tip you off to this "feature".

Note that if you ever use reference qualifiers you need to make sure all overloads use them otherwise the ambiguous ones may take precedence and screw things up.

I don’t even know when the function’s context would ever be rvalue (factory functions?) but that should be enough of a syntax hint to send you off in the right direction for proper research into the topic.

Taking some kind of obnoxious programming test? I had never heard of this and I suspect it has something to do with Java where abstract is a keyword; it is not in Cpp! But there are abstract base classes, sometimes referred to as ABC, in Cpp. An abstract base class is really just a class that contains one or more pure virtual functions. Class declarations containing at least one pure virtual function will not allow objects to be instantiated from that class.

A "pure virtual function" is one that ends with =0 like this.

That’s it. The =0 in the prototype means that the ABC doesn’t need to define the function. Also note the const member function version.

In class definitions the constructor can have a list of members with their correct initial values defined. These are placed after the constructor name and parameters, followed by a : and before the body of the constructor. The following are very similar. The first is preferred since it avoids unnecessary copies.

Iterators are pretty important in normal C++ and are pretty much how you rummage through STL containers of data. And lots of other things. You can have an iterator type that looks like this.

One interesting thing that seems bonkers to me is that you can have, and should prefer, constant iterators. It seems to me that if an iterator’s whole point is going from one thing to another, that’s fundamentally not very constant. Here’s an example.

My limited understanding (here’s more) is that the const_iterator type points to different stuff, it’s just that the stuff is immutable. Still look out for it and, in theory, if you can use it, the const gods will smile upon you.

A vector container is essentially a dynamic array. It has most of the advantageous properties of regular C arrays, mostly contiguous memory that can be accessed with predictable strides. Unlike regular C arrays, a vector can be dynamically resized as needs grow. This implies that vectors hog more memory than you may actually need them to, just in case you eventually want to use more than you thought you would. This also implies that once you use more than even this amount of memory, that an abrupt allocation of yet more memory may perhaps be needed along with a physical reshuffling of the contents; I don’t know if this can inject weird choppy performance issues, but it’s something to think about. The strategies used by vector to allocate additional memory are implementation dependent but seem to try to keep log(size) performance (adding twice as much as you had before upon running out).

The following sample program shows the basic STL container usage with a "vector" template.

Methods for vector include:

An STL list is a doubly-linked list. It’s quick to insert one or many anywhere, but slow to find particular items deep in the chain. This means that inserting can be slow if you need to find the insertion point first. However it also implies that editing the ends of the chain is going to be quick.

Don’t forget to #include <list>.

Methods for list include:

Here is an example of using a linked list. One helpful feature is that you can insert into the beginning of the list without actually remapping everything else. This is a rough implementation of the Unix tac command which reverses lines of input. The reversing is done simply by inserting each line read into the list of lines instead of appending each.

Note also this program roughly shows how to handle reading standard input or a file specified. Also note that the reverse method could have been used, perhaps with slightly more clarity of purpose.

Another quirk of lists is that because it’s more of a linked chain — importantly, of arbitrarily sized items — it’s kind of weak on other simple features like spitting out what position a program is currently iterating over. Since it just moves around from node to node on the linked graph, it actually doesn’t really know much about the big picture. This means that some obvious strategies may not work as in this example where I want to know if the iterator, i is on the 2nd item.

A set is a container whose elements are always ordered (not sorted) and unique. Sets can be handy when trying to count unique items, even mildly complex ones as shown here with pair containers.

An unordered_set does not maintain an order. These can be quicker than regular sets. This is a C++11 thing.

Allows duplicates.

If you don’t want a strict ordering and you want duplicates to be valid, the unordered_multiset is a Cpp11 thing. For simplicity, imagine a Python dict where the keys are combined with an invisible nonce and there are no values; something like that.

The pair container — which came first — is a specific case of a std::tuple with two elements. Or thought of another way, a tuple is a generalization of std::pair. It is basically a way to store heterogeneous items as, well, a pair. Tuples make me wonder what the advantage is over a vector of structs besides everyone in 2011 (C++11) having forgotten C by then. I guess there are a bunch of helper functions and so on; though interestingly many seem to have been removed for C++20. Oops!

It looks like pair is basically a struct: template<class T1,class T2> struct pair; Anyway, if you’re using pair<blah,blah> X, you mostly need to know about X.first and X.second. Those are not extraction functions so no parentheses. Also X.swap(), which is a function, might possibly be useful for graphics stuff.

Related to a pair in some subtle way is a map. A very simple demonstration of the most basic map syntax.

A nice property of the map container is that it is some kind of a tree that stores values in a way that guarantees the keys to be sorted. It can be used to sort complex data on arbitrary fields by making those fields the key.

Here’s a way to iterate over all the items contained in a map object.

Note that if you ask for my_hash[not_really_there] it will create a new pair with a key matching what you asked for and a value of empty (or whatever your default constructor dreams up). If you like exceptions, the my_hash.at(key) will not do this, but it will throw an exception if the key is missing. It could be smart to look for the key first as in something like:

The STL algorithms can be so bizarre conceptually and with such baroque syntax that it’s hard to even know what they do. But with a decent example, it all starts to make sense. Here was a project I worked on where I had a simple struct L that contained two variables, x and y. I had them in a vector and I needed them sorted on x but made unique with respect to y. Here’s what I used for that.

You can read more about this and how its speed compares to the unix command line in this blog post I wrote.

Notable interesting functions include the following.

There is a whole bunch of stuff like that which can be found in the reference documentation.