Modern C++ in practicePart 2

Today

Generic programming introductionLearn & code some generic design patterns

Goals

Practical experience of

•C++ best practices, idioms and details•Design patterns in C++•Generic, functional and template programming•Using boost and STL•Utilize APIs, books and mailing lists

Coherent coding style and get to know each other

Past•RAII•Boost candy•Higher order programming•Workshops, variant+signals

Future•Modelling static or dynamic?•”Prepone” error detection•Template metaprogramming introduction•Working with namespaces•Free functions over classes•Exception safe code•Event driven architecture•Dive deeper: boost, STL, template metaprogramming, generic programming•Something else?

C++ - a multiparadigm language•Procedural programming•Object oriented programming•Generic programming•Functional programming•Embedded DSLs•Template metaprogramming•Macro metaprogramming

Know and blend these paradigms Generic programming is especially important

OO is just one paradigm

”I find OOP methodologically wrong”Alexander Stepanov

”Objects are a poor man’s closures”Norman Adams

”... what society overwhelmingly asks for is snake oil. Of course, the snake oil has the most impressive names —otherwise you would be selling nothing— like ... "Object Orientation" ...”

Edsger W. Dijkstra

What is generic programming•Orthogonality•Encapsulate the essence of a problem•Very high degree of reusability

”Commit to abstractions, not to details: Use the mose generic and abstract means to implement a piece of functionality”

C++ coding standards #67

Why bother learning

Larger design space => more sweetspotsEncapsulate error prone codeC++ 0xDifferent perspectiveWill spread to other languages

Very simplified...

OO programming builds on run-time polymorphismGeneric programming builds on compile-time polymorphism

Polymorphism revisited

Run-time polymorphism through explicit interfaces

class FooType { virtual void bar() = 0; };

void foo(FooType& t) { t.bar(); }

Compile-time polymorphism through ”implicit interfaces”

template<class T>

void foo(T& t) { t.bar(); }

The STL

Laid the foundation of generic programming in C++

Alexander Stepanov first introduced GP in Ada

STL•Containers•Iterators•Algorithm•Functors

Concepts•Valid expressions•Associated types•Invariants•Complexity guarantees

Types which satifies requirements models the conceptConcepts can be refined

Surf time!

Review iterator concepts at

http://www.sgi.com/tech/stl/table_of_contents.html

Hack time!

Generalize memcpy

void* memcpy(void* region1, const void* region2, size_t n)

{

const char* first = (const char*)region2;

const char* last = ((const char*)region2) + n;

char* result = (char*)region1;

while (first != last) *result++ = *first++;

return result;

}

Memcpy generalizedtemplate <typename InputIterator, typename OutputIterator>

OutputIterator copy(InputIterator first, InputIterator last,

OutputIterator result)

{

while (first != last) *result++ = *first++;

return result;

}

Hack time!

Implement

www.sgi.com/tech/stl/find_if.html

How to apply GP

Apply at generic layers and architectureDon’t be overly specificSpread conventions

Second part

Get familiar with generic design techniques

Introduce, code small example, surf APIs

Time for a break?

Object generatorsUse template type deduction to construct unnamed temporaries

std::make_pairboost::bind

template <class T> foo(T t);

foo(std::pair<unsigned int, std::multimap<unsigned int, std::string> >(0, it));

foo(std::make_pair(0,it));

Hack time!

Implement make_shared_ptr

Type traits

Associates information with a compile time entity

Non-intrusive templated classUses partial template specializationNever instantiated

Ehh...What the *beep*?

Example usagetemplate <class Iterator> struct iterator_traits { typedef typename Iterator::value_type value_type;

typedef typename Iterator::difference_type difference_type; ... Some other things

};

template<class Iterator>void my_algorithm(Iterator begin, Iterator end){... iterator_traits<Iterator>::value_type copy_of_first_element = *begin;...}

To write your own iterator•Specialize std::iterator_traits•Or provide the required typedefs

Example implementationtemplate <typename T>

struct is_void : public false_type{};

template <>

struct is_void<void> : public true_type{};

Surf time!

Let’s have a look at some usages of type traits

www.boost.org/doc/html/boost_typetraits/examples.html

Then let’s look at what boost::type_traits contains

www.boost.org/doc/html/boost_typetraits/category.html

Hack time!template <class Iterator> struct iterator_traits {

typedef typename Iterator::iterator_category iterator_category; typedef typename Iterator::value_type value_type; typedef typename Iterator::difference_type difference_type; typedef typename Iterator::pointer pointer; typedef typename Iterator::reference reference;

};

Implement raw pointer specialization of iterator_traits

Tag dispatching

Dispatch function calls depending of type properties

Uses function overloading to do so

Type traits class often provide tags

Tag dispatchingstruct input_iterator_tag{};

struct random_access_iterator_tag{};

namespace detail {

template<class InputIterator, class Distance>

void advance_impl(InputIterator& i, Distance n, input_iterator_tag) {...}

template<class RandomAccessIterator, class Distance>

void advance_impl(RandomAccessIterator & i, Distance n,

random_access_iterator_tag) {...}

}

template<class InputIterator, class Distance>

void advance(InputIterator& i, Distance n)

{

typedef typename iterator_traits<InputIterator>::iterator_category category;

detail::advance_impl(i, n, category);

}

Tag dispatching

Appears in STL & boost – important to know

Curiously Recurring Template Patternclass Derived : public Base<Derived>

Example

class Y: public boost::enable_shared_from_this<Y>

Hack time!

Use CRTP implement an instance counter

CRTP as abstract base classtemplate <class Derived> struct Base { void interface() { .. static_cast<Derived&>(*this).implementation(); ... } };

struct Derived : public Base<Derived> {

void implementation();};

Derived needn’t implement an interface, only model a concept

Policy based class design

Reminds you of aspect oriented development

Break classes down to small orthogonal pieces

Encapsulate a design space, allow users to do the trade offs

Policy example

struct ThrowError { void handle_error(int line_nr, const std::string& s) { throw std::exception(s); }};

struct AssertError { void handle_error(int line_nr, const std::string& s) { assert(false); }};

struct LogError { void handle_error(int line_nr, const std::string& s) { log(s); }};

struct IgnoreError { void handle_error(int line_nr, const std::string& s) {}};

template <class ErrorHandlingModel=LogError>class Foo : public ErrorHandlingModel{ void bar() { if (condition_xxx) handle_error(__LINE__, ”Error, XXX occurred”); }};

Policy example

struct MultiThreadedModel {protected: typedef boost::thread::mutex mutex; mutex m_mutex;};

struct SingleThreadedModel {protected: struct mutex { // Dummy class struct scoped_lock { scoped_lock(mutex) {} }; }; mutex m_mutex;};

template <class ErrorHandlingModel, class ThreadingModel>class Foo : public ErrorHandlingModel { void bar() { typename ThreadingModel::mutex::scoped_lock lock(m_mutex); if (condition_xxx) handle_error(__LINE__, ”Error, XXX occurred”); }};

Hack time!template<class ValueType,

class ValueDescription,

class ThreadingModel,

class LifeTimeModel>

class Cache

{

boost::shared_ptr<ValueType> get(const ValueDescription& description);

};

Use new ValueType(ValueDescription) for creationThread safe or notDestroy or cache not used resources

Policy classesPolicy classes can also be used to extend interfaces

How would you change the following class to allow asynchronous delivery?

class MessageChannel

{

template<class Msg>

void send(const Msg& msg) const;

template<class Msg>

const Signal<void(const Msg&)>& get_signal() const;

};

Hack time!template<class T> struct ImmediateDeliveryModel {protected: template <class Msg> void on_message(const Msg& msg);};

template<class T> class RequestedDeliveryModel {public: void deliver();protected: template<class Msg> void on_message(const Msg& msg);};

template <template <class> DeliveryModel>class MessageChannel : public DeliveryModel<MessageChannel> // CRTP{public: template<class Msg> void send(const Msg& msg) { on_message(msg); }protected: template<class Msg> void deliver_impl(const Msg& msg);};

Policy based class design

Extend interface, add state, add compile time entitesNeed not be entirely orthogonalCan pass policies on to internal subclasses

Book tip: Modern C++ Design

Break?

Surf time!

Let’s have a look at a policized class

svn.boost.org/svn/boost/sandbox/flyweight/libs/flyweight/doc/

Policies vs traitsType traits and policies are only instantiated as base-classesNeither type traits nor policy inheritance model IS-A

Policies can add state, type traits doesn’tPolicies can extend interfaces, type traits has no functions

Type traits is pure, compile time, entity -> information mappingYou can use type traits as policy parameters to model concepts

SFINAE

template<class IntType>

IntType triple(IntType i)

{ return 3*i; }

void foo()

{

triple(”hej!”);

}

SFINAE

Substitution Failure Is Not An Error

template<bool, typename T = void>

struct enable_if {};

template<typename T>

struct enable_if<true, T> { typedef T type; };

template<class T>

enable_if<is_integral<T>::type, T>::type

triple(T t) { ... }

SFINAE

If you ever need to limit a function template

www.boost.org/libs/utility/enable_if.html

Problem 1 Giving away too much information// Models Containerclass MyClass{private: typedef std::vector<int> InternalCollection; public: typedef InternalCollection::iterator iterator; ...};

void user_code(){ MyClass a; int size = a.end() – a.begin(); // compiles cleanly, violates

promises}

Problem 2 Requiring user code is templatedtemplate <class T> class Foo { Foo(const T& t); void bar(); void baz();

void monkey(T t);};

template <class T> void user_code(Foo<T>& foo){ foo.bar(); foo.baz();}

Solution: Type Erasureclass Foo { virtual void bar() = 0; virtual void baz() = 0;};

template <class T> class FooImpl : public Foo{ Foo(const T& t);

void bar(); void baz();

void monkey(T t);};

void user_code(Foo& foo);

Solution to problem 1

template< class Value,

class CategoryOrTraversal,

class Reference = Value&,

class Difference = std::ptrdiff_t >

class any_iterator;

Hack time!

Implement void_function

•Compatible with free functions•Compatible with other functors•Provide uniform type

Erase which type it was constructed from

Problems with concepts

Until C++0x comes, we have the following problems

•Incorrect arguments generate difficult error messages•The documented requirements might not cover everything•Code and documentation might drift out of sync

Reminder

The Boost Concept Checking Library provides:

•A mechanism for inserting compile-time checks•A framework for specifying concept requirements•A mechanism for verifying concept coverage•Concept checking and archetype classes for STL concepts

Concept checks to help code usersArchetype checks to help require correct concepts

Surf time!

Let’s refresh our memory

www.boost.org/libs/concept_check/using_concept_check.htm

A taste of Metaprogrammingtemplate <unsigned long N>struct binary{ static const unsigned long value = binary<N/10>::value*2 + N%10;};

template <>struct binary<0>{ static const unsigned long value = 0;};

binary<101>::value

Summary first part

C++ is a multiparadigm language

GP+OO can achieve simplified, robust, decoupled systems

Concepts consists of•Invariants•Valid expressions•Associated types•Complexity guarantees

Summary second partQuick taste of some patterns

•Object generators•Type traits•Tag dispatching•CRTP•Policy classes•SFINAE•Type erasure•Concept checking

Get familiar with, not master

Thanks for listening

Slides available at

twiki.gameop.net/twiki/bin/view/Main/ModernC++InPractice