    it() Version 7.3.0 adds a section about overloading operators outside of
the common context of classes (section ref(EnumOverload)).
    it() Version 7.2.0 describes the implementation of polymorphism for
classes inheriting from multiple base classes defining virtual member
functions (section ref(howpolymorphism)) and adds two new sections in the
concrete examples chapter: Section ref(PROXY) discusses the problem how to
distinguish em(lvalues) from em(rvalues) with tt(operator[]()), section
ref(BISONSEM) discusses in the context of the Bisonc++ parser generator how to
use polymorphism instead of a union to define different types of semantic
values. As usual, several typos were repaired and various other improvements
were made.
    it() Version 7.1.0 adds a description of the tt(type_info::before())
member (cf. section ref(TYPEID)). Furthermore, several typographical
corrections were made.
    it() Version 7.0.1. was released shortly after releasing version 7.0.0, as
the result of very extensive feedback received by Eric S. Raymond (esr at
thyrsus dot com) and Edward Welbourne (eddy at chaos dot org dot
uk). Considering the extent of the received feedback, it's appropriate to
mention explicitly the sub-sub-release here. Many textual changes were made
and section ref(STRINGMEMBERS) was completely reorganized.
    it() Version 7.0.0 comes with a new chapter discussing advanced template
applications. Moreover, the general terminology used with templates has
evolved. `Templates' are now considered a core concept, which is reflected by
the use of `templates' as a noun, rather than an adjective. So, from now on it
is `class template' rather than `template class'. The addition of another
chapter, together with the addition of several new sections to existing
chapters as well as various rewrites of existing sections made it appropriate
to upgrade to the next major release. The newly added chapter does not aim at
concrete examples of templates. Instead it discusses possibilities of
templates beyond the basic function and class templates. In addition to this
new chapter, several new sections were added: section ref(LOCAL) introduces
em(local classes); section ref(PLACEMENT) discusses the em(placement new
operator); section ref(ACCESSPROMOTION) discusses how to make available some
members of privately inherited classes and section ref(NONDEFINIT) discusses
how objects created by tt(new[]) can be initialized by non-default
constructors. In addition to all this, Elwin Dijck (e dot dijck at gmail dot
com), one of the students of the 2006-2007 edition of the bf(C++) course, did
a em(magnificent) job by converting em(all) images to vector graphics (in the
process prompting me to start using vector graphics as well :-). Thanks, Elwin
for a job well done!
    it() Version 6.5.0 changed tt(unsigned) into tt(size_t) where appropriate,
and explicitly mentioned tt(int)-derived types like tt(int16_t). In-class
member function definitions were moved out of (below) their class definitions
as tt(inline) defined members. A paragraphs about implementing pure virtual
member functions was added. Various bugs and compilation errors were fixed.
    it() Version 6.4.0 added a new section (ref(RETURNNESTED)) further
discussing the use of the tt(template) keyword to distinguish types nested
under class templates from template members. Furthermore, emi(Sergio Bacchi)
tt( s dot bacchi at gmail dot com) did an impressive job when translating the
Annotations into Portuguese. His translation (which may lag a distribution or
two behind the latest verstion of the Annotations) may also be retrieved
from the tt(contributions/) subdirectory in the
tt(c++-annotations_X.Y.Z.tar.gz) archive at+nl()
lurl(http://sourceforge.net/projects/cppannotations/)
    it() Version 6.3.0 added new sections about anonymous objects (section
ref(ANONYMOUS)) and type resolution with class templates (section
ref(TYPERES)). Also the description of the template parameter deduction
algorithm was rewritten (cf. section ref(PARDEDUCT)) and numerous
modifications required because of the compiler's closer adherence to the
bf(C++) standard were realized, among which exception rethrowing from
constructor and destructor function try blocks. Also, all textual corrections
received from readers since version 6.2.4 were processed.
    it() In version 6.2.4 many textual improvements were realized. I received
extensive lists of typos and suggestions for clarifications of the text, in
particular from Nathan Johnson and from Jakob van Bethlehem. Equally valuable
were suggestions I received from various other readers of the bf(C++)
annotations: all were processed in this release. The bf(C++) content matter of
this release was not substantially modified, compared to version 6.2.2.
    it() Version 6.2.2 offers improved implementations of the configurable
class templates (removed in 8.1.0, superseded by lambda functions).
    it() Version 6.2.0 was released as an Annual Update, by the end of May,
2005. Apart from the usual typo corrections several new sections
were added and some were removed: in the Exception chapter (ref(EXCEPTIONS)) a
section was added covering the standard exceptions and their meanings; in the
chapter covering static members (ref(StaticDataFun)) a section was added
discussing tt(static const) data members; and the final chapter
(ref(CONCRETE)) covers configurable class templates using em(local context
structs) (replacing the previous tt(ForEach, UnaryPredicate) and
tt(BinaryPredicate) classes). Furthermore, the final section (covering a
bf(C++) parser generator) now uses bf(bisonc++), rather than the old
(and somewhat outdated) bf(bison++) program.
    it() Version 6.1.0 was released shortly after releasing 6.0.0. Following
suggestions received from nemail(Leo Razoumov)(LEOR@winmain.rutgers.edu) and
Paulo Tribolet, and after receiving many, many useful suggestions and
extensive help from Leo, navigatable tt(.pdf) files are from now on
distributed with the bf(C++) Annotations. Also, some sections were slightly
adapted. COMMENT(e.g., section ref(FOREACHWRAPPER).)
    it() Version 6.0.0 was released after a full update of the text, removing
many inconsistencies and typos. Since the update effected the Annotation's
full text an upgrade to a new major version seemed appropriate.  Several new
sections were added: overloading binary operators (section
ref(OVERLOADBINARY)); throwing exceptions in constructors and destructors
(section ref(CONSEXCEPTIONS)); function tt(try)-blocks (section ref(FUNTRY));
calling conventions of static and global functions (section
ref(CALLINGCONVENTION)) and virtual constructors (section ref(VIRTCONS)). The
chapter on templates was completely rewritten and split into two separate
chapters: chapter ref(TEMPLATES) discusses the syntax and use of template
em(functions); chapter ref(TEMPCLASS) discusses template em(classes). Various
concrete examples were modified; new examples were included as well (chapter
ref(CONCRETE)).
    it() In version 5.2.4 the description of the em(random_shuffle) generic
algorithm (section ref(SHUFFLE)) was modified.
    it() In version 5.2.3 section ref(LOCALVARS) on local variables was
extended and section ref(FunctionOverloading) on function overloading was
modified by explicitly discussing the effects of the bf(const) modifier with
overloaded functions. Also, the description of the tt(compare()) function in
chapter ref(String) contained an error, which was repaired.
    it() In version 5.2.2 a leftover in section ref(EXPLICIT)
from a former version was removed and the corresponding text was
updated. Also, some minor typos were corrected.
    it() In version 5.2.1 various typos were repaired, and some paragraphs
were further clarified. Furthermore, a section was added to the em(template)
chapter (chapter ref(TEMPLATES)), about creating several tt(iterator)
types. This topic was further elaborated in chapter ref(CONCRETE), where the
section about the construction of a reverse iterator (section
ref(CONCRETEITER)) was completely rewritten.  In the same chapter, a
em(universal text to anything convertor) is discussed (section ref(A2X)).
    Also, tt(LaTeX), tt(PostScript) and tt(PDF) versions fitting the
emi(US-letter)
    hi(letter (US paper size)) paper size are now available as
hi(cplusplusus) tt(cplusplus)bf(us) versions: tt(cplusplusus.latex,
cplusplusus.ps) and tt(cplusplus.pdf). The em(A4-paper) size is of course
kept, and remains to be available in the tt(cplusplus.latex, cplusplus.ps) and
tt(cpluspl.pdf) files.
    COMMENT(
    IFDEF(html)(nl()Finally, readers might be interested in reading the new
section ref(FREELECTURES), where the concept of emi(free lectures) is
introduced.)()
    )
    it() Version 5.2.0 was released after adding a section about
the
tt(mutable) keyword (section ref(MUTABLE)), and after thoroughly changing the
discussion of the tt(Fork()) abstract base class (section ref(FORK)). All
examples should now be up-to-date with respect to the use of the tt(std)
namespace.
    it() However, in the meantime the Gnu
            g++ compiler version 3.2 was hi(http://www.gnu.org)
released+footnote(tlurl(http://www.gnu.org)). In this version extensions to
the abstract containers (see chapter ref(CONTAINERS)) like the hash_map were
placed in a separate namespace, ti(__gnu_cxx). This namespace should be used
when using these containers. However, this may break compilations of sources
with tt(g++), version 3.0. In that case, a compilation can be performed
conditionally to the 3.2 and the 3.0 compiler version, defining tt(__gnu_cxx)
for the 3.2 version. Alternatively, the em(dirty trick)
        verb(
    #define __gnu_cxx std
        )
    can be placed just before header files in which the tt(__gnu_cxx)
namespace is used. This might eventually result in name-collisions, and it's a
dirty trick by any standards, so please don't tell anybody I wrote this down.
    it() Version 5.1.1 was released after modifying the sections related to
the tt(fork()) system call in chapter ref(CONCRETE). Under the i(ANSI/ISO)
standard many of the previously available extensions (like ti(procbuf), and
ti(vform)) applied to streams were discontinued. Starting with version
5.1.1. ways of constructing these facilities under the ANSI/ISO standard are
discussed in the bf(C++) Annotations. I consider the involved subject
sufficiently complex to warrant the upgrade to a new subversion.
    it() With the advent of the Gnu tt(g++) compiler version 3.00, a more
strict implementation of the ANSI/ISO bf(C++) standard became
available. This resulted in version 5.1.0 of the Annotations, appearing
shortly after version 5.0.0. In version 5.1.0 chapter ref(IOStreams) was
modified and several cosmetic changes took place (e.g., removing tt(class)
from template type parameter lists, see chapter ref(TEMPLATES)). Intermediate
versions (like 5.0.0a, 5.0.0b) were not further documented, but were mere
intermediate releases while approaching version 5.1.0. Code
examples will gradually be adapted to the new release of the compiler.
    quote(
        In the meantime the reader should be prepared to insert
        tt(using namespace std;)
    in many code examples, just beyond the ti(#include)
        preprocessor directives as a temporary measure to make the
    example accepted by the compiler.
    )
    it() New insights develop all the time, resulting in version 5.0.0 of the
Annotations. In this version a lot of old code was cleaned up and typos were
repaired. According to current standard, em(namespaces) are required in
bf(C++) programs, so they are introduced now very early (in section
ref(INTRONAME)) in the Annotations. A new section about using external
programs was added to the Annotations (and removed again in version 5.1.0),
and the new tt(stringstream) class, replacing the tt(strstream) class is now
covered too (sections ref(OSTRINGSTREAM) and ref(ISTRINGSTREAM)). Actually,
the chapter on input and output was completely rewritten. Furthermore, the
operators tt(new) and tt(delete) are now discussed in chapter ref(MEMORY),
where they fit better than in a chapter on classes, where they previously were
discussed. Chapters were moved, split and reordered, so that subjects could
generally be introduced without forward references. Finally, the tt(html),
PostScript and pdf versions of the bf(C++) Annotations now contain an
index (sigh of relief ?)  All in, considering the volume and nature of the
modifications, it seemed right to upgrade to a full major version. So here it
is.

Considering the volume of the Annotations, I'm sure there will be
typos found every now and then. Please do not hesitate to send me mail
containing any mistakes you find or corrections you would like to suggest.
    it() In release tt(4.4.1b) the pagesize in the LaTeX file was defined to
be tt(din A4). In countries where other pagesizes are standard the default
pagesize might be a better choice. In that case, remove the
tt(a4paper,twoside) option from tt(cplusplus.tex) (or tt(cplusplus.yo) if you
have tt(yodl) installed), and reconstruct the Annotations from the
em(TeX)-file or tt(Yodl)-files.

The Annotations mailing lists was stopped at release tt(4.4.1d). From this
point on only minor modifications were expected, which are not anymore
generally announced.

At some point, I considered version tt(4.4.1) to be the final version of the
bf(C++) Annotations. However, a section on special I/O functions was added to
cover unformatted I/O, and the section about the tt(string) datatype had its
layout improved and was, due to its volume, given a chapter of its own
(chapter ref(String)). All this eventually resulted in version tt(4.4.2).

Version tt(4.4.1) again contains new material, and reflects the
    hi(ftp://research.att.com/dist/c++std/WP/)
url(ANSI/ISO)(ftp://research.att.com/dist/c++std/WP/) standard (well, I try to
have it reflect the ANSI/ISO standard). In version 4.4.1. several new
sections and chapters were added, among which a chapter about the
    em(Standard Template Library) (STL) and em(generic algorithms).

Version tt(4.4.0) (and subletters) was a mere construction version and was
never made available.

The version tt(4.3.1a) is a precursor of tt(4.3.2). In tt(4.3.1a) most of the
typos I've received since the last update have been processed. In version
tt(4.3.2) extra attention was paid to the syntax for function addresses and
pointers to member functions.

The decision to upgrade from version 4.2.* to 4.3.* was made after realizing
that the lexical scanner function tt(yylex()) can be defined in the
scanner class that is derived from tt(yyFlexLexer). Under this approach
the tt(yylex()) function can access the members of the class derived from
tt(yyFlexLexer) as well as the public and protected members of
tt(yyFlexLexer). The result of all this is a clean implementation of the rules
defined in the tt(flex++) specification file.

The upgrade from version 4.1.* to 4.2.* was the result of the inclusion of
section ref(BOOL) about the bf(bool) data type in chapter
ref(FirstImpression). The distinction between differences between bf(C) and
bf(C++) and extensions of the bf(C) programming languages is (albeit a bit
fuzzy) reflected in the introduction chapter and the chapter on first
impressions of bf(C++): The link(introduction chapter)(IntroC)
covers some differences between bf(C) and bf(C++), whereas the chapter about
link(first impressions)(FirstImpression) of bf(C++) covers some extensions of
the bf(C) programming language as found in bf(C++).

Major version 4 is a major rewrite of the previous
version 3.4.14. The document was rewritten from SGML to
Yodl and many
new sections were added. All sections got a tune-up. The distribution basis,
however, hasn't changed: see link(the introduction)(IntroC).

Modifications in versions 1.*.*, 2.*.*, and 3.*.* (replace the stars by any
applicable number) were not logged.

Subreleases like tt(4.4.2a) etc. contain bugfixes and typographical
corrections.
