1
it() Version 7.3.0 adds a section about overloading operators outside of
2
the common context of classes (section ref(EnumOverload)).
3
it() Version 7.2.0 describes the implementation of polymorphism for
4
classes inheriting from multiple base classes defining virtual member
5
functions (section ref(howpolymorphism)) and adds two new sections in the
6
concrete examples chapter: Section ref(PROXY) discusses the problem how to
7
distinguish em(lvalues) from em(rvalues) with tt(operator[]()), section
8
ref(BISONSEM) discusses in the context of the Bisonc++ parser generator how to
9
use polymorphism instead of a union to define different types of semantic
10
values. As usual, several typos were repaired and various other improvements
12
it() Version 7.1.0 adds a description of the tt(type_info::before())
13
member (cf. section ref(TYPEID)). Furthermore, several typographical
14
corrections were made.
15
it() Version 7.0.1. was released shortly after releasing version 7.0.0, as
16
the result of very extensive feedback received by Eric S. Raymond (esr at
17
thyrsus dot com) and Edward Welbourne (eddy at chaos dot org dot
18
uk). Considering the extent of the received feedback, it's appropriate to
19
mention explicitly the sub-sub-release here. Many textual changes were made
20
and section ref(STRINGMEMBERS) was completely reorganized.
21
it() Version 7.0.0 comes with a new chapter discussing advanced template
22
applications. Moreover, the general terminology used with templates has
23
evolved. `Templates' are now considered a core concept, which is reflected by
24
the use of `templates' as a noun, rather than an adjective. So, from now on it
25
is `class template' rather than `template class'. The addition of another
26
chapter, together with the addition of several new sections to existing
27
chapters as well as various rewrites of existing sections made it appropriate
28
to upgrade to the next major release. The newly added chapter does not aim at
29
concrete examples of templates. Instead it discusses possibilities of
30
templates beyond the basic function and class templates. In addition to this
31
new chapter, several new sections were added: section ref(LOCAL) introduces
32
em(local classes); section ref(PLACEMENT) discusses the em(placement new
33
operator); section ref(ACCESSPROMOTION) discusses how to make available some
34
members of privately inherited classes and section ref(NONDEFINIT) discusses
35
how objects created by tt(new[]) can be initialized by non-default
36
constructors. In addition to all this, Elwin Dijck (e dot dijck at gmail dot
37
com), one of the students of the 2006-2007 edition of the bf(C++) course, did
38
a em(magnificent) job by converting em(all) images to vector graphics (in the
39
process prompting me to start using vector graphics as well :-). Thanks, Elwin
41
it() Version 6.5.0 changed tt(unsigned) into tt(size_t) where appropriate,
42
and explicitly mentioned tt(int)-derived types like tt(int16_t). In-class
43
member function definitions were moved out of (below) their class definitions
44
as tt(inline) defined members. A paragraphs about implementing pure virtual
45
member functions was added. Various bugs and compilation errors were fixed.
46
it() Version 6.4.0 added a new section (ref(RETURNNESTED)) further
47
discussing the use of the tt(template) keyword to distinguish types nested
48
under class templates from template members. Furthermore, emi(Sergio Bacchi)
49
tt( s dot bacchi at gmail dot com) did an impressive job when translating the
50
Annotations into Portuguese. His translation (which may lag a distribution or
51
two behind the latest verstion of the Annotations) may also be retrieved
52
from the tt(contributions/) subdirectory in the
53
tt(c++-annotations_X.Y.Z.tar.gz) archive at+nl()
54
lurl(http://sourceforge.net/projects/cppannotations/)
55
it() Version 6.3.0 added new sections about anonymous objects (section
56
ref(ANONYMOUS)) and type resolution with class templates (section
57
ref(TYPERES)). Also the description of the template parameter deduction
58
algorithm was rewritten (cf. section ref(PARDEDUCT)) and numerous
59
modifications required because of the compiler's closer adherence to the
60
bf(C++) standard were realized, among which exception rethrowing from
61
constructor and destructor function try blocks. Also, all textual corrections
62
received from readers since version 6.2.4 were processed.
63
it() In version 6.2.4 many textual improvements were realized. I received
64
extensive lists of typos and suggestions for clarifications of the text, in
65
particular from Nathan Johnson and from Jakob van Bethlehem. Equally valuable
66
were suggestions I received from various other readers of the bf(C++)
67
annotations: all were processed in this release. The bf(C++) content matter of
68
this release was not substantially modified, compared to version 6.2.2.
69
it() Version 6.2.2 offers improved implementations of the configurable
70
class templates (removed in 8.1.0, superseded by lambda functions).
71
it() Version 6.2.0 was released as an Annual Update, by the end of May,
72
2005. Apart from the usual typo corrections several new sections
73
were added and some were removed: in the Exception chapter (ref(EXCEPTIONS)) a
74
section was added covering the standard exceptions and their meanings; in the
75
chapter covering static members (ref(StaticDataFun)) a section was added
76
discussing tt(static const) data members; and the final chapter
77
(ref(CONCRETE)) covers configurable class templates using em(local context
78
structs) (replacing the previous tt(ForEach, UnaryPredicate) and
79
tt(BinaryPredicate) classes). Furthermore, the final section (covering a
80
bf(C++) parser generator) now uses bf(bisonc++), rather than the old
81
(and somewhat outdated) bf(bison++) program.
82
it() Version 6.1.0 was released shortly after releasing 6.0.0. Following
83
suggestions received from nemail(Leo Razoumov)(LEOR@winmain.rutgers.edu) and
84
Paulo Tribolet, and after receiving many, many useful suggestions and
85
extensive help from Leo, navigatable tt(.pdf) files are from now on
86
distributed with the bf(C++) Annotations. Also, some sections were slightly
87
adapted. COMMENT(e.g., section ref(FOREACHWRAPPER).)
88
it() Version 6.0.0 was released after a full update of the text, removing
89
many inconsistencies and typos. Since the update effected the Annotation's
90
full text an upgrade to a new major version seemed appropriate. Several new
91
sections were added: overloading binary operators (section
92
ref(OVERLOADBINARY)); throwing exceptions in constructors and destructors
93
(section ref(CONSEXCEPTIONS)); function tt(try)-blocks (section ref(FUNTRY));
94
calling conventions of static and global functions (section
95
ref(CALLINGCONVENTION)) and virtual constructors (section ref(VIRTCONS)). The
96
chapter on templates was completely rewritten and split into two separate
97
chapters: chapter ref(TEMPLATES) discusses the syntax and use of template
98
em(functions); chapter ref(TEMPCLASS) discusses template em(classes). Various
99
concrete examples were modified; new examples were included as well (chapter
101
it() In version 5.2.4 the description of the em(random_shuffle) generic
102
algorithm (section ref(SHUFFLE)) was modified.
103
it() In version 5.2.3 section ref(LOCALVARS) on local variables was
104
extended and section ref(FunctionOverloading) on function overloading was
105
modified by explicitly discussing the effects of the bf(const) modifier with
106
overloaded functions. Also, the description of the tt(compare()) function in
107
chapter ref(String) contained an error, which was repaired.
108
it() In version 5.2.2 a leftover in section ref(EXPLICIT)
109
from a former version was removed and the corresponding text was
110
updated. Also, some minor typos were corrected.
111
it() In version 5.2.1 various typos were repaired, and some paragraphs
112
were further clarified. Furthermore, a section was added to the em(template)
113
chapter (chapter ref(TEMPLATES)), about creating several tt(iterator)
114
types. This topic was further elaborated in chapter ref(CONCRETE), where the
115
section about the construction of a reverse iterator (section
116
ref(CONCRETEITER)) was completely rewritten. In the same chapter, a
117
em(universal text to anything convertor) is discussed (section ref(A2X)).
118
Also, tt(LaTeX), tt(PostScript) and tt(PDF) versions fitting the
120
hi(letter (US paper size)) paper size are now available as
121
hi(cplusplusus) tt(cplusplus)bf(us) versions: tt(cplusplusus.latex,
122
cplusplusus.ps) and tt(cplusplus.pdf). The em(A4-paper) size is of course
123
kept, and remains to be available in the tt(cplusplus.latex, cplusplus.ps) and
124
tt(cpluspl.pdf) files.
126
IFDEF(html)(nl()Finally, readers might be interested in reading the new
127
section ref(FREELECTURES), where the concept of emi(free lectures) is
130
it() Version 5.2.0 was released after adding a section about
132
tt(mutable) keyword (section ref(MUTABLE)), and after thoroughly changing the
133
discussion of the tt(Fork()) abstract base class (section ref(FORK)). All
134
examples should now be up-to-date with respect to the use of the tt(std)
136
it() However, in the meantime the Gnu
137
g++ compiler version 3.2 was hi(http://www.gnu.org)
138
released+footnote(tlurl(http://www.gnu.org)). In this version extensions to
139
the abstract containers (see chapter ref(CONTAINERS)) like the hash_map were
140
placed in a separate namespace, ti(__gnu_cxx). This namespace should be used
141
when using these containers. However, this may break compilations of sources
142
with tt(g++), version 3.0. In that case, a compilation can be performed
143
conditionally to the 3.2 and the 3.0 compiler version, defining tt(__gnu_cxx)
144
for the 3.2 version. Alternatively, the em(dirty trick)
146
#define __gnu_cxx std
148
can be placed just before header files in which the tt(__gnu_cxx)
149
namespace is used. This might eventually result in name-collisions, and it's a
150
dirty trick by any standards, so please don't tell anybody I wrote this down.
151
it() Version 5.1.1 was released after modifying the sections related to
152
the tt(fork()) system call in chapter ref(CONCRETE). Under the i(ANSI/ISO)
153
standard many of the previously available extensions (like ti(procbuf), and
154
ti(vform)) applied to streams were discontinued. Starting with version
155
5.1.1. ways of constructing these facilities under the ANSI/ISO standard are
156
discussed in the bf(C++) Annotations. I consider the involved subject
157
sufficiently complex to warrant the upgrade to a new subversion.
158
it() With the advent of the Gnu tt(g++) compiler version 3.00, a more
159
strict implementation of the ANSI/ISO bf(C++) standard became
160
available. This resulted in version 5.1.0 of the Annotations, appearing
161
shortly after version 5.0.0. In version 5.1.0 chapter ref(IOStreams) was
162
modified and several cosmetic changes took place (e.g., removing tt(class)
163
from template type parameter lists, see chapter ref(TEMPLATES)). Intermediate
164
versions (like 5.0.0a, 5.0.0b) were not further documented, but were mere
165
intermediate releases while approaching version 5.1.0. Code
166
examples will gradually be adapted to the new release of the compiler.
168
In the meantime the reader should be prepared to insert
169
tt(using namespace std;)
170
in many code examples, just beyond the ti(#include)
171
preprocessor directives as a temporary measure to make the
172
example accepted by the compiler.
174
it() New insights develop all the time, resulting in version 5.0.0 of the
175
Annotations. In this version a lot of old code was cleaned up and typos were
176
repaired. According to current standard, em(namespaces) are required in
177
bf(C++) programs, so they are introduced now very early (in section
178
ref(INTRONAME)) in the Annotations. A new section about using external
179
programs was added to the Annotations (and removed again in version 5.1.0),
180
and the new tt(stringstream) class, replacing the tt(strstream) class is now
181
covered too (sections ref(OSTRINGSTREAM) and ref(ISTRINGSTREAM)). Actually,
182
the chapter on input and output was completely rewritten. Furthermore, the
183
operators tt(new) and tt(delete) are now discussed in chapter ref(MEMORY),
184
where they fit better than in a chapter on classes, where they previously were
185
discussed. Chapters were moved, split and reordered, so that subjects could
186
generally be introduced without forward references. Finally, the tt(html),
187
PostScript and pdf versions of the bf(C++) Annotations now contain an
188
index (sigh of relief ?) All in, considering the volume and nature of the
189
modifications, it seemed right to upgrade to a full major version. So here it
192
Considering the volume of the Annotations, I'm sure there will be
193
typos found every now and then. Please do not hesitate to send me mail
194
containing any mistakes you find or corrections you would like to suggest.
195
it() In release tt(4.4.1b) the pagesize in the LaTeX file was defined to
196
be tt(din A4). In countries where other pagesizes are standard the default
197
pagesize might be a better choice. In that case, remove the
198
tt(a4paper,twoside) option from tt(cplusplus.tex) (or tt(cplusplus.yo) if you
199
have tt(yodl) installed), and reconstruct the Annotations from the
200
em(TeX)-file or tt(Yodl)-files.
202
The Annotations mailing lists was stopped at release tt(4.4.1d). From this
203
point on only minor modifications were expected, which are not anymore
206
At some point, I considered version tt(4.4.1) to be the final version of the
207
bf(C++) Annotations. However, a section on special I/O functions was added to
208
cover unformatted I/O, and the section about the tt(string) datatype had its
209
layout improved and was, due to its volume, given a chapter of its own
210
(chapter ref(String)). All this eventually resulted in version tt(4.4.2).
212
Version tt(4.4.1) again contains new material, and reflects the
213
hi(ftp://research.att.com/dist/c++std/WP/)
214
url(ANSI/ISO)(ftp://research.att.com/dist/c++std/WP/) standard (well, I try to
215
have it reflect the ANSI/ISO standard). In version 4.4.1. several new
216
sections and chapters were added, among which a chapter about the
217
em(Standard Template Library) (STL) and em(generic algorithms).
219
Version tt(4.4.0) (and subletters) was a mere construction version and was
220
never made available.
222
The version tt(4.3.1a) is a precursor of tt(4.3.2). In tt(4.3.1a) most of the
223
typos I've received since the last update have been processed. In version
224
tt(4.3.2) extra attention was paid to the syntax for function addresses and
225
pointers to member functions.
227
The decision to upgrade from version 4.2.* to 4.3.* was made after realizing
228
that the lexical scanner function tt(yylex()) can be defined in the
229
scanner class that is derived from tt(yyFlexLexer). Under this approach
230
the tt(yylex()) function can access the members of the class derived from
231
tt(yyFlexLexer) as well as the public and protected members of
232
tt(yyFlexLexer). The result of all this is a clean implementation of the rules
233
defined in the tt(flex++) specification file.
235
The upgrade from version 4.1.* to 4.2.* was the result of the inclusion of
236
section ref(BOOL) about the bf(bool) data type in chapter
237
ref(FirstImpression). The distinction between differences between bf(C) and
238
bf(C++) and extensions of the bf(C) programming languages is (albeit a bit
239
fuzzy) reflected in the introduction chapter and the chapter on first
240
impressions of bf(C++): The link(introduction chapter)(IntroC)
241
covers some differences between bf(C) and bf(C++), whereas the chapter about
242
link(first impressions)(FirstImpression) of bf(C++) covers some extensions of
243
the bf(C) programming language as found in bf(C++).
245
Major version 4 is a major rewrite of the previous
246
version 3.4.14. The document was rewritten from SGML to
248
new sections were added. All sections got a tune-up. The distribution basis,
249
however, hasn't changed: see link(the introduction)(IntroC).
251
Modifications in versions 1.*.*, 2.*.*, and 3.*.* (replace the stars by any
252
applicable number) were not logged.
254
Subreleases like tt(4.4.2a) etc. contain bugfixes and typographical
added
removed
yo/whatsnew.yo.old
