C++ Core Guidelines: Rules for the Definition of Concepts

15 October 2018

Contents[Show]

Although rule T.11 states: Whenever possible use standard concepts you sometimes have to define your concepts. This post gives you rules to do it.

definition 390785 1280

The C++ core guidelines has nine rules for defining concepts. Seven of them have content. Here are the first four for today.

Let's see how to define concepts

T.20: Avoid “concepts” without meaningful semantics

This rule is quite obvious but what does meaningful semantic mean. Meaningful semantics are not just simple constraints such as has_plus but concepts such as Number, Range, or InputIterator.

For example, the following concept Addable requires has_plus and is, therefore, also fulfilled by a string.

template<typename T>
concept Addable = has_plus<T>;    // bad; insufficient

template<Addable N> auto algo(const N& a, const N& b) // use two numbers
{
    // ...
    return a + b;
}

int x = 7;
int y = 9;
auto z = algo(x, y);   // z = 16

string xx = "7";
string yy = "9";
auto zz = algo(xx, yy);   // zz = "79"

I assume this was not your intention because the function template algo should accept arguments which model numbers and not just addable. The solution is quite simple. Define and use a concept Number with a meaningful semantic.

template<typename T>
// The operators +, -, *, and / for a number 
// are assumed to follow the usual mathematical rules
concept Number = has_plus<T>
                 && has_minus<T>
                 && has_multiply<T>
                 && has_divide<T>;

template<Number N> auto algo(const N& a, const N& b)
{
    // ...
    return a + b;
}

Now the invocation of algo with a string would give an error. The next rule is a particular case of this rule.

T.21: Require a complete set of operations for a concept

First of all, what is a complete set of operations? Here are two complete sets for Arithmetic and Comparable.

Arithmetic: +, -, *, /, +=, -=, *=, /=
Comparable: <, >, <=, >=, ==, !=

Do you want for what the acronym POLA stands for? It stands for Principle Of Least Astonishment. You can quite easily break this principle of good software design if you implement just a partial set of operations.

Here is a very promising example from the guidelines. The concept Minimal in this case supports==, < and +.

void f(const Minimal& x, const Minimal& y)
{
    if (!(x == y)) { /* ... */ }    // OK
    if (x != y) { /* ... */ }       // surprise! error

    while (!(x < y)) { /* ... */ }  // OK
    while (x >= y) { /* ... */ }    // surprise! error

    x = x + y;          // OK
    x += y;             // surprise! error
}

T.22: Specify axioms for concepts

First of all: What is an axiom? Here is my definition from Wikipedia:

An axiom or postulate is a statement that is taken to be true, to serve as a premise or starting point for further reasoning and arguments.

Because C++ does not support axioms, you have to express them with comments. If C++ does support them in the future, you can remove the comment symbol // in front of the axiom in the following example.

template<typename T>
    // axiom(T a, T b) { a + b == b + a; a - a == 0; a * (b + c) == a * b + a * c; /*...*/ }
    concept Number = requires(T a, T b) {
        {a + b} -> T;  
        {a - b} -> T;
        {a * b} -> T;
        {a / b} -> T;
    }

The axiom means in this case that the number follow the mathematical rules. In contrast, the concept requires that a Number has to support the binary operations +, -, *, and / and that the result is convertible to T. T is the type of the arguments.

T.23: Differentiate a refined concept from its more general case by adding new use patterns

If two concepts have the same requirements, they are logically equivalent. This means the compiler can't distinguish them and, therefore, may not choose automatically the correct one during overload resolution.

To make the rule clear, here is a simplified version of the concept BidirectionalIterator and the refined concept RandomAccessIterator.

template<typename I>
concept bool BidirectionalIterator = ForwardIterator<I> && 
                                     requires(I iter){ 
                                         --iter;  
                                         iter--; 
                                     }  

template<typename I>
concept bool RandomAccessIterator = BidirectionalIterator<I> && 
                                    Integer<N> &&
                                    requires(I iter, I iter2, N n){
                                        iter += n;               // increment or decrement an iterator
                                        iter -= n;
                                        n + iter;                // return a temp iterator
                                        iter + n;
                                        iter - n; 
                                        iter[n];                 // access the element
                                        iter1 - iter2;           // subtract two iterators
                                        iter1 < iter2;           // compare two iterators 
                                        iter1 <= iter2;
                                        iter1 > iter2;
                                        iter1 >= iter2;
                                    }

std::advance(i, n) increments a given iterator i by n elements. Depending on the value of n, the iterator is incremented or decremented. When the iterator i is a bidirectional iterator, std::advance has to step n times one element forwards or backwards. But when the iterator i is a random access iterator, just n is added to the iterator.

template<BidirectionalIterator I>
void advance(I& iter, int n){...}

template<RandomAccessIterator I>
void advance(I& iter, int n){...}

std::list<int> lst{1, 2, 3, 4, 5, 6, 7, 8, 9};
std::list<int>::iterator listIt = lst.begin();
std::advance(listIt, 2);   // BidirectionalIterator

std::vector<int> vec{1, 2, 3, 4, 5, 6, 7, 8, 9};
std::vector<int>::iterator vecIt = vec.begin();
std::advance(vecIt, 2);    // RandomAccessIterator

In case of the std::vector<int>, vec.begin() returns an random access iterator and, therefore, the fast variant of std::advance is used.

Each container of the STL creates an iterator specific to its structure. Here is the overview:

IteratorCategories

What's next?

Three rules to the definition of concepts are left. In particular, the next rule "T.24: Use tag classes or traits to differentiate concepts that differ only in semantics." sound quite interesting. Let's see in the next post what a tag class or traits class is.

Thanks a lot to my Patreon Supporters: Eric Pederson, Paul Baxter, Meeting C++, Matt Braun, Avi Lachmish, Roman Postanciuc, Venkata Ramesh Gudpati, Tobias Zindl, Mielo, and Dilettant.

Thanks in particular to:

Get your e-book at Leanpub:
The C++ Standard Library	Concurrency With Modern C++	Get Both as one Bundle

With C++11, C++14, and C++17 we got a lot of new C++ libraries. In addition, the existing ones are greatly improved. The key idea of my book is to give you the necessary information to the current C++ libraries in about 200 pages.	C++11 is the first C++ standard that deals with concurrency. The story goes on with C++17 and will continue with C++20. I'll give you a detailed insight in the current and the upcoming concurrency in C++. This insight includes the theory and a lot of practice with more the 100 source files.	Get my books "The C++ Standard Library" (including C++17) and "Concurrency with Modern C++" in a bundle. In sum, you get more than 600 pages full of modern C++ and more than 100 source files presenting concurrency in practice.