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.

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.

Class

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

//=============================================================================
class Example {
public:

  //===========================================================================
  // 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.