Higher Level C++ with the Boost Libraries—Dave Abrahams

Save to:
Instapaper Pocket Readability

Higher-Level C++ with the Boost Libraries

Dave Abrahams, BoostPro Computing

Contact info@boostpro.com for further details

The Boost library collection has become the de-facto standard toolkit for serious C++ development projects.

What You'll Get: new tools, revolutionary ideas, and a foundation upon which to continue expanding their knowledge.

Who It’s For: C++ developers who want to accelerate their work using high-quality infrastructure.

Format: Each day is divided roughly into four blocks, each consisting of an hour of lecture and thirty minutes of hands-on exercises. Ideally presented as a 5-day course, it is scalable to 3 days based on your team’s needs.

Structure: the scope of Boost is broad, so it is important to cover a subset of the collection that is both useful and relevant to your team. We will customize a selection of course modules that address your group’s needs, experience, and short- and long-term needs.

Suggested Course Modules

The modules below represent some suggested groupings of similar/related libraries, based on size, domain, and utility. Some libraries don’t fit neatly into one particular module, and the list of Boost libraries is constantly growing, so be sure to let us know if you want something you can't find here.

  • The Boost Core: presents a broad array of generally-useful libraries and introduces “vocabulary components and idioms” that are used throughout other libraries in Boost and in the C++11 standard. Recommended for all presentations of this course.
  • The Boost Graph Library: concepts, algorithms, data structures, theory and practice.
  • Computational Geometry with Boost: covers Boost.Geometry and Boost.Polygon.
  • Networking and Async Services: showcases Boost.ASIO and gets inside the “network programming head-space,” showing design patterns that can make this kind of code tight, maintainable, and efficient.
  • Boost Concurrency and HPC: covers both the issues inherent in concurrent systems and a suite of libraries in Boost that can help you solve them.
  • Algebraic Data Types: describes a highly-generic and introspectable way of working with data using the Boost Tuple, Variant, Optional, and Fusion libraries.
  • Image Processing: covers the powerful Boost.GIL library
  • Testing and Correctness: discover the Boost tools for writing rock solid code. Shows how to manage uncertainty and makes it possible to code with confidence.
  • Boost for Numerical Computing: covers the Boost.Math, Boost.Interval, Boost.Random, Boost.Accumulators and more, including several important offerings outside the Boost collection.
  • Functional Programming: aimed at C++03 programmers (who don’t have true lambda expressions) and at C++11 programmers desiring more power to create and manipulate functions.
  • Thinking Hybrid with Boost.Python: covers everything needed to flow smoothly between Python and C++, small- and large-scale development, extending Python, and embedding it in C++ programs.
  • Text Processing with Boost: develop fluency with the vocabulary of Boost's many text processing libraries and learn how to apply them effectively.
  • Metaprogramming Concepts and Frameworks: 
A compressed, high-intensity subset of our 5-day metaprogramming course, covering Boost.MPL, Boost.Fusion, and Boost.Proto, among others.

Add a Comment

Comments are closed.

Comments (2)

1 1

Algocoders said on Jan 16, 2013 09:12 AM:

Where do I get to see the concepts getting implemented strictly using C++11 language and library features? I will prefer a simple library to start using it right away.

I was referring to the famous paper "A Concept Design for the STL" by Dr. Bjarne Stroustrup, which inspired me to dive into Origin C++ Libraries, which is an implementation using C++11. I ended up collating the ideas with our experiments to put these into work in my book : "Foundation of Algorithms in C++11, Volume 1 : Using And Extending C++11, Boost And Beyond". But to go further, we need a complete set-up for C++11 concepts and Origin libraries are still very incomplete and experimental in nature.Can someone point to a library, which is put to practice? Any pointer will be very helpful.

For people interested to look at our work :
Revised edition of the C++11 Cookbook : "Foundation of Algorithms in C++11, Volume 1(Revised Edition): Using and Extending C++11, Boost And Beyond" : is available now.



To be clear, I do not mean "C++ Concepts & Axioms" which (as originally proposed) cannot be fully implemented as a library feature.

For example, the paper "A Concept Design of STL" proposes the following interface for the STL Algorithm "std::copy_backward":

template<BidirectionalIterator I, BidirectionalIterator Out>
requires IndirectlyCopyable<I, Out> Out copy_backward(I first, I last, Out result);

which cannot be implemented using just library features.

So I reduced it to look like the following :

template<typename I, typename I>
requires<IndirectlyCopyable<I, Out>() && Bidirectional_Iterator<I>()>
Out copy_backward(I first, I last, Out result);

This I was able to get it easily using sfinae feature : enable_if. But I was looking for something like this in a form of a full blown C++11 library.

Using template alias and sfinae, simulation of requires may look like :

#include <type_traits>
template <bool Condition, typename T = void>
using requires = typename std::enable_if<Condition, T>::type;

And the Conditions being passed to requires can be simulated using the language feature "constexpr" like:

template <typename I, typename Out>
constexpr bool IndirectlyCopyable() { ...}

template <typename I>
constexpr bool Bidirectional_Iterator() { ...}

So, all I am looking for a C++11 library, which fully implement C++11 Algorithms using Concepts as part of algorithm's interface as in :

template<typename I, typename I>
requires<IndirectlyCopyable<I, Out>() && Bidirectional_Iterator<I>()>
Out copy_backward(I first, I last, Out result);


template<typename I, typename I>
auto copy_backward(I first, I last, Out result)
-> requires<IndirectlyCopyable<I, Out>() && Bidirectional_Iterator<I>(), Out>;

or something similar. Origin C++ library has similar components in place, but it is still a work in progress. Boost.Contract(Contract++) takes a different approach to simulate the above.

Does any one know of any such library in use?

Thanks a lot in advance.

0 0

NoSenseEtAl said on Jul 5, 2013 01:40 AM:

Amazon reviow of "your" "book":

Don't buy this book. If you're interested in the topics covered, you would be better served by reading the original sources. While the authors have taken the time to reproduce code, text, and images from those sources, they have neglected to credit the original authors, preserve copyright notices, or adhere to the licenses of the copied material. Beyond the obvious plagiarism and copyright violations, the writing and presentation is terrible.

The entirety of Chapter 7 appears to have been taken directly from the implementation of the Origin C++ Libraries ([...])---my project---without any reference to the original source. Not only does the book include misappropriated code and text, its presentation is, at best, misleading. The authors fail to note that the work is purely experimental and have managed to uphold some of the library's darkest corners as elements of good design.

Other parts of the book summarize or copy parts of the "A Concept Design for the STL", which is freely available as a WG21 document ([...]). It's a good read, free, and written by experts. The same can be said of every other library referred to or borrowed from in this book (Loki, Boost, LibC++). To say that I am extremely disappointed in this book would be a great understatement.