Archive Page 2


C++ Digraphs

This is not as you might think, an article about implementing directed graphs in C++. The digraphs I am writing about are sequences of characters which act as a stand in for other characters. Digraphs and trigraphs exist in many languages, but I will be focusing on C++. The difference between digraphs and trigraphs is simple the number of characters, a digraph is 2 characters and a trigraph is 3 characters.

Digraphs are part of the language because in the past special characters were hard to input. This was generally because they were not on the keyboard, but in a few cases, they were not even in the code page!

So what use is this now, when modern keyboards have all the symbols we could want and we can use different encodings in source files?

Here is a screenshot of the C++ standard where it defines the allowed digraphs.

Digraphs in C++ Standard

C++ standard digraphs

The first column are backwards compatible digraphs for C. The next two columns are rather interesting.

For example. If you write the word or in a C++ source file, the compiler will replace that with ||. This means that the following code compiles and works.

int main() {
  bool a = false;
  bool b = true;
  std::cout << "a or b == " << (a or b) << std::endl;
  return 0;

Not only will this work for built in types, this works for user defined operators too. This is because the compiler simply substitutes the symbols.

Here is an example class and calling code which uses all the C++ digraphs.


This is just a stub class which defines a lot of operators which do nothing.

class Example {

  // logic operators
  bool operator&&(const Example& t) {
    return true;
  bool operator||(const Example& t) {
    return true;
  bool operator!() {
    return true;
  // bitwise operators
  bool operator&(const Example& t) {
    return true;
  bool operator|(const Example& t) {
    return true;
  bool operator^(const Example& t) {
    return true;
  bool operator~() {
    return true;
  // logic equals operators
  Example operator&=(const Example& t) {
    return t;
  Example operator|=(const Example& t) {
    return t;
  Example operator^=(const Example& t) {
    return t;
  Example operator!=(const Example& t) {
    return t;

Calling Code

int main() {
  bool a = true;
  bool b = true;
  if (a and b) {
    cout << "\"and\" is an operator." << endl;
  if (false or b) {
    cout << "\"or\" is also an operator." << endl;
  if (not false) {
    cout << "\"not\" is also an operator." << endl;

  Example t_1, t_2;
  if (t_1 and t_2) {
    cout << "\"and\" even works for classes" << endl;
  if (t_1 or t_2) {
    cout << "\"or\" even works for classes" << endl;
  if (not t_1) {
    cout << "\"and\" even works for classes" << endl;
  if (t_1 bitand t_2) {
    cout << "\"bitand\" also works for classes" << endl;
  if (t_1 bitor t_2) {
    cout << "\"bitor\" even works for classes" << endl;
  if (compl t_1) {
    cout << "\"compl\" even works for classes" << endl;
  if (t_1 xor t_2) {
    cout << "\"xor\" even works for classes" << endl;
  t_1 and_eq t_2;
  cout << "\"and_eq\" even works for classes" << endl;
  t_1 or_eq t_2;
  cout << "\"or_eq\" even works for classes" << endl;
  t_1 xor_eq t_2;
  cout << "\"xor_eq\" even works for classes" << endl;

  return 0;

This gives the output;

"and" is an operator.
"or" is also an operator.
"not" is also an operator.
"and" even works for classes
"or" even works for classes
"and" even works for classes
"bitand" also works for classes
"bitor" even works for classes
"compl" even works for classes
"xor" even works for classes
"and_eq" even works for classes
"or_eq" even works for classes
"xor_eq" even works for classes

This file can be found here.

This is an interesting feature, but is it useful?

I think it is, I think that the code;

if (not fail and ok) {
  // ...

Is more readable than;

if (!fail && ok) {
  // ...

However just because these are defined in the standard does not mean they can be used. These are largely considered a legacy part of the standard and there is limited support for it.

In particular Microsoft’s C++ compiler will not compile it. Both clang and g++ will compile it however, so if you are compiling using either of these you can use this nice feature.

Thanks for reading.


Keeping History Using the cd Command

If you use shell scripting a lot from the command line, this will probably improve your experience of it. This is for users of linux/mac command line or of cygwin on windows. Anywhere you can use the bash cd command.

Firstly (if you didn’t know) cd remembers the last directory you went to. To access this use;

cd -

This will change to the previous directory you were in. If you want to supercharge this you can add the following to your .bashrc/.profile/… customization file.

# petar marinov, http:/, this is public domain
cd_func ()
  local x2 the_new_dir adir index
  local -i cnt

  if [[ $1 ==  "--" ]]; then
    dirs -v
    return 0

  [[ -z $1 ]] && the_new_dir=$HOME

  if [[ ${the_new_dir:0:1} == '-' ]]; then
    # Extract dir N from dirs
    [[ -z $index ]] && index=1
    adir=$(dirs +$index)
    [[ -z $adir ]] && return 1

  # '~' has to be substituted by ${HOME}
  [[ ${the_new_dir:0:1} == '~' ]] && the_new_dir="${HOME}${the_new_dir:1}"

  # Now change to the new dir and add to the top of the stack
  pushd "${the_new_dir}" > /dev/null
  [[ $? -ne 0 ]] && return 1

  # Trim down everything beyond 11th entry
  popd -n +11 2>/dev/null 1>/dev/null

  # Remove any other occurence of this dir, skipping the top of the stack
  for ((cnt=1; cnt <= 10; cnt++)); do
    x2=$(dirs +${cnt} 2>/dev/null)
    [[ $? -ne 0 ]] && return 0
    [[ ${x2:0:1} == '~' ]] && x2="${HOME}${x2:1}"
    if [[ "${x2}" == "${the_new_dir}" ]]; then
      popd -n +$cnt 2>/dev/null 1>/dev/null

  return 0

alias cd=cd_func

This means that you can keep a history of the past 10 directories which you have visited and change between them.

To access this list type

cd --

Which will print a list like.

0  /e/projects/dgc/or14126h_3
1  /e/projects/dgc/or14126h_3/
2  /c/Users/dgc/Dropbox/Coding
3  /e/projects/dgc
4  /e/projects/dgc/or14126h_2
5  /e/devdisk/dcm/configs
6  /e/devdisk/dcm
7  /e/devdisk
8  /e

And then

cd -5

will take you to entry 5 in the list.

To be clear I did not write this, I found it in the default cygwin .bashrc. The author of this was Petar Marinov.

I have found this very helpful, particularly when using a new python module. This is the process;

  • I would be in my working area
  • download it from pypi
  • cd to my download area
  • untar it
  • cd into it
  • run python install
  • then want to go back but cd – would get me to my download area.

This function removes that minor inconvenience and I have found it very useful.

Thanks for reading.


Unusual C++ use of #include

Muhamad Hesham's T-Blog


The usual use is to write it at the very top of your .h/.cpp files to include other header files like (Windows.h, iostream, cstdio, etc..) to use the what is defined inside in your .h/.cpp file.

The unusual use is to use it to initialize a data-structure like arrays by including a text file that contains the array initialization data between the array initializer list parentheses – e.g XX XXX[] = { <HERE> }. This is is illustrated in the sample program below. The same concept can be used to initialize an array of any dimension.

// main.cpp
#include <cstdio>
#include <Windows.h>

struct Person
    char        *pName;
    unsigned    Age;
    unsigned    Height;
    char        Gender;

// Declare and initialize a 1D array of Persons structs using PersonTableData text file
// #include "PersonsTableData" will be expanded at COMPILE TIME to the content of PersonsTableData file
Person PersonsTable[] = {
    #include "PersonsTableData"

View original post 73 more words


Resource Acquisition is Initialization (RAII)

This post will be about the Resource Acquisition is Initialization (RAII) pattern which is a creational pattern. This is going to be the first non Gang of Four pattern I will write about.

The Purpose

The idea behind this pattern is to correctly dispose of all the resources that you acquire. This pattern was first written about by Bjarne Stroustrup, the creator of C++. The most common examples of this pattern are in opening and closing files and web sockets. It is also important in controlling mutexes so you can write tread safe code.

Continue reading ‘Resource Acquisition is Initialization (RAII)’


Comparisons in C++

This is about the comparison operators in C++ and making them easy to implement. There are 6 comparison operators in C++; ==, !=, <, <=, >, and >=. If you want to be able to apply all of these to a class, and you have the right type of order, you only need to implement one function which will determines them all. Incidentally this is called a total order, but I won’t go into what that means here.

The tl;dr of this is look at this repository and use a class from there to easily implement custom comparison operators.

This idea is to map the order onto the real numbers (doubles). So you have a function which takes two instances of a class and returns a double. If this function returns a negative number then the first instance is less than the second, if it returns 0 they are equal and if it returns a positive number then the first instance is greater than the second.

This will be easier to see with an example, so here is a class which is just data storage for an int.

Continue reading ‘Comparisons in C++’


C++ Sandbox

This is just a short post to tell you about my C++ sandbox. This is my area for trying out ideas (such as using mutable for caching) or testing C++ 11 features.

This is stored as a mercurial repository on bitbucket here. Please feel free to have a look or add to it if you have something you want to try out. I often use this to test answers to stackoverflow questions. A few of them have generated blog posts here as well.

The rest of this post is the current contents of the repository with a brief description of what I was trying to do with each file.


In this file I was playing around with C style arrays, slightly old and a bit dated to be honest.


This may be a future post here. It defines a templatised base class for comparable class (using the curiously recurring template pattern . It means that if you inherit from this class and define one compare function, you get all 6 comparison operators.


Testing out what you can do with const pointers. With a const Class* const you can only call const methods, with a Class* const you can call anything (this keeps the pointer const not what it points at) and with a Class* you can call anything.


Found an unusual bug and tested it here. If you have a reference (or a pointer) as a member of your class, in a const function you can call non-const functions on the member. This is because it doesn’t change the reference (or pointer) which the class keeps, what it does is change is the object it references.


Trying to copy a reference without using the copy constructor or assignment operator.


I wondered what compiler errors/warnings you get from dividing by zero?
It turns out (in g++) that it will not give errors at all. It will warn you if you divide by a literal zero or a const zero, but not a variable with value zero.


This was for checking the results of using xor on integers.


This was testing the newly added lambda functions, but changed to using standard template library algorithms.


This was playing around with pure virtual functions with implementations. So you can call them using Base::function() in the derived class.


Testing using a mutable member for data caching. This was the basis for the blog post mutable and data caching.


Testing calling operator() on pointer. Here is the calling code.

  Foo* f = new Foo();

  delete f;

A common mistake doing this is to leave off the final brackets so.


But these will return a function pointer to operator(), they won’t call it.


Archetypal polygon example for inheritance. A base polygon, a derived rectangle and triangle. Not great as you use a width and height for the polygon but not all polygons have it. Also I prepended all the classes with the letter C and allocated the instances as pointers to the base class.


Trying to make an executable to delete itself, unsurprisingly this doesn’t work.


Something picked up from a dirty programming trick called the programming antihero (if you haven’t read that article I can’t recommend it enough!). In this there was a game programmer who reserved 2Mb of memory to lose later when memory was tight. I was testing to see how this worked by reserving some memory and checking memory usage. It is had to see the exact memory usage from this sort of thing due to differences in types of memory (i.e. private bytes/working set…) but it certainly took some memory.


Testing out the differences between structs and classes in C++. I found that apart from private/public as default there is no difference! This includes if you declare class T in a template, you can still use a struct.

UserDefinedLiterals and UserDefinedLiteralsBinary

Trying to use C++ 11 user defined literals to be able to use syntax like this:

  Binary two = 10_b;

I was following a good guide from here.


Quite a complicated file. I was trying to use variadic templates to access private methods of a class. Hopefully not of any practical use (it breaks encapsulation and is extremely fragile) but an interesting idea to try,


Unimplemented test for SetEvent() in windows.h.


Made to test getenv from cstdlib for getting environmental variables.


Using C preprocessor magic to join together variable names.


Given an amount in cents (American currency as it was taken from an answer on stackoverflow) find the number of ways you can make it from quarters, dimes, nickles and pennies. This was taken from this answer.


I didn’t think the reply to this question would compile so I tried it out. I realised you can override private virtual functions but not call them.


My thoughts about the answer to this stackoverflow question being wrong, and my idea for a better way.

As always thanks for reading.


Iterator Pattern

This post will be about the Iterator pattern which is a behavioural pattern.

The Purpose

The idea behind this pattern is to have an object which you can loop over without needing to know the internal representation of the data. While in python nothing is private so you can find out the internals of the class, the iterator pattern gives you a standard interface.

Continue reading ‘Iterator Pattern’