Close shaves: the complete book of razor fighting by Bradley Steiner

Show description

Significant slowdowns can result indirectly in compiled code, however, because the indirection may prevent an optimizing compiler from inlining the function and from applying subsequent optimizations to the surrounding code after inlining. Of course the overall impact of the overhead is entirely dependent on the amount of work done in the function—that is, how much the overhead will be amortized. For components at the level of the STL iterators and containers, or at the level of graph iterators, function call overhead is significant.

An archetype class provides a minimal implementation of a concept. To check whether a concept covers an algorithm, the archetype class for the concept is instantiated and passed to the algorithm. The following example program attempts to verify that the requirements of std::sort() are covered by an iterator that models RandomAccessIterator having a value type modeling LessThanComparable. hpp> int main() { using namespace boost; typedef less than comparable archetype<> T; random access iterator archetype ri; std::sort(ri, ri); } In fact, this program will not successfully compile because those concepts do not cover the requirements that std::sort() makes of its template parameters.

For each concept, the BCCL provides a concept-checking class, such as the following concept-checking class for LessThanComparable. The required valid expressions for the concept are exercised in the constraints() member function. template struct LessThanComparableConcept { void constraints() { (bool)(a < b); } T a, b; }; The concept-checking class is instantiated with the user’s template arguments at the beginning of the generic algorithm using the BCCL function requires(). hpp> template void safe sort(Iterator first, Iterator last) { typedef typename std::iterator traits::value type T; function requires< LessThanComparableConcept >(); // other requirements .