Boost-Commit :

Date view	Thread view	Subject view	Author view

From: daniel_james_at_[hidden]
Date: 2007-11-11 14:14:35

Author: danieljames
Date: 2007-11-11 14:14:34 EST (Sun, 11 Nov 2007)
New Revision: 41012
URL: http://svn.boost.org/trac/boost/changeset/41012

Log:
Move several C++ related articles to the new site.

Fixes #1343, #1344, #1347, #1352, #1353.

Removed:
   trunk/more/count_bdy.htm
   trunk/more/cpp_committee_meetings.html
   trunk/more/error_handling.html
   trunk/more/generic_exception_safety.html
   trunk/more/generic_programming.html

Deleted: trunk/more/count_bdy.htm
==============================================================================
--- trunk/more/count_bdy.htm 2007-11-11 14:14:34 EST (Sun, 11 Nov 2007)
+++ (empty file)
@@ -1,774 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<html>
-<head>
- <meta http-equiv="Content-Language" content="en-us">
- <meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
- <meta name="GENERATOR" content="Microsoft FrontPage 6.0">
- <meta name="Author" content="Kevlin Henney">
- <meta name="KeyWords" content=
- "C++, Reference Counting, Advanced Techniques, Smart Pointers, Patterns">
-
- <title>Counted Body Techniques</title>
-</head>
-
-<body bgcolor="#FFFFFF" text="#000000">
- <h1 align="center">Counted Body Techniques</h1>
-
- <center>
- Kevlin Henney 
- (<a href=
- "mailto:kevlin_at_[hidden]">kevlin_at_[hidden]</a>, <a href=
- "mailto:khenney_at_[hidden]">khenney_at_[hidden]</a>)
- </center>
-
- <div style="margin-left: 2em">
- Reference counting techniques? Nothing new, you might think. Every good
- C++ text that takes you to an intermediate or advanced level will
- introduce the concept. It has been explored with such thoroughness in the
- past that you might be forgiven for thinking that everything that can be
- said has been said. Well, let's start from first principles and see if we
- can unearth something new....
- </div>
- <hr width="100%">
-
- <h2>And then there were none...</h2>
-
- <div style="margin-left: 2em">
- The principle behind reference counting is to keep a running usage
- count of an object so that when it falls to zero we know the object is
- unused. This is normally used to simplify the memory management for
- dynamically allocated objects: keep a count of the number of references
- held to that object and, on zero, delete the object.
-
- How to keep a track of the number of users of an object? Well, normal
- pointers are quite dumb, and so an extra level of indirection is required
- to manage the count. This is essentially the PROXY
- pattern described in Design Patterns [Gamma, Helm, Johnson &
- Vlissides, Addison-Wesley, ISBN 0-201-63361-2]. The
- intent is given as
-
- <div style="margin-left: 2em">
- Provide a surrogate or placeholder for another object to control
- access to it.
- </div>
-
- Coplien [Advanced C++ Programming Styles and Idioms,
- Addison-Wesley, ISBN 0-201-56365-7] defines a set
- of idioms related to this essential separation of a handle and a body
- part. The Taligent Guide to Designing Programs [Addison-Wesley,
- ISBN 0-201-40888-0] identifies a number of specific
- categories for proxies (aka surrogates). Broadly speaking they fall into
- two general categories:
-
- <ul>
- <li>Hidden: The handle is the object of interest, hiding the body
- itself. The functionality of the handle is obtained by delegation to the
- body, and the user of the handle is unaware of the body. Reference
- counted strings offer a transparent optimisation. The body is shared
- between copies of a string until such a time as a change is needed, at
- which point a copy is made. Such a COPY ON WRITE
- pattern (a specialisation of LAZY EVALUATION) requires the use of a hidden reference counted
- body.</li>
-
- <li>Explicit: Here the body is of interest and the handle merely
- provides intelligence for its access and housekeeping. In C++ this is
- often implemented as the SMART POINTER idiom. One such application is that of reference
- counted smart pointers that collaborate to keep a count of an object,
- deleting it when the count falls to zero.</li>
- </ul>
- </div>
- <hr width="100%">
-
- <h2>Attached vs detached</h2>
-
- <div style="margin-left: 2em">
- For reference counted smart pointers there are two places the count can
- exist, resulting in two different patterns, both outlined in
- Software Patterns [Coplien, SIGS, ISBN
- 0-884842-50-X]:
-
- <ul>
- <li>COUNTED BODY or ATTACHED
- COUNTED
- HANDLE/BODY places the
- count within the object being counted. The benefits are that
- countability is a part of the object being counted, and that reference
- counting does not require an additional object. The drawbacks are
- clearly that this is intrusive, and that the space for the reference
- count is wasted when the object is not heap based. Therefore the
- reference counting ties you to a particular implementation and style of
- use.</li>
-
- <li>DETACHED COUNTED
- HANDLE/BODY places the
- count outside the object being counted, such that they are handled
- together. The clear benefit of this is that this technique is completely
- unintrusive, with all of the intelligence and support apparatus in the
- smart pointer, and therefore can be used on classes created
- independently of the reference counted pointer. The main disadvantage is
- that frequent use of this can lead to a proliferation of small objects,
- i.e. the counter, being created on the heap.</li>
- </ul>
-
- Even with this simple analysis, it seems that the DETACHED COUNTED HANDLE/BODY approach is ahead. Indeed,
- with the increasing use of templates this is often the favourite, and is
- the principle behind the common - but not standard - <tt>counted_ptr</tt>. [The Boost name is <a href=
- "../libs/smart_ptr/shared_ptr.htm"><tt>shared_ptr</tt></a> rather than <tt>counted_ptr</tt>.]
-
- A common implementation of COUNTED BODY is to provide the counting mechanism in a base class that
- the counted type is derived from. Either that, or the reference counting
- mechanism is provided anew for each class that needs it. Both of these
- approaches are unsatisfactory because they are quite closed, coupling a
- class into a particular framework. Added to this the non-cohesiveness of
- having the count lying dormant in a non-counted object, and you get the
- feeling that excepting its use in widespread object models such as COM and
- CORBA the COUNTED BODY
- approach is perhaps only of use in specialised situations.
- </div>
- <hr width="100%">
-
- <h2>A requirements based approach</h2>
-
- <div style="margin-left: 2em">
- It is the question of openness that convinced me to revisit the
- problems with the COUNTED BODY idiom. Yes, there is a certain degree of intrusion
- expected when using this idiom, but is there anyway to minimise this and
- decouple the choice of counting mechanism from the smart pointer type
- used?
-
- In recent years the most instructive body of code and specification for
- constructing open general purpose components has been the Stepanov and
- Lee's STL (Standard Template Library), now part of the C++ standard
- library. The STL approach makes extensive use of compile time polymorphism
- based on well defined operational requirements for types. For instance,
- each container, contained and iterator type is defined by the operations
- that should be performable on an object of that type, often with
- annotations describing additional constraints. Compile time polymorphism,
- as its name suggests, resolves functions at compile time based on function
- name and argument usage, i.e. overloading. This is less intrusive,
- although less easily diagnosed if incorrect, than runtime poymorphism that
- is based on types, names and function signatures.
-
- This requirements based approach can be applied to reference counting.
- The operations we need for a type to be Countable are loosely:
-
- <ul>
- <li>An <tt>acquire</tt> operation that registers
- interest in a Countable object.</li>
-
- <li>A <tt>release</tt> operation unregisters
- interest in a Countable object.</li>
-
- <li>An <tt>acquired</tt> query that returns
- whether or not a Countable object is currently acquired.</li>
-
- <li>A <tt>dispose</tt> operation that is
- responsible for disposing of an object that is no longer acquired.</li>
- </ul>
-
- Note that the count is deduced as a part of the abstract state of this
- type, and is not mentioned or defined in any other way. The openness of
- this approach derives in part from the use of global functions, meaning
- that no particular member functions are implied; a perfect way to wrap up
- an existing counted body class without modifying the class itself. The
- other aspect to the openness comes from a more precise specification of
- the operations.
-
- For a type to be Countable it must satisfy the following
- requirements, where <tt>ptr</tt> is a non-null
- pointer to a single object (i.e. not an array) of the type, and
- <tt>#function</tt> indicates number of calls
- to <tt>function(ptr)</tt>:
-
- <center>
- <table border="1" cellspacing="2" cellpadding="2" summary="">
- <tr>
- <td>Expression</td>
-
- <td>Return type</td>
-
- <td>Semantics and notes</td>
- </tr>
-
- <tr>
- <td><tt>acquire(ptr)</tt></td>
-
- <td>no requirement</td>
-
- <td>post: <tt>acquired(ptr)</tt></td>
- </tr>
-
- <tr>
- <td><tt>release(ptr)</tt></td>
-
- <td>no requirement</td>
-
- <td>pre: <tt>acquired(ptr) </tt>
- post: <tt>acquired(ptr) == #acquire -
- #release</tt></td>
- </tr>
-
- <tr>
- <td><tt>acquired(ptr)</tt></td>
-
- <td>convertible to <tt>bool</tt></td>
-
- <td>return: <tt>#acquire > #release</tt></td>
- </tr>
-
- <tr>
- <td><tt>dispose(ptr, ptr)</tt></td>
-
- <td>no requirement</td>
-
- <td>pre: <tt>!acquired(ptr) </tt>
- post: <tt>*ptr</tt> no longer usable</td>
- </tr>
- </table>
- </center>
-
- Note that the two arguments to <tt>dispose</tt>
- are to support selection of the appropriate type safe version of the
- function to be called. In the general case the intent is that the first
- argument determines the type to be deleted, and would typically be
- templated, while the second selects which template to use, e.g. by
- conforming to a specific base class.
-
- In addition the following requirements must also be satisfied, where
- <tt>null</tt> is a null pointer to the
- Countable type:
-
- <center>
- <table border="1" summary="">
- <tr>
- <td>Expression</td>
-
- <td>Return type</td>
-
- <td>Semantics and notes</td>
- </tr>
-
- <tr>
- <td><tt>acquire(null)</tt></td>
-
- <td>no requirement</td>
-
- <td>action: none</td>
- </tr>
-
- <tr>
- <td><tt>release(null)</tt></td>
-
- <td>no requirement</td>
-
- <td>action: none</td>
- </tr>
-
- <tr>
- <td><tt>acquired(null)</tt></td>
-
- <td>convertible to <tt>bool</tt></td>
-
- <td>return: <tt>false</tt></td>
- </tr>
-
- <tr>
- <td><tt>dispose(null, null)</tt></td>
-
- <td>no requirement</td>
-
- <td>action: none</td>
- </tr>
- </table>
- </center>
-
- Note that there are no requirements on these functions in terms of
- exceptions thrown or not thrown, except that if exceptions are thrown the
- functions themselves should be exception safe.
- </div>
- <hr width="100%">
-
- <h2>Getting smart</h2>
-
- <div style="margin-left: 2em">
- Given the Countable requirements for a type, it is possible to
- define a generic smart pointer type that uses them for reference counting:
-
- <div style="margin-left: 2em">
- <pre>
-<tt>template<typename countable_type>
-class countable_ptr
-{
-public: // construction and destruction
-
- explicit countable_ptr(countable_type *);
- countable_ptr(const countable_ptr &);
- ~countable_ptr();
-
-public: // access
-
- countable_type *operator->() const;
- countable_type &operator*() const;
- countable_type *get() const;
-
-public: // modification
-
- countable_ptr &clear();
- countable_ptr &assign(countable_type *);
- countable_ptr &assign(const countable_ptr &);
- countable_ptr &operator=(const countable_ptr &);
-
-private: // representation
-
- countable_type *body;
-
-};
-</tt>
-</pre>
- </div>
-
- The interface to this class has been kept intentionally simple, e.g.
- member templates and <tt>throw</tt> specs have been
- omitted, for exposition. The majority of the functions are quite simple in
- implementation, relying very much on the <tt>assign</tt> member as a keystone function:
-
- <div style="margin-left: 2em">
- <pre>
-<tt>template<typename countable_type>
-countable_ptr<countable_type>::countable_ptr(countable_type *initial)
- : body(initial)
-{
- acquire(body);
-}
-
-template<typename countable_type>
-countable_ptr<countable_type>::countable_ptr(const countable_ptr &other)
- : body(other.body)
-{
- acquire(body);
-}
-
-template<typename countable_type>
-countable_ptr<countable_type>::~countable_ptr()
-{
- clear();
-}
-
-template<typename countable_type>
-countable_type *countable_ptr<countable_type>::operator->() const
-{
- return body;
-}
-
-template<typename countable_type>
-countable_type &countable_ptr<countable_type>::operator*() const
-{
- return *body;
-}
-
-template<typename countable_type>
-countable_type *countable_ptr<countable_type>::get() const
-{
- return body;
-}
-
-template<typename countable_type>
-countable_ptr<countable_type> &countable_ptr<countable_type>::clear()
-{
- return assign(0);
-}
-
-template<typename countable_type>
-countable_ptr<countable_type> &countable_ptr<countable_type>::assign(countable_type *rhs)
-{
- // set to rhs (uses Copy Before Release idiom which is self assignment safe)
- acquire(rhs);
- countable_type *old_body = body;
- body = rhs;
-
- // tidy up
- release(old_body);
- if(!acquired(old_body))
- {
- dispose(old_body, old_body);
- }
-
- return *this;
-}
-
-template<typename countable_type>
-countable_ptr<countable_type> &countable_ptr<countable_type>::assign(const countable_ptr &rhs)
-{
- return assign(rhs.body);
-}
-
-template<typename countable_type>
-countable_ptr<countable_type> &countable_ptr<countable_type>::operator=(const countable_ptr &rhs)
-{
- return assign(rhs);
-}
-</tt>
-</pre>
- </div>
- </div>
- <hr width="100%">
-
- <h2>Public accountability</h2>
-
- <div style="margin-left: 2em">
- Conformance to the requirements means that a type can be used with
- <tt>countable_ptr</tt>. Here is an implementation
- mix-in class (mix-imp) that confers countability on its derived
- classes through member functions. This class can be used as a class
- adaptor:
-
- <div style="margin-left: 2em">
- <pre>
-<tt>class countability
-{
-public: // manipulation
-
- void acquire() const;
- void release() const;
- size_t acquired() const;
-
-protected: // construction and destruction
-
- countability();
- ~countability();
-
-private: // representation
-
- mutable size_t count;
-
-private: // prevention
-
- countability(const countability &);
- countability &operator=(const countability &);
-
-};
-</tt>
-</pre>
- </div>
-
- Notice that the manipulation functions are <tt>const</tt> and that the <tt>count</tt>
- member itself is <tt>mutable</tt>. This is because
- countability is not a part of an object's abstract state: memory
- management does not depend on the <tt>const</tt>-ness or otherwise of an object. I won't include the
- definitions of the member functions here as you can probably guess them:
- increment, decrement and return the current count, respectively for the
- manipulation functions. In a multithreaded environment you should ensure
- that such read and write operations are atomic.
-
- So how do we make this class Countable? A simple set of
- forwarding functions does the job:
-
- <div style="margin-left: 2em">
- <pre>
-<tt>void acquire(const countability *ptr)
-{
- if(ptr)
- {
- ptr->acquire();
- }
-}
-
-void release(const countability *ptr)
-{
- if(ptr)
- {
- ptr->release();
- }
-}
-
-size_t acquired(const countability *ptr)
-{
- return ptr ? ptr->acquired() : 0;
-}
-
-template<class countability_derived>
-void dispose(const countability_derived *ptr, const countability *)
-{
- delete ptr;
-}
-</tt>
-</pre>
- </div>
-
- Any type that now derives from <tt>countability</tt> may now be used with <tt>countable_ptr</tt>:
-
- <div style="margin-left: 2em">
- <pre>
-<tt>class example : public countability
-{
- ...
-};
-
-void simple()
-{
- countable_ptr<example> ptr(new example);
- countable_ptr<example> qtr(ptr);
- ptr.clear(); // set ptr to point to null
-} // allocated object deleted when qtr destructs
-</tt>
-</pre>
- </div>
- </div>
- <hr width="100%">
-
- <h2>Runtime mixin</h2>
-
- <div style="margin-left: 2em">
- The challenge is to apply COUNTED BODY in a non-intrusive fashion, such that there is no overhead
- when an object is not counted. What we would like to do is confer this
- capability on a per object rather than on a per class basis. Effectively
- we are after Countability on any object, i.e. anything pointed to
- by a <tt>void *</tt>! It goes without saying that <tt>
- void</tt> is perhaps the least committed of any type.
-
- The forces to resolve on this are quite interesting, to say the least.
- Interesting, but not insurmountable. Given that the class of a runtime
- object cannot change dynamically in any well defined manner, and the
- layout of the object must be fixed, we have to find a new place and time
- to add the counting state. The fact that this must be added only on heap
- creation suggests the following solution:
-
- <div style="margin-left: 2em">
- <pre>
-<tt>struct countable_new;
-extern const countable_new countable;
-
-void *operator new(size_t, const countable_new &);
-void operator delete(void *, const countable_new &);</tt>
-</pre>
- </div>
-
- We have overloaded <tt>operator new</tt> with a
- dummy argument to distinguish it from the regular global <tt>operator new</tt>. This is comparable to the use of the
- <tt>std::nothrow_t</tt> type and <tt>std::nothrow</tt> object in the standard library. The
- placement <tt>operator delete</tt> is there to
- perform any tidy up in the event of failed construction. Note that this is
- not yet supported on all that many compilers.
-
- The result of a <tt>new</tt> expression using
- <tt>countable</tt> is an object allocated on the
- heap that has a header block that holds the count, i.e. we have extended
- the object by prefixing it. We can provide a couple of features in an
- anonymous namespace (not shown) in the implementation file for for
- supporting the count and its access from a raw pointer:
-
- <div style="margin-left: 2em">
- <pre>
-<tt>struct count
-{
- size_t value;
-};
-
-count *header(const void *ptr)
-{
- return const_cast<count *>(static_cast<const count *>(ptr) - 1);
-}
-</tt>
-</pre>
- </div>
-
- An important constraint to observe here is the alignment of
- <tt>count</tt> should be such that it is suitably
- aligned for any type. For the definition shown this will be the case on
- almost all platforms. However, you may need to add a padding member for
- those that don't, e.g. using an anonymous <tt>union</tt> to coalign <tt>count</tt>
- and the most aligned type. Unfortunately, there is no portable way of
- specifying this such that the minimum alignment is also observed - this is
- a common problem when specifying your own allocators that do not directly
- use the results of either <tt>new</tt> or
- <tt>malloc</tt>.
-
- Again, note that the count is not considered to be a part of the
- logical state of the object, and hence the conversion from
- <tt>const</tt> to non-<tt>const</tt> - <tt>count</tt> is in
- effect a <tt>mutable</tt> type.
-
- The allocator functions themselves are fairly straightforward:
-
- <div style="margin-left: 2em">
- <pre>
-<tt>void *operator new(size_t size, const countable_new &)
-{
- count *allocated = static_cast<count *>(::operator new(sizeof(count) + size));
- *allocated = count(); // initialise the header
- return allocated + 1; // adjust result to point to the body
-}
-
-void operator delete(void *ptr, const countable_new &)
-{
- ::operator delete(header(ptr));
-}
-</tt>
-</pre>
- </div>
-
- Given a correctly allocated header, we now need the Countable
- functions to operate on <tt>const void *</tt> to
- complete the picture:
-
- <div style="margin-left: 2em">
- <pre>
-<tt>void acquire(const void *ptr)
-{
- if(ptr)
- {
- ++header(ptr)->value;
- }
-}
-
-void release(const void *ptr)
-{
- if(ptr)
- {
- --header(ptr)->value;
- }
-}
-
-size_t acquired(const void *ptr)
-{
- return ptr ? header(ptr)->value : 0;
-}
-
-template<typename countable_type>
-void dispose(const countable_type *ptr, const void *)
-{
- ptr->~countable_type();
- operator delete(const_cast<countable_type *>(ptr), countable);
-}
-</tt>
-</pre>
- </div>
-
- The most complex of these is the <tt>dispose</tt> function that must ensure that the correct type
- is destructed and also that the memory is collected from the correct
- offset. It uses the value and type of first argument to perform this
- correctly, and the second argument merely acts as a strategy selector,
- i.e. the use of <tt>const void *</tt>
- distinguishes it from the earlier dispose shown for <tt>const countability *</tt>.
- </div>
- <hr width="100%">
-
- <h2>Getting smarter</h2>
-
- <div style="margin-left: 2em">
- Now that we have a way of adding countability at creation for objects
- of any type, what extra is needed to make this work with the
- <tt>countable_ptr</tt> we defined earlier? Good
- news: nothing!
-
- <div style="margin-left: 2em">
- <pre>
-<tt>class example
-{
- ...
-};
-
-void simple()
-{
- countable_ptr<example> ptr(new(countable) example);
- countable_ptr<example> qtr(ptr);
- ptr.clear(); // set ptr to point to null
-} // allocated object deleted when qtr destructs
-</tt>
-</pre>
- </div>
-
- The <tt>new(countable)</tt> expression defines a
- different policy for allocation and deallocation and, in common with other
- allocators, any attempt to mix your allocation policies, e.g. call
- <tt>delete</tt> on an object allocated with
- <tt>new(countable)</tt>, results in undefined
- behaviour. This is similar to what happens when you mix <tt>new[]</tt> with <tt>delete</tt> or
- <tt>malloc</tt> with <tt>delete</tt>. The whole point of Countable conformance
- is that Countable objects are used with <tt>countable_ptr</tt>, and this ensures the correct use.
-
- However, accidents will happen, and inevitably you may forget to
- allocate using <tt>new(countable)</tt> and instead
- use <tt>new</tt>. This error and others can be
- detected in most cases by extending the code shown here to add a check
- member to the <tt>count</tt>, validating the check
- on every access. A benefit of ensuring clear separation between header and
- implementation source files means that you can introduce a checking
- version of this allocator without having to recompile your code.
- </div>
- <hr width="100%">
-
- <h2>Conclusion</h2>
-
- <div style="margin-left: 2em">
- There are two key concepts that this article has introduced:
-
- <ul>
- <li>The use of a generic requirements based approach to simplify and
- adapt the use of the COUNTED BODY pattern.</li>
-
- <li>The ability, through control of allocation, to dynamically and
- non-intrusively add capabilities to fixed types using the RUNTIME MIXIN pattern.</li>
- </ul>
-
- The application of the two together gives rise to a new variant of the
- essential COUNTED BODY
- pattern, UNINTRUSIVE COUNTED BODY. You can take this theme
- even further and contrive a simple garbage collection system for C++.
-
- The complete code for <tt>countable_ptr</tt>,
- <tt>countability</tt>, and the <tt>countable new</tt> is also available.
- </div>
-
- <div align="right">
- <hr width="100%">
- First published in <a href=
- "http://www.accu.org/c++sig/public/Overload.html">Overload</a> 25,
- April 1998, ISSN 1354-3172
- </div>
-
- <a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
- "http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01 Transitional"
- height="31" width="88"></a>
-
- Revised
- 04 December, 2006
-
- Copyright © 1998-1999 Kevlin Henney
-
- Distributed under the Boost Software License, Version 1.0. (See
- accompanying file LICENSE_1_0.txt or copy
- at <a href=
- "http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt>)
-</body>
-</html>

Deleted: trunk/more/cpp_committee_meetings.html
==============================================================================
--- trunk/more/cpp_committee_meetings.html 2007-11-11 14:14:34 EST (Sun, 11 Nov 2007)
+++ (empty file)
@@ -1,125 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-
-<head>
-<meta http-equiv="Content-Language" content="en-us">
-<meta name="GENERATOR" content="Microsoft FrontPage 5.0">
-<meta name="ProgId" content="FrontPage.Editor.Document">
-<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
-<title>C++ Committee Meetings</title>
-</head>
-
-<body bgcolor="#FFFFFF">
-
-<h1>C++ Committee Meeting FAQ for Boost Members</h1>
-Who can attend C++ Committee meetings? Members of
-J16 (the INCITS/ANSI committee) or of a WG21 (ISO) member country committee
-("national body" in
-ISO-speak). <a href="http://www.ncits.org/">
-INCITS</a> has broadened  J16 membership requirements so anyone can
-join, regardless of nationality or employer.
-In addition, a small number of "technical experts" who are not committee
-members can also attend meetings. The "technical expert" umbrella is broad enough to cover
-the
-Boost members who attend meetings.
-When and where is the next meeting? There are two meetings a year. The
-Fall meeting is usually in North America, and the Spring meeting is usually
-outside North America. See a general
-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/meetings">list of meeting locations and
-dates</a>. Detailed information about a particular meeting, including hotel
-information, is usually provided in a paper appearing in one of
-mailings for the prior meeting. If there isn't a link to
-it on the <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/meetings">
-Meetings</a> web page, you will have to go to
-the committee's <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/">
-Papers</a> page and search a bit.
-Is there a fee for attending meetings? No, but there can be a lot of
-incidental expenses like travel, lodging, and meals, and there is a $US 800 a
-year INCITS fee to become a voting member.
-What is the schedule?  The meetings start at 9:00AM on
-Monday, and 8:30AM other days, unless otherwise announced. It is best to arrive
-a half-hour early to grab a good seat, some coffee, tea, or donuts, and to say
-hello to people. (There is also a Sunday evening a WG21 administrative meeting,
-which is closed except to delegates from national bodies.)
-The meetings generally end on Friday, although there is discussion of
-extending them one extra day until the next standard ships. The last day the meeting  is generally over by 11:00AM. Because
-the last day's meeting is for formal votes only, it is primarily of interest only to
-actual committee
-members.
-Sometimes there are evening technical sessions; the details aren't
-usually available until the Monday morning meeting.  There may be a
-reception one evening, and, yes, significant others are
-invited. Again, details usually become available Monday morning.
-What actually happens at the meetings? Monday morning an hour or two
-is spent in full committee on administrivia, and then the committee breaks up
-into working groups (Core, Library, and Enhancements). The full committee also
-gets together later in the week to hear working group progress reports.
-The working groups are where most technical activities take place.  Each
-active issue that appears on an issues list is discussed, as are papers from the
-mailing. Most issues are non-controversial and disposed of in a few minutes.
-Technical discussions are often led by long-term committee members, often
-referring to past decisions or longstanding working group practice. Sometimes a
-controversy erupts. It takes first-time attendees awhile to understand the
-discussions and how decisions are actually made. The working group chairperson
-moderates.
-Sometimes straw polls are taken. In a straw poll anyone attending can vote,
-in contrast to the formal votes taken by the full committee, where only voting
-members can vote.
-Lunch break is an hour and a half.  Informal subgroups often lunch
-together; a lot of technical problems are discussed or actually solved at lunch,
-or later at dinner. In many ways these discussions involving only a few people
-are the most interesting. Sometimes during the regular meetings, a working group
-chair will break off a sub-group to tackle a difficult problem. 
-Do I have to stay at the main hotel? No, and committee members on
-tight budgets often stay at other, cheaper, hotels. (The main hotels are usually
-chosen because they have large meeting rooms available, and thus tend to be pricey.)
-The advantage of staying at the main hotel is that it is then easier to
-participate in the off-line discussions which can be at least as interesting
-as what actually happens in the scheduled meetings.
-What do people wear at meetings?  Programmer casual. No neckties
-to be seen. 
-What should I bring to a meeting? It is almost essential to have a
-laptop computer along. There is a committee LAN with a wiki and Internet connectivity.
-Wireless connectivity has become the norm, although there is usually a wired hub
-or two for those needed wired access.
-What should I do to prepare for a meeting? It is helpful to have
-downloaded the mailing or individual papers for the
-meeting, and read any papers you are interested in. Familiarize yourself with
-the issues lists if you haven't done so already. Decide which of the working
-groups you want to attend.
-What is a "<a name="Paper">Paper</a>"? An electronic document containing issues,
-proposals, or anything else the committee is interested in. Very little gets
-discussed at a meeting, much less acted upon, unless it is presented in a paper. 
-Papers are available
-to anyone. Papers don't just appear randomly; they become available four (lately
-six) times a
-year, before and after each meeting. Committee members often refer to a paper by
-saying what mailing it was in: "See the pre-Redmond mailing."
-What is a "<a name="Mailing">Mailing</a>"? A mailing is the
-set of papers prepared four to six times a year before and after each meeting,
-or between meetings.  It
-is physically just a
-.zip or .gz
-archive of
-all the papers for a meeting. Although the mailing's archive file itself is only available to committee members and technical
-experts, the contents (except copies of the standard) are available to the
-general public as individual papers. The ways of ISO are
-inscrutable.
-What is a "Reflector"? The committee's mailing lists are
-called "reflectors". There are a number of them; "all", "core", "lib", and "ext"
-are the main ones. As a courtesy, Boost technical experts can be added to
-committee reflectors at the request of a committee member. 
-<hr>
-Revised
-April 17, 2005
-© Copyright Beman Dawes, 2002
-
- Distributed under the Boost Software License, Version 1.0. (See
- accompanying file LICENSE_1_0.txt or copy
- at <a href=
- "http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt>)
-
-
-</body>
-
-</html>

Deleted: trunk/more/error_handling.html
==============================================================================
--- trunk/more/error_handling.html 2007-11-11 14:14:34 EST (Sun, 11 Nov 2007)
+++ (empty file)
@@ -1,240 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
-
-<html>
- <head>
- <meta name="generator" content=
- "HTML Tidy for Cygwin (vers 1st April 2002), see www.w3.org">
- <meta http-equiv="Content-Type" content=
- "text/html; charset=windows-1252">
-
- <title>Error and Exception Handling</title>
- </head>
-
- <body>
- <h1>Error and Exception Handling</h1>
-
- <h2>References</h2>
-
- The following paper is a good introduction to some of the issues of
- writing robust generic components:
-
- <blockquote>
- <a href="generic_exception_safety.html">D. Abrahams: ``Exception Safety
- in Generic Components''</a>, originally published in <a href=
- "http://www.springer.de/cgi-bin/search_book.pl?isbn=3-540-41090-2">M.
- Jazayeri, R. Loos, D. Musser (eds.): Generic Programming, Proc. of a
- Dagstuhl Seminar, Lecture Notes on Computer Science. Volume. 1766</a>
- </blockquote>
-
- <h2>Guidelines</h2>
-
- <h3>When should I use exceptions?</h3>
-
- The simple answer is: ``whenever the semantic and performance
- characteristics of exceptions are appropriate.''
-
- An oft-cited guideline is to ask yourself the question ``is this an
- exceptional (or unexpected) situation?'' This guideline has an attractive
- ring to it, but is usually a mistake. The problem is that one person's
- ``exceptional'' is another's ``expected'': when you really look at the
- terms carefully, the distinction evaporates and you're left with no
- guideline. After all, if you check for an error condition, then in some
- sense you expect it to happen, or the check is wasted code.
-
- A more appropriate question to ask is: ``do we want stack
- unwinding here?'' Because actually handling an exception is likely
- to be significantly slower than executing mainline code, you
- should also ask: ``Can I afford stack unwinding here?'' For
- example, a desktop application performing a long computation might
- periodically check to see whether the user had pressed a cancel
- button. Throwing an exception could allow the operation to be
- cancelled gracefully. On the other hand, it would probably be
- inappropriate to throw and handle exceptions in the inner
- loop of this computation because that could have a significant
- performance impact. The guideline mentioned above has a grain of
- truth in it: in time critical code, throwing an exception
- should be the exception, not the rule.
-
- <h3>How should I design my exception classes?</h3>
-
- <ol>
- <li>Derive your exception class
- from <code>std::exception</code>. Except in *very* rare
- circumstances where you can't afford the cost of a virtual
- table,
- <code>std::exception</code> makes a reasonable exception base class,
- and when used universally, allows programmers to catch "everything"
- without resorting to <code>catch(...)</code>. For more about
- <code>catch(...)</code>, see below.
-
- <li>Use virtual inheritance. This insight is due
- to Andrew Koenig. Using virtual inheritance from your
- exception's base class(es) prevents ambiguity problems at the
- catch-site in case someone throws an exception derived from
- multiple bases which have a base class in common:
-
-<pre>
-#include <iostream>
-struct my_exc1 : std::exception { char const* what() const throw(); };
-struct my_exc2 : std::exception { char const* what() const throw(); };
-struct your_exc3 : my_exc1, my_exc2 {};
-
-int main()
-{
- try { throw your_exc3(); }
- catch(std::exception const& e) {}
- catch(...) { std::cout << "whoops!" << std::endl; }
-}
-</pre>
-
-The program above prints <code>"whoops"</code> because the
-C++ runtime can't resolve which <code>exception</code> instance to
-match in the first catch clause.
-
- </li>
-
- <li>
- Don't embed a std::string object or any other data
- member or base class whose copy constructor could throw an exception.
- That could lead directly to std::terminate() at the throw point.
- Similarly, it's a bad idea to use a base or member whose ordinary
- constructor(s) might throw, because, though not necessarily fatal to
- your program, you may report a different exception than intended from
- a throw-expression that includes construction such as:
-
- <blockquote>
-<pre>
-throw some_exception();
-</pre>
- </blockquote>
-
- There are various ways to avoid copying string objects when
- exceptions are copied, including embedding a fixed-length buffer in
- the exception object, or managing strings via reference-counting.
- However, consider the next point before pursuing either of these
- approaches.
- </li>
-
- <li>Format the <code>what()</code> message on demand, if you
- feel you really must format the message. Formatting an exception error
- message is typically a memory-intensive operation that could
- potentially throw an exception. This is an operation best delayed until
- after stack unwinding has occurred, and presumably, released some
- resources. It's a good idea in this case to protect your
- <code>what()</code> function with a <code>catch(...)</code> block so
- that you have a fallback in case the formatting code throws</li>
-
- <li>Don't worry too much about the <code>what()</code>
- message. It's nice to have a message that a programmer stands a
- chance of figuring out, but you're very unlikely to be able to compose
- a relevant and user-comprehensible error message at the point an
- exception is thrown. Certainly, internationalization is beyond the
- scope of the exception class author. <a href=
- "../people/peter_dimov.htm">Peter Dimov</a> makes an excellent argument
- that the proper use of a <code>what()</code> string is to serve as a
- key into a table of error message formatters. Now if only we could get
- standardized <code>what()</code> strings for exceptions thrown by the
- standard library...</li>
-
- <li>Expose relevant information about the cause of the error in
- your exception class' public interface. A fixation on the
- <code>what()</code> message is likely to mean that you neglect to
- expose information someone might need in order to make a coherent
- message for users. For example, if your exception reports a numeric
- range error, it's important to have the actual numbers involved
- available as numbers in the exception class' public interface
- where error reporting code can do something intelligent with them. If
- you only expose a textual representation of those numbers in the
- <code>what()</code> string, you will make life very difficult for
- programmers who need to do something more (e.g. subtraction) with them
- than dumb output.</li>
-
- <li>Make your exception class immune to double-destruction if
- possible. Unfortunately, several popular compilers occasionally cause
- exception objects to be destroyed twice. If you can arrange for that to
- be harmless (e.g. by zeroing deleted pointers) your code will be more
- robust.</li>
- </ol>
-
- <h3>What About Programmer Errors?</h3>
-
- As a developer, if I have violated a precondition of a library I'm
- using, I don't want stack unwinding. What I want is a core dump or the
- equivalent - a way to inspect the state of the program at the exact point
- where the problem was detected. That usually means <tt>assert()</tt> or
- something like it.
-
- Sometimes it is necessary to have resilient APIs which can stand up to
- nearly any kind of client abuse, but there is usually a significant cost
- to this approach. For example, it usually requires that each object used
- by a client be tracked so that it can be checked for validity. If you
- need that sort of protection, it can usually be provided as a layer on
- top of a simpler API. Beware half-measures, though. An API which promises
- resilience against some, but not all abuse is an invitation to disaster.
- Clients will begin to rely on the protection and their expectations will
- grow to cover unprotected parts of the interface.
-
- Note for Windows developers: unfortunately, the native
- exception-handling used by most Windows compilers actually throws an
- exception when you use <tt>assert()</tt>. Actually, this is true of other
- programmer errors such as segmentation faults and divide-by-zero errors.
- One problem with this is that if you use JIT (Just In Time) debugging,
- there will be collateral exception-unwinding before the debugger comes up
- because <code>catch(...)</code> will catch these not-really-C++
- exceptions. Fortunately, there is a simple but little-known workaround,
- which is to use the following incantation:
-
- <blockquote>
-<pre>
-extern "C" void straight_to_debugger(unsigned int, EXCEPTION_POINTERS*)
-{
- throw;
-}
-extern "C" void (*old_translator)(unsigned, EXCEPTION_POINTERS*)
- = _set_se_translator(straight_to_debugger);
-</pre>
- </blockquote>
- This technique doesn't work if the SEH is raised from within a catch
- block (or a function called from within a catch block), but it still
- eliminates the vast majority of JIT-masking problems.
-
- <h3>How should I handle exceptions?</h3>
-
- Often the best way to deal with exceptions is to not handle them at
- all. If you can let them pass through your code and allow destructors to
- handle cleanup, your code will be cleaner.
-
- <h4>Avoid <code>catch(...)</code> when possible</h4>
- Unfortunately, operating systems other than Windows also wind non-C++
- "exceptions" (such as thread cancellation) into the C++ EH machinery, and
- there is sometimes no workaround corresponding to the
- <code>_set_se_translator</code> hack described above. The result is that
- <code>catch(...)</code> can have the effect of making some unexpected
- system notification at a point where recovery is impossible look just
- like a C++ exception thrown from a reasonable place, invalidating the
- usual safe assumptions that destructors and catch blocks have taken valid
- steps to ensure program invariants during unwinding.
-
- I reluctantly concede this point to Hillel Y. Sims, after many
- long debates in the newsgroups: until all OSes are "fixed", if
- every exception were derived from <code>std::exception</code> and
- everyone substituted
- <code>catch(std::exception&)</code> for <code>catch(...)</code>, the
- world would be a better place.
-
- Sometimes, <code>catch(...)</code>, is still the most appropriate
- pattern, in spite of bad interactions with OS/platform design choices. If
- you have no idea what kind of exception might be thrown and you really
- must stop unwinding it's probably still your best bet. One obvious
- place where this occurs is at language boundaries.
- <hr>
-
- © Copyright David Abrahams 2001-2003. All rights reserved.
-
- Revised
- 
- 21 August, 2003
- 
- </body>
-</html>
-

Deleted: trunk/more/generic_exception_safety.html
==============================================================================
--- trunk/more/generic_exception_safety.html 2007-11-11 14:14:34 EST (Sun, 11 Nov 2007)
+++ (empty file)
@@ -1,683 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
-
-
- <meta name="generator" content="Microsoft FrontPage 5.0">
- <title>Exception-Safety in Generic Components</title>
- <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
- <meta content="MSHTML 5.50.4522.1800" name="GENERATOR">
-
- <h1 align="center">Exception-Safety in Generic Components</h1>
-
- Lessons Learned from Specifying Exception-Safety
- for the C++ Standard Library
-
- <h3 align="center">David Abrahams</h3>
-
- <h3 align="center"><a href="mailto:david.abrahams_at_[hidden]">
- david.abrahams_at_[hidden]</a></h3>
-
- Abstract. This paper represents the knowledge accumulated in
- response to a real-world need: that the C++ Standard Template Library
- exhibit useful and well-defined interactions with exceptions, the
- error-handling mechanism built-in to the core C++ language. It explores the
- meaning of exception-safety, reveals surprising myths about exceptions and
- genericity, describes valuable tools for reasoning about program
- correctness, and outlines an automated testing procedure for verifying
- exception-safety.
-
- Keywords: exception-safety, exceptions, STL, C++
-
- <h2>1 What is exception-safety?</h2>
-
- Informally, exception-safety in a component means that it exhibits
- reasonable behavior when an exception is thrown during its execution. For
- most people, the term ``reasonable'' includes all the usual
- expectations for error-handling: that resources should not be leaked, and
- that the program should remain in a well-defined state so that execution
- can continue. For most components, it also includes the expectation that
- when an error is encountered, it is reported to the caller.
-
- More formally, we can describe a component as minimally exception-safe
- if, when exceptions are thrown from within that component, its invariants
- are intact. Later on we'll see that at least three different levels of
- exception-safety can be usefully distinguished. These distinctions can help
- us to describe and reason about the behavior of large systems.
-
- In a generic component, we usually have an additional expectation of
- exception-neutrality, which means that exceptions thrown by a
- component's type parameters should be propagated, unchanged, to the
- component's caller.
-
- <h2>2 Myths and Superstitions</h2>
-
- Exception-safety seems straightforward so far: it doesn't constitute
- anything more than we'd expect from code using more traditional
- error-handling techniques. It might be worthwhile, however, to examine the
- term from a psychological viewpoint. Nobody ever spoke of
- ``error-safety'' before C++ had exceptions.
-
- It's almost as though exceptions are viewed as a mysterious
- attack on otherwise correct code, from which we must protect ourselves.
- Needless to say, this doesn't lead to a healthy relationship with error
- handling! During standardization, a democratic process which requires broad
- support for changes, I encountered many widely-held superstitions. In order
- to even begin the discussion of exception-safety in generic components, it
- may be worthwhile confronting a few of them.
-
- ``Interactions between templates and exceptions are not
- well-understood.'' This myth, often heard from those who consider
- these both new language features, is easily disposed of: there simply are
- no interactions. A template, once instantiated, works in all respects like
- an ordinary class or function. A simple way to reason about the behavior of
- a template with exceptions is to think of how a specific instantiation of
- that template works. Finally, the genericity of templates should not cause
- special concern. Although the component's client supplies part of the
- operation (which may, unless otherwise specified, throw arbitrary
- exceptions), the same is true of operations using familiar virtual
- functions or simple function pointers.
-
- ``It is well known to be impossible to write an exception-safe
- generic container.'' This claim is often heard with reference to
- an article by Tom Cargill <a title=
- "Tom Cargill, ``Exception Handling: A False Sense of Security'', C++ Report, Nov-Dec 1994"
- href=
- "#reference4">[4]</a>
- in which he explores the problem of exception-safety for a generic stack
- template. In his article, Cargill raises many useful questions, but
- unfortunately fails to present a solution to his problem.<a title=
- "Probably the greatest impediment to a solution in Cargill's case was an unfortunate combination of choices on his part: the interface he chose for his container was incompatible with his particular demands for safety. By changing either one he might have solved the problem."
- href=
- "#footnote1">1</a>
- He concludes by suggesting that a solution may not be possible.
- Unfortunately, his article was read by many as ``proof'' of that
- speculation. Since it was published there have been many examples of
- exception-safe generic components, among them the C++ standard library
- containers.
-
- ``Dealing with exceptions will slow code down, and templates are
- used specifically to get the best possible performance.'' A good
- implementation of C++ will not devote a single instruction cycle to dealing
- with exceptions until one is thrown, and then it can be handled at a speed
- comparable with that of calling a function <a title=
- "D. R. Musser, ``Introspective Sorting and Selection Algorithms'', Software-Practice and Experience 27(8):983-993, 1997."
- href=
- "#reference7">[7]</a>.
- That alone gives programs using exceptions performance equivalent to that
- of a program which ignores the possibility of errors. Using exceptions can
- actually result in faster programs than ``traditional'' error
- handling methods for other reasons. First, a catch block clearly indicates
- to the compiler which code is devoted to error-handling; it can then be
- separated from the usual execution path, improving locality of reference.
- Second, code using ``traditional'' error handling must typically
- test a return value for errors after every single function call; using
- exceptions completely eliminates that overhead.
-
- ``Exceptions make it more difficult to reason about a program's
- behavior.'' Usually cited in support of this myth is the way
- ``hidden'' execution paths are followed during stack-unwinding.
- Hidden execution paths are nothing new to any C++ programmer who expects
- local variables to be destroyed upon returning from a function:
-
- <blockquote>
-<pre>ErrorCode f( int& result ) // 1
-{ // 2
- X x; // 3
- ErrorCode err = x.g( result ); // 4
- if ( err != kNoError ) // 5
- return err; // 6
- // ...More code here...
- return kNoError; // 7
-}
-</pre>
- </blockquote>
-
- In the example above, there is a ``hidden'' call to
- <code>X::~X()</code> in lines 6 and 7. Granted, using exceptions, there is
- no code devoted to error handling visible:
-
- <blockquote>
-<pre>int f() // 1
-{ // 2
- X x; // 3
- int result = x.g(); // 4
- // ...More code here...
- return result; // 5
-}
-</pre>
- </blockquote>
-
- For many programmers more familiar with exceptions, the second example
- is actually more readable and understandable than the first. The
- ``hidden'' code paths include the same calls to destructors of
- local variables. In addition, they follow a simple pattern which acts
- exactly as though there were a potential return statement after each
- function call in case of an exception. Readability is enhanced because the
- normal path of execution is unobscured by error-handling, and return values
- are freed up to be used in a natural way.
-
- There is an even more important way in which exceptions can enhance
- correctness: by allowing simple class invariants. In the first example, if
- <code>x</code>'s constructor should need to allocate resources, it has no
- way to report a failure: in C++, constructors have no return values. The
- usual result when exceptions are avoided is that classes requiring
- resources must include a separate initializer function which finishes the
- job of construction. The programmer can therefore never be sure, when an
- object of class <code>X</code> is used, whether he is handling a
- full-fledged <code>X</code> or some abortive attempt to construct one (or
- worse: someone simply forgot to call the initializer!)
-
- <h2>3 A contractual basis for exception-safety</h2>
-
- A non-generic component can be described as exception-safe in isolation,
- but because of its configurability by client code, exception-safety in a
- generic component usually depends on a contract between the component and
- its clients. For example, the designer of a generic component might require
- that an operation which is used in the component's destructor not throw any
- exceptions.<a title=
- " It is usually inadvisable to throw an exception from a destructor in C++, since the destructor may itself be called during the stack-unwinding caused by another exception. If the second exception is allowed to propagate beyond the destructor, the program is immediately terminated."
- href=
- "#footnote2">2</a>
- The generic component might, in return, provide one of the following
- guarantees:
-
- <ul>
- <li>The basic guarantee: that the invariants of the component are
- preserved, and no resources are leaked.
-
- <li>The strong guarantee: that the operation has either completed
- successfully or thrown an exception, leaving the program state exactly as
- it was before the operation started.
-
- <li>The no-throw guarantee: that the operation will not throw an
- exception.
- </ul>
-
- The basic guarantee is a simple minimum standard for exception-safety to
- which we can hold all components. It says simply that after an exception,
- the component can still be used as before. Importantly, the preservation of
- invariants allows the component to be destroyed, potentially as part of
- stack-unwinding. This guarantee is actually less useful than it might at
- first appear. If a component has many valid states, after an exception we
- have no idea what state the component is in|only that the state is valid.
- The options for recovery in this case are limited: either destruction or
- resetting the component to some known state before further use. Consider
- the following example:
-
- <blockquote>
-<pre>template <class X>
-void print_random_sequence()
-{
- std::vector<X> v(10); // A vector of 10 items
- try {
- // Provides only the basic guarantee
- v.insert( v.begin(), X() );
- }
- catch(...) {} // ignore any exceptions above
- // print the vector's contents
- std::cout "(" << v.size() << ") ";
- std::copy( v.begin(), v.end(),
- std::ostream_iterator<X>( std::cout, " " ) );
-}
-</pre>
- </blockquote>
-
- Since all we know about v after an exception is that it is valid, the
- function is allowed to print any random sequence of <code>X</code>s.<a
- title=
- "In practice of course, this function would make an extremely poor random sequence generator!"
- href=
- "#footnote3">3</a>
- It is ``safe'' in the sense that it is not allowed to crash, but
- its output may be unpredictable.
-
- The strong guarantee provides full
- ``commit-or-rollback'' semantics. In the case of C++ standard
- containers, this means, for example, that if an exception is thrown all
- iterators remain valid. We also know that the container has exactly the
- same elements as before the exception was thrown. A transaction that has no
- effects if it fails has obvious benefits: the program state is simple and
- predictable in case of an exception. In the C++ standard library, nearly
- all of the operations on the node-based containers list, set, multiset,
- map, and multimap provide the strong guarantee.<a title=
- "It is worth noting that mutating algorithms usually cannot provide the strong guarantee: to roll back a modified element of a range, it must be set back to its previous value using operator=, which itself might throw. In the C++ standard library, there are a few exceptions to this rule, whose rollback behavior consists only of destruction: uninitialized_copy, uninitialized_fill, and uninitialized_fill_n."
- href=
- "#footnote4">4</a>).
-
- The no-throw guarantee is the strongest of all, and it says that
- an operation is guaranteed not to throw an exception: it always completes
- successfully. This guarantee is necessary for most destructors, and indeed
- the destructors of C++ standard library components are all guaranteed not
- to throw exceptions. The no-throw guarantee turns out to be
- important for other reasons, as we shall see.<a title=
- "All type parameters supplied by clients of the C++ standard library are required not to throw from their destructors. In return, all components of the C++ standard library provide at least the basic guarantee."
- href=
- "#footnote5">5</a>
-
- <h2>4 Legal Wrangling</h2>
-
- Inevitably, the contract can get more complicated: a quid pro quo
- arrangement is possible. Some components in the C++ Standard Library give
- one guarantee for arbitrary type parameters, but give a stronger guarantee
- in exchange for additional promises from the client type that no exceptions
- will be thrown. For example, the standard container operation
- <code>vector<T>::erase</code> gives the basic guarantee for
- any <code>T</code>, but for types whose copy constructor and copy
- assignment operator do not throw, it gives the no-throw guarantee.<a
- title=
- "Similar arrangements might have been made in the C++ standard for many of the mutating algorithms, but were never considered due to time constraints on the standardization process."
- href=
- "#footnote6">6</a>
-
- <h2>5 What level of exception-safety should a component specify?</h2>
-
- From a client's point-of-view, the strongest possible level of safety
- would be ideal. Of course, the no-throw guarantee is simply
- impossible for many operations, but what about the strong guarantee?
- For example, suppose we wanted atomic behavior for
- <code>vector<T>::insert</code>. Insertion into the middle of a vector
- requires copying elements after the insertion point into later positions,
- to make room for the new element. If copying an element can fail, rolling
- back the operation would require ``undoing'' the previous
- copies...which depends on copying again. If copying back should fail (as it
- likely would), we have failed to meet our guarantee.
-
- One possible alternative would be to redefine <code>insert</code> to
- build the new array contents in a fresh piece of memory each time, and only
- destroy the old contents when that has succeeded. Unfortunately, there is a
- non-trivial cost if this approach is followed: insertions near the end of a
- vector which might have previously caused only a few copies would now cause
- every element to be copied. The basic guarantee is a
- ``natural'' level of safety for this operation, which it can
- provide without violating its performance guarantees. In fact all of the
- operations in the library appear to have such a ``natural'' level
- of safety.
-
- Because performance requirements were already a well-established part of
- the draft standard and because performance is a primary goal of the STL,
- there was no attempt to specify more safety than could be provided within
- those requirements. Although not all of the library gives the strong
- guarantee, almost any operation on a standard container which gives the
- basic guarantee can be made strong using the ``make a
- new copy'' strategy described above:
-
- <blockquote>
-<pre>template <class Container, class BasicOp>
-void MakeOperationStrong( Container& c, const BasicOp& op )
-{
- Container tmp(c); // Copy c
- op(tmp); // Work on the copy
- c.swap(tmp); // Cannot fail<a title=
-"Associative containers whose Compare object might throw an exception when copied cannot use this technique, since the swap function might fail."
- href=
-"#footnote7">7</a>
-}
-</pre>
- </blockquote>
-
- This technique can be folded into a wrapper class to make a similar
- container which provides stronger guarantees (and different performance
- characteristics).<a title=
- "This suggests another potential use for the oft-wished-for but as yet unseen container traits<> template: automated container selection to meet exceptionsafety constraints."
- href=
- "#footnote8">8</a>
-
- <h2>6 Should we take everything we can get?</h2>
-
- By considering a particular implementation, we can hope to discern a
- natural level of safety. The danger in using this to establish requirements
- for a component is that the implementation might be restricted. If someone
- should come up with a more-efficient implementation which we'd like to use,
- we may find that it's incompatible with our exception-safety requirements.
- One might expect this to be of no concern in the well-explored domains of
- data structures and algorithms covered by the STL, but even there, advances
- are being made. A good example is the recent introsort algorithm <a
- title=
- "D. R. Musser, ``Introspective Sorting and Selection Algorithms'', Software-Practice and Experience 27(8):983-993, 1997."
- href=
- "#reference6">[6]</a>,
- which represents a substantial improvement in worst-case complexity over
- the well-established quicksort.
-
- To determine exactly how much to demand of the standard components, I
- looked at a typical real-world scenario. The chosen test case was a
- ``composite container.'' Such a container, built of two or more
- standard container components, is not only commonly needed, but serves as a
- simple representative case for maintaining invariants in larger systems:
-
- <blockquote>
-<pre>// SearchableStack - A stack which can be efficiently searched
-// for any value.
-template <class T>
-class SearchableStack
-{
- public:
- void push(const T& t); // O(log n)
- void pop(); // O(log n)
- bool contains(const T& t) const; // O(log n)
- const T& top() const; // O(1)
- private:
- std::set<T> set_impl;
- std::list<std::set<T>::iterator> list_impl;
-};
-</pre>
- </blockquote>
-
- The idea is that the list acts as a stack of set iterators: every
- element goes into the set first, and the resulting position is pushed onto
- the list. The invariant is straightforward: the set and the list should
- always have the same number of elements, and every element of the set
- should be referenced by an element of the list. The following
- implementation of the push function is designed to give the strong
- guarantee within the natural levels of safety provided by set and list:
-
- <blockquote>
-<pre>template <class T> // 1
-void SearchableStack<T>::push(const T& t) // 2
-{ // 3
- set<T>::iterator i = set_impl.insert(t); // 4
- try // 5
- { // 6
- list_impl.push_back(i); // 7
- } // 8
- catch(...) // 9
- { // 10
- set_impl.erase(i); // 11
- throw; // 12
- } // 13
-} // 14
-</pre>
- </blockquote>
-
- What does our code actually require of the library? We need to examine
- the lines where non-const operations occur:
-
- <ul>
- <li>Line 4: if the insertion fails but <code>set_impl</code> is modified
- in the process, our invariant is violated. We need to be able to rely on
- the strong guarantee from <code>set<T>::insert</code>.
-
- <li>Line 7: likewise, if <code>push_back</code> fails, but
- <code>list_impl</code> is modified in the process, our invariant is
- violated, so we need to be able to rely on the strong guarantee
- from list<T>::insert.
-
- <li>Line 11: here we are ``rolling back'' the insertion on line
- 4. If this operation should fail, we will be unable to restore our
- invariant. We absolutely depend on the no-throw guarantee from
- <code>set<T>::erase</code>.<a title=
- "One might be tempted to surround the erase operation with a try/catch block to reduce the requirements on set<T> and the problems that arise in case of an exception, but in the end that just begs the question. First, erase just failed and in this case there are no viable alternative ways to produce the necessary result. Second and more generally, because of the variability of its type parameters a generic component can seldom be assured that any alternatives will succeed."
- href=
- "#footnote9">9</a>
-
- <li>Line 11: for the same reasons, we also depend on being able to pass
- the <code>i</code> to the <code>erase</code> function: we need the
- no-throw guarantee from the copy constructor of
- <code>set<T>::iterator</code>.
- </ul>
-
- I learned a great deal by approaching the question this way during
- standardization. First, the guarantee specified for the composite container
- actually depends on stronger guarantees from its components (the
- no-throw guarantees in line 11). Also, I took advantage of all of
- the natural level of safety to implement this simple example. Finally, the
- analysis revealed a requirement on iterators which I had previously
- overlooked when operations were considered on their own. The conclusion was
- that we should provide as much of the natural level of safety as possible.
- Faster but less-safe implementations could always be provided as extensions
- to the standard components. <a title=
- "The prevalent philosophy in the design of STL was that functionality that wasn't essential to all uses should be left out in favor of efficiency, as long as that functionality could be obtained when needed by adapting the base components. This departs from that philosophy, but it would be difficult or impossible to obtain even the basic guarantee by adapting a base component that doesn't already have it."
- name="#footnote10">10</a>
-
- <h2>7 Automated testing for exception-safety</h2>
-
- As part of the standardization process, I produced an exception-safe
- reference implementation of the STL. Error-handling code is seldom
- rigorously tested in real life, in part because it is difficult to cause
- error conditions to occur. It is very common to see error-handling code
- which crashes the first time it is executed ...in a shipping product! To
- bolster confidence that the implementation actually worked as advertised, I
- designed an automated test suite, based on an exhaustive technique due to
- my colleague Matt Arnold.
-
- The test program started with the basics: reinforcement and
- instrumentation, especially of the global operators <code>new</code> and
- <code>delete</code>.<a title=
- "An excellent discussion on how to fortify memory subsystems can be found in: Steve Maguire, Writing Solid Code, Microsoft Press, Redmond, WA, 1993, ISBN 1-55615- 551-4."
- name="#footnote11">11</a>Instances of the components (containers and
- algorithms) were created, with type parameters chosen to reveal as many
- potential problems as possible. For example, all type parameters were given
- a pointer to heap-allocated memory, so that leaking a contained object
- would be detected as a memory leak.
-
- Finally, a scheme was designed that could cause an operation to throw an
- exception at each possible point of failure. At the beginning of every
- client-supplied operation which is allowed to throw an exception, a call to
- <code>ThisCanThrow</code> was added. A call to <code>ThisCanThrow</code>
- also had to be added everywhere that the generic operation being tested
- might throw an exception, for example in the global operator
- <code>new</code>, for which an instrumented replacement was supplied.
-
- <blockquote>
-<pre>// Use this as a type parameter, e.g. vector<TestClass>
-struct TestClass
-{
- TestClass( int v = 0 )
- : p( ThisCanThrow(), new int( v ) ) {}
- TestClass( const TestClass& rhs )
- : p( ThisCanThrow(), new int( *rhs.p ) ) {}
- const TestClass& operator=( const TestClass& rhs )
- { ThisCanThrow(); *p = *rhs.p; }
- bool operator==( const TestClass& rhs ) const
- { ThisCanThrow(); return *p == *rhs.p; }
- ...etc...
- ~TestClass() { delete p; }
-};
-</pre>
- </blockquote>
-
- <code>ThisCanThrow</code> simply decrements a ``throw
- counter'' and, if it has reached zero, throws an exception. Each test
- takes a form which begins the counter at successively higher values in an
- outer loop and repeatedly attempts to complete the operation being tested.
- The result is that the operation throws an exception at each successive
- step along its execution path that can possibly fail. For example, here is
- a simplified version of the function used to test the strong
- guarantee: <a title=
- "Note that this technique requires that the operation being tested be exception-neutral. If the operation ever tries to recover from an exception and proceed, the throw counter will be negative, and subsequent operations that might fail will not be tested for exception-safety."
- href=
- "#footnote12">12</a>
-
- <blockquote>
-<pre>extern int gThrowCounter; // The throw counter
-void ThisCanThrow()
-{
- if (gThrowCounter-- == 0)
- throw 0;
-}
-
-template <class Value, class Operation>
-void StrongCheck(const Value& v, const Operation& op)
-{
- bool succeeded = false;
- for (long nextThrowCount = 0; !succeeded; ++nextThrowCount)
- {
- Value duplicate = v;
- try
- {
- gThrowCounter = nextThrowCount;
- op( duplicate ); // Try the operation
- succeeded = true;
- }
- catch(...) // Catch all exceptions
- {
- bool unchanged = duplicate == v; // Test strong guarantee
- assert( unchanged );
- }
- // Specialize as desired for each container type, to check
- // integrity. For example, size() == distance(begin(),end())
- CheckInvariant(v); // Check any invariant
- }
-}
-</pre>
- </blockquote>
-
- Notably, this kind of testing is much easier and less intrusive with a
- generic component than with non-generics, because testing-specific type
- parameters can be used without modifying the source code of the component
- being tested. Also, generic functions like <code>StrongCheck</code> above
- were instrumental in performing the tests on a wide range of values and
- operations.
-
- <h2>8 Further Reading</h2>
- To my knowledge, there are currently only two descriptions of STL
- exception-safety available. The original specification <a title=
- "D. Abrahams, Exception Safety in STLport" href=
- "#reference2">[2]</a>
- for the reference exception-safe implementation of the STL is an informal
- specification, simple and self-explanatory (also verbose), and uses the
- basic- and strong-guarantee distinctions outlined in this
- article. It explicitly forbids leaks, and differs substantively from the
- final C++ standard in the guarantees it makes, though they are largely
- identical. I hope to produce an updated version of this document soon.
-
- The description of exception-safety in the C++ Standard <a title=
- "International Standard ISO/IEC 14882, Information Technology-Programming Languages-C++, Document Number ISO/IEC 14882-1998"
- href=
- "#reference1">[1]</a>
- is only slightly more formal, but relies on hard-to-read
- ``standardese'' and an occasionally subtle web of implication.<a
- title=
- "The changes to the draft standard which introduced exception-safety were made late in the process, when amendments were likely to be rejected solely on the basis of the number of altered words. Unfortunately, the result compromises clarity somewhat in favor of brevity. Greg Colvin was responsible for the clever language-lawyering needed to minimize the extent of these changes."
- href=
- "#footnote13">13</a>
- In particular, leaks are not treated directly at all. It does have the
- advantage that it is the standard.
-
- The original reference implementation <a title=
- "B. Fomitchev, Adapted SGI STL Version 1.0, with exception handling code by D. Abrahams"
- href=
- "#reference5">[5]</a>
- of the exception-safe STL is an adaptation of an old version of the SGI
- STL, designed for C++ compilers with limited features. Although it is not a
- complete STL implementation, the code may be easier to read, and it
- illustrates a useful base-class technique for eliminating
- exception-handling code in constructors. The full test suite <a title=
- "D. Abrahams and B. Fomitchev, Exception Handling Test Suite" href=
- "#reference3">[3]</a>
- used to validate the reference implementation has been used successfully to
- validate all recent versions of the SGI STL, and has been adapted to test
- one other vendor's implementation (which failed). As noted on the
- documentation page, it also seems to have the power to reveal hidden
- compiler bugs, particularly where optimizers interact with
- exception-handling code.
-
- <h2>References</h2>
-
- <ol>
- <li><a name="reference1">International</a> Standard ISO/IEC 14882,
- Information Technology-Programming Languages-C++, Document Number
- ISO/IEC 14882-1998, available from <a href=
- "http://webstore.ansi.org/ansidocstore/default.asp">http://webstore.ansi.org/ansidocstore/default.asp>.
-
- <li><a name="reference2">D.</a> Abrahams, Exception Safety in
- STLport, available at <a href=
- "http://www.stlport.org/doc/exception_safety.html">http://www.stlport.org/doc/exception_safety.html>.
-
- <li><a name="reference3">D.</a> Abrahams and B. Fomitchev, Exception
- Handling Test Suite, available at <a href=
- "http://www.stlport.org/doc/eh_testsuite.html">http://www.stlport.org/doc/eh_testsuite.html>.
-
- <li><a name="reference4">Tom</a> Cargill, ``Exception Handling:
- A False Sense of Security,'' C++ Report, Nov-Dec 1994, also
- available at <a href=
- "http://www.awprofessional.com/content/images/020163371x/supplements/Exception_Handling_Article.html">http://www.awprofessional.com/content/images/020163371x/supplements/Exception_Handling_Article.html>.
-
- <li><a name="reference5">B.</a> Fomitchev, Adapted SGI STL Version
- 1.0, with exception handling code by D. Abrahams, available at <a
- href="http://www.stlport.org">http://www.stlport.org>.
-
- <li><a name="reference6">D.</a> R. Musser, ``Introspective Sorting
- and Selection Algorithms,'' Software-Practice and Experience
- 27(8):983-993, 1997.
-
- <li><a name="reference7">Bjarne</a> Stroustrup, The Design And
- Evolution of C++. Addison Wesley, Reading, MA, 1995, ISBN
- 0-201-54330-3, Section 16.9.1.
- </ol>
-
- <h2>Footnotes</h2>
-
- <a name="footnote1">1</a> Probably the greatest impediment to a solution
- in Cargill's case was an unfortunate combination of choices on his part:
- the interface he chose for his container was incompatible with his
- particular demands for safety. By changing either one he might have solved
- the problem.
-
- <a name="footnote2">2</a> It is usually inadvisable to throw an
- exception from a destructor in C++, since the destructor may itself be
- called during the stack-unwinding caused by another exception. If the
- second exception is allowed to propagate beyond the destructor, the program
- is immediately terminated.
-
- <a name="footnote3">3</a> In practice of course, this function would
- make an extremely poor random sequence generator!
-
- <a name="footnote4">4</a> It is worth noting that mutating algorithms
- usually cannot provide the strong guarantee: to roll back a modified
- element of a range, it must be set back to its previous value using
- <code>operator=</code>, which itself might throw. In the C++ standard
- library, there are a few exceptions to this rule, whose rollback behavior
- consists only of destruction: <code>uninitialized_copy</code>,
- <code>uninitialized_fill</code>, and <code>uninitialized_fill_n</code>.
-
- <a name="footnote5">5</a> All type parameters supplied by clients of the
- C++ standard library are required not to throw from their destructors. In
- return, all components of the C++ standard library provide at least the
- basic guarantee.
-
- <a name="footnote6">6</a> Similar arrangements might have been made in
- the C++ standard for many of the mutating algorithms, but were never
- considered due to time constraints on the standardization process.
-
- <a name="footnote7">7</a> Associative containers whose
- <code>Compare</code> object might throw an exception when copied cannot use
- this technique, since the swap function might fail.
-
- <a name="footnote8">8</a> This suggests another potential use for the
- oft-wished-for but as yet unseen <code>container_traits<></code>
- template: automated container selection to meet exception-safety
- constraints.
-
- <a name="footnote9">9</a> One might be tempted to surround the erase
- operation with a <code>try</code>/<code>catch</code> block to reduce the
- requirements on <code>set<T></code> and the problems that arise in
- case of an exception, but in the end that just begs the question. First,
- erase just failed and in this case there are no viable alternative ways to
- produce the necessary result. Second and more generally, because of the
- variability of its type parameters a generic component can seldom be
- assured that any alternatives will succeed.
-
- <a name="footnote10">10</a> The prevalent philosophy in the design of
- STL was that functionality that wasn't essential to all uses should be left
- out in favor of efficiency, as long as that functionality could be obtained
- when needed by adapting the base components. This departs from that
- philosophy, but it would be difficult or impossible to obtain even the
- basic guarantee by adapting a base component that doesn't already
- have it.
-
- <a name="footnote11">11</a> An excellent discussion on how to fortify
- memory subsystems can be found in: Steve Maguire, Writing Solid Code,
- Microsoft Press, Redmond, WA, 1993, ISBN 1-55615- 551-4.
-
- <a name="footnote12">12</a> Note that this technique requires that the
- operation being tested be exception-neutral. If the operation ever tries to
- recover from an exception and proceed, the throw counter will be negative,
- and subsequent operations that might fail will not be tested for
- exception-safety.
-
- <a name="footnote13">13</a> The changes to the draft standard which
- introduced exception-safety were made late in the process, when amendments
- were likely to be rejected solely on the basis of the number of altered
- words. Unfortunately, the result compromises clarity somewhat in favor of
- brevity. Greg Colvin was responsible for the clever language-lawyering
- needed to minimize the extent of these changes.

Deleted: trunk/more/generic_programming.html
==============================================================================
--- trunk/more/generic_programming.html 2007-11-11 14:14:34 EST (Sun, 11 Nov 2007)
+++ (empty file)
@@ -1,451 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
-
-<html>
- <head>
- <meta name="generator" content=
- "Microsoft FrontPage 5.0">
- <meta http-equiv="Content-Type" content=
- "text/html; charset=windows-1252">
- <meta name="GENERATOR" content="Microsoft FrontPage 4.0">
- <meta name="ProgId" content="FrontPage.Editor.Document">
-
- <title>Generic Programming Techniques</title>
- </head>
-
- <body bgcolor="#FFFFFF" text="#000000">
- <img src="../boost.png" alt="boost.png (6897 bytes)" align="center"
- width="277" height="86">
-
- <h1>Generic Programming Techniques</h1>
-
- This is an incomplete survey of some of the generic programming
- techniques used in the boost libraries.
-
- <h2>Table of Contents</h2>
-
- <ul>
- <li>Introduction</li>
-
- <li>The Anatomy of a Concept</li>
-
- <li>Traits</li>
-
- <li>Tag Dispatching</li>
-
- <li>Adaptors</li>
-
- <li>Type Generators</li>
-
- <li>Object Generators</li>
-
- <li>Policy Classes</li>
- </ul>
-
- <h2><a name="introduction">Introduction</a></h2>
-
- Generic programming is about generalizing software components so that
- they can be easily reused in a wide variety of situations. In C++, class
- and function templates are particularly effective mechanisms for generic
- programming because they make the generalization possible without
- sacrificing efficiency.
-
- As a simple example of generic programming, we will look at how one
- might generalize the <tt>memcpy()</tt> function of the C standard
- library. An implementation of <tt>memcpy()</tt> might look like the
- following: 
- 
- 
-
- <blockquote>
-<pre>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;
-}
-</pre>
- </blockquote>
- The <tt>memcpy()</tt> function is already generalized to some extent by
- the use of <tt>void*</tt> so that the function can be used to copy arrays
- of different kinds of data. But what if the data we would like to copy is
- not in an array? Perhaps it is in a linked list. Can we generalize the
- notion of copy to any sequence of elements? Looking at the body of
- <tt>memcpy()</tt>, the function's minimal requirements are
- that it needs to traverse through the sequence using some sort
- of pointer, access elements pointed to, write the elements
- to the destination, and compare pointers to know when to stop. The
- C++ standard library groups requirements such as these into
- concepts, in this case the <a href=
- "http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>
- concept (for <tt>region2</tt>) and the <a href=
- "http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a>
- concept (for <tt>region1</tt>).
-
- If we rewrite the <tt>memcpy()</tt> as a function template, and use
- the <a href="http://www.sgi.com/tech/stl/InputIterator.html">Input
- Iterator</a> and <a href=
- "http://www.sgi.com/tech/stl/OutputIterator.html">Output Iterator</a>
- concepts to describe the requirements on the template parameters, we can
- implement a highly reusable <tt>copy()</tt> function in the following
- way: 
- 
- 
-
- <blockquote>
-<pre>template <typename InputIterator, typename OutputIterator>
-OutputIterator
-copy(InputIterator first, InputIterator last, OutputIterator result)
-{
- while (first != last)
- *result++ = *first++;
- return result;
-}
-</pre>
- </blockquote>
-
- Using the generic <tt>copy()</tt> function, we can now copy elements
- from any kind of sequence, including a linked list that exports iterators
- such as <tt>std::<a href=
- "http://www.sgi.com/tech/stl/List.html">list</a></tt>. 
- 
- 
-
- <blockquote>
-<pre>#include <list>
-#include <vector>
-#include <iostream>
-
-int main()
-{
- const int N = 3;
- std::vector<int> region1(N);
- std::list<int> region2;
-
- region2.push_back(1);
- region2.push_back(0);
- region2.push_back(3);
-
- std::copy(region2.begin(), region2.end(), region1.begin());
-
- for (int i = 0; i < N; ++i)
- std::cout << region1[i] << " ";
- std::cout << std::endl;
-}
-</pre>
- </blockquote>
-
- <h2><a name="concept">Anatomy of a Concept</a></h2>
- A concept is a set of requirements
- consisting of valid expressions, associated types, invariants, and
- complexity guarantees. A type that satisfies the requirements is
- said to model the concept. A concept can extend the
- requirements of another concept, which is called
- refinement.
-
- <ul>
- <li><a name="valid_expression">Valid Expressions</a> are C++
- expressions which must compile successfully for the objects involved in
- the expression to be considered models of the concept.</li>
-
- <li><a name="associated_type">Associated Types</a> are types
- that are related to the modeling type in that they participate in one
- or more of the valid expressions. Typically associated types can be
- accessed either through typedefs nested within a class definition for
- the modeling type, or they are accessed through a <a href=
- "#traits">traits class</a>.</li>
-
- <li>Invariants are run-time characteristics of the objects that
- must always be true, that is, the functions involving the objects must
- preserve these characteristics. The invariants often take the form of
- pre-conditions and post-conditions.</li>
-
- <li>Complexity Guarantees are maximum limits on how long the
- execution of one of the valid expressions will take, or how much of
- various resources its computation will use.</li>
- </ul>
-
- The concepts used in the C++ Standard Library are documented at the <a
- href="http://www.sgi.com/tech/stl/table_of_contents.html">SGI STL
- site</a>.
-
- <h2><a name="traits">Traits</a></h2>
-
- A traits class provides a way of associating information with a
- compile-time entity (a type, integral constant, or address). For example,
- the class template <tt><a href=
- "http://www.sgi.com/tech/stl/iterator_traits.html">std::iterator_traits<T></a></tt>
- looks something like this:
-
- <blockquote>
-<pre>template <class Iterator>
-struct iterator_traits {
- typedef ... iterator_category;
- typedef ... value_type;
- typedef ... difference_type;
- typedef ... pointer;
- typedef ... reference;
-};
-</pre>
- </blockquote>
- The traits' <tt>value_type</tt> gives generic code the type which the
- iterator is "pointing at", while the <tt>iterator_category</tt> can be
- used to select more efficient algorithms depending on the iterator's
- capabilities.
-
- A key feature of traits templates is that they're
- non-intrusive: they allow us to associate information with
- arbitrary types, including built-in types and types defined in
- third-party libraries, Normally, traits are specified for a particular
- type by (partially) specializing the traits template.
-
- For an in-depth description of <tt>std::iterator_traits</tt>, see <a
- href="http://www.sgi.com/tech/stl/iterator_traits.html">this page</a>
- provided by SGI. Another very different expression of the traits idiom in
- the standard is <tt>std::numeric_limits<T></tt> which provides
- constants describing the range and capabilities of numeric types.
-
- <h2><a name="tag_dispatching">Tag Dispatching</a></h2>
-
- Tag dispatching is a way of using function overloading to
- dispatch based on properties of a type, and is often used hand in
- hand with traits classes. A good example of this synergy is the
- implementation of the <a href=
- "http://www.sgi.com/tech/stl/advance.html"><tt>std::advance()</tt></a>
- function in the C++ Standard Library, which increments an iterator
- <tt>n</tt> times. Depending on the kind of iterator, there are different
- optimizations that can be applied in the implementation. If the iterator
- is <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">random
- access</a> (can jump forward and backward arbitrary distances), then the
- <tt>advance()</tt> function can simply be implemented with <tt>i +=
- n</tt>, and is very efficient: constant time. Other iterators must be
- <tt>advance</tt>d in steps, making the operation linear in n. If the
- iterator is <a href=
- "http://www.sgi.com/tech/stl/BidirectionalIterator.html">bidirectional</a>,
- then it makes sense for <tt>n</tt> to be negative, so we must decide
- whether to increment or decrement the iterator.
-
- The relation between tag dispatching and traits classes is that the
- property used for dispatching (in this case the
- <tt>iterator_category</tt>) is often accessed through a traits class. The
- main <tt>advance()</tt> function uses the <a href=
- "http://www.sgi.com/tech/stl/iterator_traits.html"><tt>iterator_traits</tt></a>
- class to get the <tt>iterator_category</tt>. It then makes a call the the
- overloaded <tt>advance_dispatch()</tt> function. The appropriate
- <tt>advance_dispatch()</tt> is selected by the compiler based on whatever
- type the <tt>iterator_category</tt> resolves to, either <a href=
- "http://www.sgi.com/tech/stl/input_iterator_tag.html"><tt>input_iterator_tag</tt></a>,
- <a href=
- "http://www.sgi.com/tech/stl/bidirectional_iterator_tag.html"><tt>bidirectional_iterator_tag</tt></a>,
- or <a href=
- "http://www.sgi.com/tech/stl/random_access_iterator_tag.html"><tt>random_access_iterator_tag</tt></a>.
- A tag is simply a class whose only purpose is to convey
- some property for use in tag dispatching and similar techniques. Refer to
- this page
- for a more detailed description of iterator tags.
-
- <blockquote>
-<pre>namespace std {
- struct input_iterator_tag { };
- struct bidirectional_iterator_tag { };
- struct random_access_iterator_tag { };
-
- namespace detail {
- template <class InputIterator, class Distance>
- void advance_dispatch(InputIterator& i, Distance n, input_iterator_tag) {
- while (n--) ++i;
- }
-
- template <class BidirectionalIterator, class Distance>
- void advance_dispatch(BidirectionalIterator& i, Distance n,
- bidirectional_iterator_tag) {
- if (n >= 0)
- while (n--) ++i;
- else
- while (n++) --i;
- }
-
- template <class RandomAccessIterator, class Distance>
- void advance_dispatch(RandomAccessIterator& i, Distance n,
- random_access_iterator_tag) {
- i += n;
- }
- }
-
- template <class InputIterator, class Distance>
- void advance(InputIterator& i, Distance n) {
- typename iterator_traits<InputIterator>::iterator_category category;
- detail::advance_dispatch(i, n, category);
- }
-}
-</pre>
- </blockquote>
-
- <h2><a name="adaptors">Adaptors</a></h2>
-
- An adaptor is a class template which builds on another type or
- types to provide a new interface or behavioral variant. Examples of
- standard adaptors are <a href=
- "http://www.sgi.com/tech/stl/ReverseIterator.html">std::reverse_iterator</a>,
- which adapts an iterator type by reversing its motion upon
- increment/decrement, and <a href=
- "http://www.sgi.com/tech/stl/stack.html">std::stack</a>, which adapts a
- container to provide a simple stack interface.
-
- A more comprehensive review of the adaptors in the standard can be
- found <a href="http://portal.acm.org/citation.cfm?id=249118.249120">
- here</a>.
-
- <h2><a name="type_generator">Type Generators</a></h2>
-
- Note: The type generator concept has largely been
- superseded by the more refined notion of a <a href=
- "../libs/mpl/doc/refmanual/metafunction.html">metafunction</a>. See
- <a href="http://www.boost-consulting.com/mplbook">C++ Template
- Metaprogramming</a> for an in-depth discussion of metafunctions.
-
- A type generator is a template whose only purpose is to
- synthesize a new type or types based on its template argument(s)<a href=
- "#1">[1]</a>. The generated type is usually expressed as a nested typedef
- named, appropriately <tt>type</tt>. A type generator is usually used to
- consolidate a complicated type expression into a simple one. This example
- uses an old version of <tt><a href=
- "../libs/iterator/doc/iterator_adaptor.html">iterator_adaptor</a></tt>
- whose design didn't allow derived iterator types. As a result, every
- adapted iterator had to be a specialization of <tt>iterator_adaptor</tt>
- itself and generators were a convenient way to produce those types.
-
- <blockquote>
-<pre>template <class Predicate, class Iterator,
- class Value = complicated default,
- class Reference = complicated default,
- class Pointer = complicated default,
- class Category = complicated default,
- class Distance = complicated default
- >
-struct filter_iterator_generator {
- typedef iterator_adaptor<
-
- Iterator,filter_iterator_policies<Predicate,Iterator>,
- Value,Reference,Pointer,Category,Distance> type;
-};
-</pre>
- </blockquote>
-
- Now, that's complicated, but producing an adapted filter iterator
- using the generator is much easier. You can usually just write:
-
- <blockquote>
-<pre>boost::filter_iterator_generator<my_predicate,my_base_iterator>::type
-</pre>
- </blockquote>
-
- <h2><a name="object_generator">Object Generators</a></h2>
-
- An object generator is a function template whose only purpose
- is to construct a new object out of its arguments. Think of it as a kind
- of generic constructor. An object generator may be more useful than a
- plain constructor when the exact type to be generated is difficult or
- impossible to express and the result of the generator can be passed
- directly to a function rather than stored in a variable. Most Boost
- object generators are named with the prefix "<tt>make_</tt>", after
- <tt>std::<a href=
- "http://www.sgi.com/tech/stl/pair.html">make_pair</a>(const T&, const U&)</tt>.
-
- For example, given:
-
- <blockquote>
-<pre>struct widget {
- void tweak(int);
-};
-std::vector<widget *> widget_ptrs;
-</pre>
- </blockquote>
- By chaining two standard object generators, <tt>std::<a href=
- "http://www.dinkumware.com/htm_cpl/functio2.html#bind2nd">bind2nd</a>()</tt>
- and <tt>std::<a href=
- "http://www.dinkumware.com/htm_cpl/functio2.html#mem_fun">mem_fun</a>()</tt>,
- we can easily tweak all widgets:
-
- <blockquote>
-<pre>void tweak_all_widgets1(int arg)
-{
- for_each(widget_ptrs.begin(), widget_ptrs.end(),
- bind2nd(std::mem_fun(&widget::tweak), arg));
-}
-</pre>
- </blockquote>
-
- Without using object generators the example above would look like
- this:
-
- <blockquote>
-<pre>void tweak_all_widgets2(int arg)
-{
- for_each(struct_ptrs.begin(), struct_ptrs.end(),
- std::binder2nd<std::mem_fun1_t<void, widget, int> >(
- std::mem_fun1_t<void, widget, int>(&widget::tweak), arg));
-}
-</pre>
- </blockquote>
-
- As expressions get more complicated the need to reduce the verbosity
- of type specification gets more compelling.
-
- <h2><a name="policy">Policy Classes</a></h2>
-
- A policy class is a template parameter used to transmit behavior. An
- example from the standard library is <tt>std::<a href=
- "http://www.dinkumware.com/htm_cpl/memory.html#allocator">allocator</a></tt>,
- which supplies memory management behaviors to standard <a href=
- "http://www.sgi.com/tech/stl/Container.html">containers</a>.
-
- Policy classes have been explored in detail by <a href=
- "http://www.moderncppdesign.com/">Andrei Alexandrescu</a> in <a href=
- "http://www.informit.com/articles/article.asp?p=167842">this chapter</a>
- of his book, Modern C++ Design. He writes:
-
- <blockquote>
- In brief, policy-based class design fosters assembling a class with
- complex behavior out of many little classes (called policies), each of
- which takes care of only one behavioral or structural aspect. As the
- name suggests, a policy establishes an interface pertaining to a
- specific issue. You can implement policies in various ways as long as
- you respect the policy interface.
-
- Because you can mix and match policies, you can achieve a
- combinatorial set of behaviors by using a small core of elementary
- components.
- </blockquote>
-
- Andrei's description of policy classes suggests that their power is
- derived from granularity and orthogonality. Less-granular policy
- interfaces have been shown to work well in practice, though. <a href=
- "http://cvs.sourceforge.net/viewcvs.py/*checkout*/boost/boost/libs/utility/Attic/iterator_adaptors.pdf">
- This paper</a> describes an old version of <tt><a href=
- "../libs/iterator/doc/iterator_adaptor.html">iterator_adaptor</a></tt>
- that used non-orthogonal policies. There is also precedent in the
- standard library: <tt><a href=
- "http://www.dinkumware.com/htm_cpl/string2.html#char_traits">std::char_traits</a></tt>,
- despite its name, acts as a policies class that determines the behaviors
- of <a href=
- "http://www.dinkumware.com/htm_cpl/string2.html#basic_string">std::basic_string</a>.
-
- <h2>Notes</h2>
- <a name="1">[1]</a> Type generators are sometimes viewed as a workaround
- for the lack of ``templated typedefs'' in C++.
- <hr>
-
- Revised
- 06 Nov 2007
- 
-
- © Copyright David Abrahams 2001.
-
-Distributed under the Boost Software License, Version 1.0. See
-www.boost.org/LICENSE_1_0.txt
-
- </body>
-</html>
\ No newline at end of file

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk