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

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>//

s/#include<stream.h>/#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; }
public:

    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;
	return;
    }

    // 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()/

s/static_type()/get_info()/

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

pg472:  s/r.count/r.pcount/

pg474:  s/(chunk_size-esize)/chunk_size/