Printing 9 and up.  There are also errata for printings 1 and 6, and for the first year.
Errata for

Bjarne Stroustrup:
The C++ Programming Language (2nd edition)

Addison-Wesley, 1991, ISBN0-201-53992-6, printing 9 and up.
I do not mention corrections of spelling mistakes, indentation style, etc.
pg54 s/char* q = p;/const char* q = p;/

pg55 s/sec7.10/sec7.11/

pg80 s/look(const char*)/look(const char*, int =0)/

pg113 s/#define "myheade.h"/#include "myheade.h"/

pp154-155 look() and insert() take const char* arguments.

pg156 s/delete n->string;/delete[] n->string;/
s/delete tbl;/delete[] tbl;/
s/char* pp = p;/const char* pp = p;/

pg158 s/ok(int&/ok(const int&/

pg194 s/#include<iostream.h>//

pg227 fourth line from bottom: s/increment/decrement/

pg230 += and *= should return complex&

pg254 s/sec5.3/sec7.14.3/

pg265 top line: add template<class T>

pg279 The 2nd sentence of sec8.6 should read:
``In addition to type arguments, variable names, function names, and constant expressions can be used.''

pg286 the definition of Map should read:
template<class K, class V> class Map {
    friend class Mapiter<K,V>;
    Link<K,V>* head;
    Link<K,V>* current;
    V def_val;
    K def_key;
    int sz;

    static K kdef(); // default K value 
    static V vdef(); // default V value

    void find(const K&);
    void init() { sz = 0; head = 0; current = 0; }

    Map() : def_key(kdef()), def_val(vdef())
	{ init(); }
    Map(const K& k, const V& d) : def_key(k), def_val(d)
	{ init(); }
    ~Map() { delete head; } // delete all links recursively

    Map(const Map&);
    Map& operator= (const Map&);

    V& operator[] (const K&);

    int size() const { return sz; }
    void clear() { delete head; init(); }
    void remove(const K& k);

	// iteration functions:

    Mapiter<K,V> element(const K& k)
	(void) operator[](k);  // move current to k
	return Mapiter<K,V>(this,current);
    Mapiter<K,V> first() { return Mapiter<K,V>(this,head); }
    Mapiter<K,V> last();

template<class K, class V> K Map<K,V>::kdef()
    { static K k; return k; }
template<class K, class V> V Map<K,V>::vdef()
    { static V v; return v; }
pg287 s/8.10 [2]/8.9 [4]/

pg289 add template<class T> before each of the iterator functions.

pg305 s/MININT -/MININT +/

pg316 delete comment on get()

pg354 s/char alloc;/short alloc;/

pg409 s/X::a/C::a/

pg418 s/i<sz/i<=sz/

pg438 s/stream_iter/input_iter/

pg445 s/Base_iterator/base_iterator/

pg447 add to the declaration of base_iterator:
    base_iterator(const base_iterator&);
    base_iterator& operator=(const base_iterator&);
replace base_iterator::base_iterator() definition with:
base_iterator::base_iterator(const Type_info* bb, int direct)
    i = 0;

    if (direct) { // use list of direct bases 
	b = bb;
	alloc = 0;

    // create list of all bases:

    // int n = number of bases
    b = new (Type_info*)[n+1];
    alloc = 1;
    // put bases into b
pg448 replace definition of ptr_cast() and ref_cast() with:
#define ptr_cast(T,p) \
    (T::info().get_type_info()->can_cast((p)) ? (T*)(p) : 0)
#define ref_cast(T,r) \
    (T::info().get_type_info()->can_cast((r)) ? 0 : \
      throw Bad_cast(T::info().get_type_info()->name()), (T&)(r))
pg449 s/dynamic_type()/info()/

pg467 s/(*pf)()/(*pf)(void*)/

pg472 s/r.count/r.pcount/

pg474 s/(chunk_size-esize)/chunk_size/

To track new developments, both the Annotated Reference Manual and Bjarne Stroustrup's book have an identical ``extra'' chapter that is updated a couple of times a year.  Its most recent version and the most recent errata sheet are available from Software, Tool & Die's ftp server in directory AW/stroustrup2e.
Thanks to Bjarne Stroustrup ( for errata and pointer.
Markup, etc. by, corrections and comments welcomed.