Table of contents for issues of C++ Report

Last update: Sun Sep 19 23:16:22 MDT 2010                Valid HTML 3.2!

Volume 3, Number 6, June, 1991
Volume 3, Number 7, July / August, 1991
Volume 3, Number 8, September, 1991
Volume 3, Number 9, October, 1991
Volume 3, Number 10, November / December, 1991
Volume 4, Number 1, January, 1992
Volume 4, Number 2, February, 1992
Volume 4, Number 3, March / April, 1992
Volume 4, Number 4, May, 1992
Volume 4, Number 5, June, 1992
Volume 4, Number 6, July / August, 1992
Volume 4, Number 7, September, 1992
Volume 4, Number 8, October, 1992
Volume 5, Number 1, January, 1993
Volume 5, Number 2, February, 1993
Volume 5, Number 3, March / April, 1993
Volume 5, Number 4, May, 1993
Volume 5, Number 5, June, 1993
Volume 5, Number 6, July / August, 1993
Volume 5, Number 7, September, 1993
Volume 5, Number 8, October, 1993
Volume 6, Number 1, January, 1994
Volume 6, Number 2, February, 1994
Volume 6, Number 3, March / April, 1994
Volume 6, Number 4, May, 1994
Volume 6, Number 5, June, 1994
Volume 6, Number 6, July / August, 1994
Volume 6, Number 7, September, 1994
Volume 6, Number 8, October, 1994
Volume 7, Number 1, January, 1995
Volume 7, Number 2, February, 1995
Volume 7, Number 3, March / April, 1995
Volume 7, Number 4, May, 1995
Volume 7, Number 5, June, 1995
Volume 8, Number 1, January, 1996
Volume 8, Number 2, February, 1996
Volume 8, Number 3, March, 1996
Volume 8, Number 4, April, 1996
Volume 8, Number 5, May, 1996
Volume 8, Number 6, June, 1996
Volume 8, Number 7, July, 1996
Volume 8, Number 8, September, 1996
Volume 8, Number 9, October, 1996
Volume 8, Number 10, November / December, 1996
Volume 9, Number 1, January, 1997
Volume 9, Number 2, February, 1997
Volume 9, Number 3, March, 1997
Volume 9, Number 4, April, 1997
Volume 9, Number 5, May, 1997


C++ Report
Volume 3, Number 6, June, 1991

                   G. Booch and   
                       M. Vilot   C++ library design . . . . . . . . . . . 10--14
                C. S. Horstmann   A first look at programming Windows with
                                  C++/Views and Borland C++  . . . . . . . 15--18, 24
                      S. Druker   `What's that compiler doing, anyway?'
                                  --- virtual function overhead  . . . . . 19--20
                  J. M. Coggins   Why does this program run so long? . . . 21--24
                   D. Steinhoff   Saber-C++ version 1.0  . . . . . . . . . 26--27, 30

C++ Report
Volume 3, Number 7, July / August, 1991

                   G. Booch and   
                       M. Vilot   Object-oriented design-C++ class
                                  categories . . . . . . . . . . . . . . . 6--10
                       B. Eckel   Containers and iterators in C++  . . . . 12--13
                        A. Lane   DOS/C++ --- application frameworks . . . 14--15
                R. Brazille and   
                     B. Leggett   The Object Interface Library . . . . . . 18--20, 22, 24

C++ Report
Volume 3, Number 8, September, 1991

                     J. Coplien   Experience with CRC cards in AT&T . . . . 1, 4--6
                   G. Booch and   
                       M. Vilot   Object-oriented analysis and design  . . 7--10
                     T. Cargill   CRC cards (OO programming) . . . . . . . 11--13

C++ Report
Volume 3, Number 9, October, 1991

                   G. Booch and   
                       M. Vilot   The object-oriented development process  8--11
                      I. Huneke   Linking C with C++ . . . . . . . . . . . 12, 16
                  C. J. Van Wyk   Simultaneous equations are your friends  14--16
                  J. M. Coggins   Naming conventions in C++ libraries  . . 17--21

C++ Report
Volume 3, Number 10, November / December, 1991

                   J. P. LeJacq   Education can you do better than C++?    1, 4--6
                   G. Booch and   
                       M. Vilot   Object-oriented design documents . . . . 8, 10--12
                        D. Saks   ANSI C++ update: works in progress . . . 13--14, 16
                   C. Horstmann   An in-depth look as Borland C++  . . . . 17--20
                  J. M. Coggins   Best of \path|comp.lang.C++| --- much
                                  ado about null . . . . . . . . . . . . . 21--24


C++ Report
Volume 4, Number 1, January, 1992

                      J. Soukup   Selecting a C++ library  . . . . . . . . 1, 4--6
                   G. Booch and   
                       M. Vilot   Object-oriented design: physical design:
                                  storage management . . . . . . . . . . . 7--10
                        D. Saks   ANSI C++ update: works in progress . . . 11--14
                   C. Horstmann   The object-based class library in
                                  Borland C++  . . . . . . . . . . . . . . 15--18
                  J. M. Coggins   Handling failed constructors gracefully  20--22

C++ Report
Volume 4, Number 2, February, 1992

                   G. McCluskey   An environment for template
                                  instantiation  . . . . . . . . . . . . . 1, 4--7
                   G. Booch and   
                       M. Vilot   Physical design: storage and management
                                  libraries (OOP)  . . . . . . . . . . . . 8--10
                      J. Soukup   Memory-resident databases  . . . . . . . 11--15
                      C. Skelly   Getting a handle on the new-handler  . . 16--18
                  J. M. Coggins   An array of questions about arrays . . . 19--22
                     N. Hamsath   Zortech C++ Developers Edition . . . . . 23--25

C++ Report
Volume 4, Number 3, March / April, 1992

              B. Stroustrup and   
                      D. Lenkov   Runtime type identification for C++  . . 32--42
                 S. C. Dewhurst   Distributed abstract interfaces  . . . . 44--50
                      J. Musser   Extending streambufs: class logstrbuf
                                  (OOP)  . . . . . . . . . . . . . . . . . 51--55

C++ Report
Volume 4, Number 4, May, 1992

                  S. Buroff and   
                      R. Murray   The C++ Oracle . . . . . . . . . . . . . 9--10
                       B. Eckel   Virtual constructors. 2  . . . . . . . . 13--16
                   G. Booch and   
                       M. Vilot   Logical design: software component
                                  libraries  . . . . . . . . . . . . . . . 18, 20--22
                      C. Skelly   In the land of OOP . . . . . . . . . . . 23--26
                      J. Soukup   Beyond templates. 1. (C++) . . . . . . . 27--31
                   G. Horstmann   The Microsoft C/C++ Version 7 compiler:
                                  A first impression . . . . . . . . . . . 53--57
                  J. M. Coggins   Questioning conventional `wisdom' about
                                  C++ code size and execution speed  . . . 58--61

C++ Report
Volume 4, Number 5, June, 1992

                N. M. Wilkinson   Subtleties of C++ operator overloading   36--41
                  H. Strickland   Object databases: a deep look at
                                  transparency . . . . . . . . . . . . . . 42--46
                     T. Cargill   A dynamic vector is harder than it looks 47--50
                     B. Leggett   The USL C++ Standard Components release
                                  2 (end user package) . . . . . . . . . . 69--73

C++ Report
Volume 4, Number 6, July / August, 1992

                      S. Meyers   Using C++ effectively. Approaches to
                                  effectiveness  . . . . . . . . . . . . . 34--39
                 S. Tavakkolian   Crossing paradigms. A pilgrim's journey
                                  from C to C++  . . . . . . . . . . . . . 40--45
                      R. Martin   Abstract classes and pure virtual
                                  functions  . . . . . . . . . . . . . . . 46--52

C++ Report
Volume 4, Number 7, September, 1992

                        M. Ball   Inside templates: implementing C++
                                  strategies . . . . . . . . . . . . . . . 36--40
                      P. Becker   A msgstream class for smart formatting:
                                  Easing the translator's job  . . . . . . 42--48
                 D. Bartels and   
                       J. Robie   Persistent objects and object-oriented
                                  databases for C++  . . . . . . . . . . . 49--50, 52--56

C++ Report
Volume 4, Number 8, October, 1992

                     M. Carroll   Invasive inheritance: modifying a base
                                  class to enable inheritance  . . . . . . 34--42
                     M. Banahan   Cross-over training: making the
                                  transition from C to C++ . . . . . . . . 44--48
                     D. Schmidt   Systems programming with C++ wrappers:
                                  encapsulating IPC services with
                                  object-oriented interfaces . . . . . . . 50--54


C++ Report
Volume 5, Number 1, January, 1993

                      S. Meyers   Using C++ effectively. Examining
                                  development tools  . . . . . . . . . . . 30, 32--35
                        D. Reed   Engineering the transition to C++: a
                                  manager's perspective on realizing the
                                  benefits of OOP  . . . . . . . . . . . . 36, 38--42
                   D. Vines and   
                   Z. Kishimoto   Smalltalk's runtime type support for C++ 44--52

C++ Report
Volume 5, Number 2, February, 1993

                  J. M. Coggins   Practical principles for library design.
                                  I. Selecting the right abstractions is
                                  the key  . . . . . . . . . . . . . . . . 38--42
                  D. C. Schmidt   Encapsulating operating system IPCs. An
                                  object-oriented interface for
                                  event-driven UNIX I/O multiplexing . . . 43--50
                      P. Becker   Iterators, portability, and reuse  . . . 51--54

C++ Report
Volume 5, Number 3, March / April, 1993

                  W. Atwood and   
              A. Breakstone and   
                 D. Britton and   
                 T. Burnett and   
                   D. Myers and   
                        G. Word   The GISMO project (C++)  . . . . . . . . 38--43
                    M. Sakkinen   How should virtual bases be initialized
                                  (and finalized)? . . . . . . . . . . . . 44--50
                 S. C. Dewhurst   Subobject members  . . . . . . . . . . . 51--53

C++ Report
Volume 5, Number 4, May, 1993

                 J. Webster and   
                     F. Douglas   C++ is everywhere  . . . . . . . . . . . 36--39
                     R. J. Reid   C++ as a first programming language  . . 41--44
                       S. Teale   Transplanting a tree-recursive LISP
                                  algorithm to C++ . . . . . . . . . . . . 45--48

C++ Report
Volume 5, Number 5, June, 1993

                  B. Stroustrup   Library design using C++ . . . . . . . . 14--22
                         D. Lea   The GNU C++ library  . . . . . . . . . . 24--27
                      T. Keffer   The design and architecture of Tools.h++ 28--33
                     M. Carroll   Design of the USL Standard Components    34--39, 53
                   G. Booch and   
                       M. Vilot   Simplifying the Booch Components . . . . 41--52

C++ Report
Volume 5, Number 6, July / August, 1993

                   T. L. Hansen   Enhancing memory allocation. An array
                                  reallocation/renew function for C++  . . 20--22, 24, 26--30
                     S. Vinoski   Distributed object computing with CORBA  32--38
                    N. C. Myers   Memory management in C++. I. Fine-tuning
                                  your programs  . . . . . . . . . . . . . 39--41, 43

C++ Report
Volume 5, Number 7, September, 1993

               J. J. Barton and   
                  L. R. Nackman   Scientific and engineering programming
                                  in C++: grafting onto our roots  . . . . 26--31
                  D. C. Schmidt   A C++ wrapper for UNIX I/O multiplexing:
                                  the object-oriented design and
                                  implementation of the Reactor  . . . . . 32--43
               B. P. Stroustrup   Why consider language extensions?
                                  Maintaining a delicate balance . . . . . 44--51

C++ Report
Volume 5, Number 8, October, 1993

                    M. Stal and   
                 U. Steinmuller   Generic dynamic arrays: integrating
                                  dynamic arrays into C++ templates  . . . 30--35, 38
                     D. R. Reed   Exceptions: pragmatic issues with a new
                                  language feature . . . . . . . . . . . . 39--44
                  H. Strickland   ODMG-93: the object database standard
                                  for C++  . . . . . . . . . . . . . . . . 45--48


C++ Report
Volume 6, Number 1, January, 1994

                W. F. Tichy and   
                  J. Heilig and   
            F. Newbery Paulisch   A generative and generic approach to
                                  persistence  . . . . . . . . . . . . . . 22--33
                   S. Churchill   Exception recovery with smart pointers   34--35, 38--42
               E. Arjomandi and   
               W. O'Farrell and   
                       I. Kalas   Concurrency support for C++: an overview 44--50

C++ Report
Volume 6, Number 2, February, 1994

                      R. Martin   A practical example of object-oriented
                                  analysis and design  . . . . . . . . . . 18--23
              I. Silva-Lepe and   
                  W. Hursch and   
                    G. Sullivan   A report on Demeter C++  . . . . . . . . 24--30
                  C. L. Havener   A C++ application story  . . . . . . . . 31--33

C++ Report
Volume 6, Number 3, March / April, 1994

                      J. Lajoie   Exception handling: supporting the
                                  runtime mechanism  . . . . . . . . . . . 36--39, 42--43
                    R. van Loon   Introducing the X Window System  . . . . 45--47
                     D. Schmidt   A domain analysis of network daemon
                                  design dimensions  . . . . . . . . . . . 50--59

C++ Report
Volume 6, Number 4, May, 1994

                C. S. Horstmann   Extending the iostream library . . . . . 22--29
                    M. Moudgill   Reverse-engineering manipulators . . . . 30--33
                    M. Stal and   
                 U. Steinmuller   Implementing a text editor using dynamic
                                  arrays . . . . . . . . . . . . . . . . . 34--39, 46

C++ Report
Volume 6, Number 5, June, 1994

                      J. Lajoie   Exception handling: supporting
                                  first-class objects  . . . . . . . . . . 35--39

C++ Report
Volume 6, Number 6, July / August, 1994

                  J. O. Coplien   Generative pattern languages: an
                                  emerging direction of software design    18--22, 66--67
                       J. Robie   Event handling in object-oriented
                                  databases  . . . . . . . . . . . . . . . 24--27
                  D. C. Schmidt   A case study of C++ design evolution . . 28--36

C++ Report
Volume 6, Number 7, September, 1994

                     S. Vinoski   Mapping CORBA IDL into C++ . . . . . . . 20--23, 55
                    J. Crawford   Runtime parameterization. 1  . . . . . . 24--29

C++ Report
Volume 6, Number 8, October, 1994

                    M. J. Vilot   An introduction to the Standard Template
                                  Library  . . . . . . . . . . . . . . . . 22--29, 35
                  B. Stroustrup   Making a vector fit for a standard . . . 30--34
                    S. R. Davis   Armor cladding C++ classes . . . . . . . 36--39, 41


C++ Report
Volume 7, Number 1, January, 1995

                    M. Speh and   
                     C. Dinnell   C++ and the World Wide Web . . . . . . . 18--23
                G. Flanagin and   
                      N. Rimmer   Doing it (C++ software reuse project)    24--28
                 M. Carroll and   
                       M. Ellis   Tradeoffs of interface classes . . . . . 29--32
               J. J. Barton and   
                  L. R. Nackman   Dimensional analysis . . . . . . . . . . 39--40, 42--43
                C. S. Horstmann   OO design tools with C++ code generation 56--58, 60--64

C++ Report
Volume 7, Number 2, February, 1995

                    M. J. Vilot   The C++ standard library . . . . . . . . 28--34
                       D. Remba   A survey of the computer generated
                                  imagery landscape  . . . . . . . . . . . 36--41
                      R. Hickey   Callbacks in C++ using template functors 42--50
            T. Kontogiorgos and   
                         M. Kim   A C++ template-based application
                                  architecture . . . . . . . . . . . . . . 51--56, 58
                 S. Vinoski and   
                     D. Schmidt   DOC by example: modelling distributed
                                  object applications  . . . . . . . . . . 64--68

C++ Report
Volume 7, Number 3, March / April, 1995

                   M. Ellis and   
                     M. Carroll   Tradeoffs of exceptions  . . . . . . . . 12, 14, 16
                      S. Meyers   Bounding object instantiations. I  . . . 18--22
                      D. Jordan   Identifying ODMG objects . . . . . . . . 24, 26--27
                         D. Box   Building C++ components using OLE2 . . . 28--34
                   J. Vlissides   Pattern hatching-perspectives from the
                                  ``gang of four'' . . . . . . . . . . . . 36--39
                      J. Lajoie   Standards update: type conversions . . . 40--46
              D. C. Schmidt and   
                  P. Stephenson   Using design patterns to evolve system
                                  software from UNIX to Windows NT . . . . 47--60
               J. J. Barton and   
                  L. R. Nackman   Algebra for C++ operators  . . . . . . . 70--74
                 E. B. Flanagan   Risky business (software development
                                  management)  . . . . . . . . . . . . . . 75--76, 78

C++ Report
Volume 7, Number 4, May, 1995

                        Don Box   Porting to Klingon --- Porting source
                                  code written to process English language
                                  text to other languages is not easily
                                  done. Don explains why Unicode is
                                  important for Windows developers . . . . 15--19
                    B. Berg and   
                    E. Rowlance   An object-oriented framework for I/O . . 28--35
                  T. Veldhuizen   Using C++ template metaprograms  . . . . 36--38, 40, 42--43
                S. Trinoski and   
                     D. Schmidt   Comparing alternative distributed
                                  programming techniques . . . . . . . . . 44--53

C++ Report
Volume 7, Number 5, June, 1995

                  T. Veldhuizen   Expression templates . . . . . . . . . . 26--31
                       N. Myers   A new and useful technique: ``traits''   32--35
                    J. H. Peden   Operator ()() for array of array (of
                                  array) class access  . . . . . . . . . . 36--38, 40--41


C++ Report
Volume 8, Number 1, January, 1996

                      J. Lajoie   Function overload resolution: selection
                                  of the best viable function  . . . . . . 12--17, 56
                       G. Glass   STL in action. Helper algorithms . . . . 18--21
                   H. M. Muller   Ten rules for handling exception
                                  handling successfully  . . . . . . . . . 22--36
                   R. C. Martin   The open-closed principle [software
                                  maintenance] . . . . . . . . . . . . . . 37--43
                  D. C. Schmidt   Connector. A design pattern for actively
                                  initializing network services  . . . . . 46--50, 52--56
                       F. Onion   Object persistence in MFC  . . . . . . . 57--60
                C. S. Horstmann   C++ class libraries for numerical
                                  programming  . . . . . . . . . . . . . . 61--64, 66
                  J. O. Coplien   The human side of patterns . . . . . . . 73--74, 76--78, 80

C++ Report
Volume 8, Number 2, February, 1996

                   J. Vlissides   Protection. I. The Hollywood principle   14, 16--19
                       S. Leary   C++ exception handling in multithreaded
                                  programs . . . . . . . . . . . . . . . . 20--31
                 M. L. Kamahele   ShMem --- a C++ class library for
                                  managing objects in shared memory  . . . 32--39, 60
                 J. Fitzpatrick   A case study: converting C programs to
                                  C++  . . . . . . . . . . . . . . . . . . 40--45, 63
                     T. Cargill   An overview of Java for C++ programmers  46--49
              D. C. Schmidt and   
                     S. Vinoski   Comparing alternative programming
                                  techniques for multithreaded servers . . 50--59
               J. J. Barton and   
                  L. R. Nackman   Automatic differentiation  . . . . . . . 61--63
                      D. Jordan   OQL: the Object Query Language . . . . . 64--66, 71--73

C++ Report
Volume 8, Number 3, March, 1996

                     K. Jameson   Multiplatform productivity lessons . . . CPS4--CPS6, CPS9
                     M. Jeghers   GUI development with cross platform
                                  toolkits . . . . . . . . . . . . . . . . CPS7--CPS9
                   R. C. Martin   The Liskov substitution principle  . . . 14, 16--17, 20--23
                   J. W. Reeves   Coping with exceptions . . . . . . . . . 24--35
                    D. Forguson   Programming with the MFC document
                                  template architecture  . . . . . . . . . 36--41
                    J. Hamilton   Reusing binary objects with DirectToSOM
                                  C++  . . . . . . . . . . . . . . . . . . 42--51
                         D. Box   Com smart pointers also considered
                                  harmful  . . . . . . . . . . . . . . . . 54--57
                   F. Onion and   
                    A. Harrison   Dynamic data structure serialization in
                                  MFC  . . . . . . . . . . . . . . . . . . 58--62
                C. S. Horstmann   Java programming with Sun's Java
                                  development kit  . . . . . . . . . . . . 63--70

C++ Report
Volume 8, Number 4, April, 1996

                   J. Vlissides   Protection: membership has its
                                  privileges . . . . . . . . . . . . . . . 11--13, 16--18, 28
                      S. Meyers   Smart pointers. I  . . . . . . . . . . . 19--23
                    R. Van Loon   The power of multimedia. Strengthen your
                                  applications to power multimedia
                                  features . . . . . . . . . . . . . . . . 24--28
                       S. Cohen   Dynamic inheritance in C++ . . . . . . . 30--37
                  M. Van Rooyen   Alternative C++. New methods for solving
                                  old problems . . . . . . . . . . . . . . 38--42
                    D. Forguson   Extending the MFC document template
                                  architecture . . . . . . . . . . . . . . 43--53
              D. C. Schmidt and   
                     S. Vinoski   Comparing alternative programming
                                  techniques for multithreaded CORBA
                                  servers  . . . . . . . . . . . . . . . . 56--66
               J. J. Barton and   
                  L. R. Nackman   Hello ANSI/ISO . . . . . . . . . . . . . 68--70, 72--73
                       G. Glass   A universal streaming service  . . . . . 74--76, 81--83

C++ Report
Volume 8, Number 5, May, 1996

                       S. Cohen   Lightweight persistence in C++ . . . . . 22--32
                        C. Moth   Lightweight classes  . . . . . . . . . . 33--39
                   T. Linenbach   Implementing reusable binary association
                                  in C++ . . . . . . . . . . . . . . . . . 40--47, 51
                   F. Onion and   
                    A. Harrison   Dialog data exchange in MFC  . . . . . . 48--51
                      J. Reeves   Exceptions and Standard C++  . . . . . . 56--59, 62--64
                      A. Koenig   Inheritance, assignment, and slicing . . 71--72
                      J. Lajoie   The memory model-type representations    73--76, 81--83

C++ Report
Volume 8, Number 6, June, 1996

                   J. Vlissides   To kill a singleton  . . . . . . . . . . 10, 12, 16--19
                      S. Meyers   Smart pointers, nullness, and type
                                  conversions  . . . . . . . . . . . . . . 20--23
                       J. Lakos   Large-scale C++ software design. 1.
                                  Mentor Graphics experiences using C++
                                  for large systems  . . . . . . . . . . . 26--37
                     S. Lippman   The varieties of object  . . . . . . . . 38--50
                  T. R. Mueller   Overcoming the problems in a large scale
                                  C++ project. AT&T's gamble with C++ as a
                                  primary programming language . . . . . . 51--52
                 J. Fitzpatrick   Redesigning a graphics test program
                                  using C++  . . . . . . . . . . . . . . . 54--60
                   R. C. Martin   The Dependency Inversion Principle . . . 61--66
                    D. Forguson   Developing the view component in MFC . . 67--74, 76
               J. J. Barton and   
                  L. R. Nackman   While (converting to C++) use iterators  77--78, 83, 87

C++ Report
Volume 8, Number 7, July, 1996

                  S. Henkel and   
                 W. Dangelmaier   Evaluating class libraries for
                                  interprocess communication . . . . . . . 21--29
                   K. Kreft and   
                      A. Langer   Iterators in the Standard Template
                                  Library  . . . . . . . . . . . . . . . . 31--37
             T. H. Harrison and   
                  D. C. Schmidt   Evaluating the performance of OO network
                                  programming toolkits . . . . . . . . . . 39--46
              D. C. Schmidt and   
                     S. Vinoski   Comparing alternative programming
                                  techniques for multithreaded CORBA
                                  servers  . . . . . . . . . . . . . . . . 47--56
                   F. Onion and   
                    A. Harrison   Chain of Responsibility and command
                                  targets  . . . . . . . . . . . . . . . . 57--59, 62--63
                   J. W. Reeves   Ten guidelines for exception
                                  specification  . . . . . . . . . . . . . 64--68, 70, 88

C++ Report
Volume 8, Number 8, September, 1996

                  H. Alicea and   
                       G. Glass   Using the universal streaming service
                                  with CORBA . . . . . . . . . . . . . . . 12--19
                    J. Vissides   The trouble with Observer  . . . . . . . 20--24
                      S. Meyers   Smart pointers: automating inheritance
                                  and const conversions  . . . . . . . . . 25--27
                    R. G. White   Advantages and disadvantages of unique
                                  representation patterns  . . . . . . . . 28--35
                     P. Gautier   Visitors revisited . . . . . . . . . . . 36--39, 42--45
                       D. Bulka   Performance and C++: separating myth
                                  from reality . . . . . . . . . . . . . . 46--54
                       J. Lakos   Large-scale C++ software design:
                                  physical hierarchy. 2. Effective
                                  testing, improved maintainability,
                                  independent reuse  . . . . . . . . . . . 55--64
                      A. Koenig   Copying and insertion in STL algorithms  65--66
                      J. Lajoie   The C++ memory model. Pointer
                                  manipulations  . . . . . . . . . . . . . 67--72

C++ Report
Volume 8, Number 9, October, 1996

                  J. O. Coplien   Code patterns  . . . . . . . . . . . . . 18--25
                      J. Lajoie   The C++ memory model: new and delete
                                  operators  . . . . . . . . . . . . . . . 26--33, 44
                      J. Lajoie   The C++ Standards Committee's sixth
                                  year-organization and schedule update    30--31
                      J. Soukup   Quality patterns . . . . . . . . . . . . 34--44
                      J. Soukup   Another controversy: managing groups of
                                  cooperating classes  . . . . . . . . . . 46--47
                 S. Vinoski and   
                  D. C. Schmidt   Distributed callbacks and decoupled
                                  communication in CORBA . . . . . . . . . 48--56, 77
                    D. Forguson   Extending the MFC document template
                                  architecture . . . . . . . . . . . . . . 57--65
               J. J. Barton and   
                  L. R. Nackman   Scientific and engineering C++-is this
                                  standard input?  . . . . . . . . . . . . 66, 68--69

C++ Report
Volume 8, Number 10, November / December, 1996

                   J. Vlissides   Generation Gap [software design pattern] 12, 14--18
                      S. Meyers   Refinements to smart pointers  . . . . . 19--22
                      A. Koenig   Containers and pointer comparisons . . . 23--26
                   K. Kreft and   
                      A. Langer   Iterators in the Standard C++ Library    27--30, 32
                  M. P. Lindner   Designing for safe hashing. Implementing
                                  efficient dynamic search structures  . . 36--41
                       J. Lakos   Large-scale C++ software design:
                                  levelization, insulation, and packages.
                                  3. Avoiding excessive compile- and
                                  link-time dependencies . . . . . . . . . 42--56
                   R. C. Martin   Granularity [object-oriented design] . . 57--62
                   J. W. Reeves   Exceptions and debugging [in C++]  . . . 63--71


C++ Report
Volume 9, Number 1, January, 1997

                  J. O. Coplien   Pattern languages  . . . . . . . . . . . 15--21
                   F. Onion and   
                    A. Harrison   Framework class factories  . . . . . . . 22--24
                      M. Hansen   How to reduce code bloat from STL
                                  containers . . . . . . . . . . . . . . . 34--41
                   R. C. Martin   Java and C++: a critical comparison  . . 42--49
                    P. Jain and   
                  D. C. Schmidt   Experiences converting a C++
                                  communication software framework to Java 50--66
                       G. Glass   The Java Generic Library . . . . . . . . 70--74

C++ Report
Volume 9, Number 2, February, 1997

              R. L. Stewart and   
                  J. Storey and   
                       D. Huang   Decentralized event handling . . . . . . 12--19
                   K. Kreft and   
                      A. Langer   Building an iterator for STL and the
                                  Standard C++ Library . . . . . . . . . . 20--27
                    J. Hamilton   Using Distributed SOM with DirectToSOM
                                  C++  . . . . . . . . . . . . . . . . . . 28--36
              D. C. Schmidt and   
                     S. Vinoski   The OMG Events Service . . . . . . . . . 37--46
                   J. Vlissides   Type laundering  . . . . . . . . . . . . 47--52
                   R. C. Martin   Large-scale stability  . . . . . . . . . 54--60
               J. J. Barton and   
                  L. R. Nackman   Generating and transforming  . . . . . . 62--64

C++ Report
Volume 9, Number 3, March, 1997

               R. C. Martin and   
              J. W. Newkirk and   
                         B. Rao   Taskmaster: an architecture pattern for
                                  GUI applications . . . . . . . . . . . . 12--14, 16--23
                P. Thompson and   
                  G. Bumgardner   Threads.h++: a portable C++ library for
                                  multithreaded programming  . . . . . . . 24--37
                     P. Jakubik   Patterns in practice: abstract client    38--44
                  A. Langer and   
                       K. Kreft   Combining object-oriented design and
                                  generic programming  . . . . . . . . . . 45--49, 69
                       F. Onion   Multithreading in MFC  . . . . . . . . . 50--53, 56
                   J. W. Reeves   Reflections on exceptions  . . . . . . . 57--65

C++ Report
Volume 9, Number 4, April, 1997

                       M. Davis   Well-mannered objects: tips on porting
                                  C++ to Java  . . . . . . . . . . . . . . 14--21
                 G. Cochran and   
                       R. Weisz   Developing reusable code in the real
                                  world: process and techniques  . . . . . 22--31
                        J. Sime   Guarded pointers: moving smart pointers
                                  into multithreaded systems . . . . . . . 32--41
                   R. C. Martin   Design patterns for dealing with dual
                                  inheritance hierarchies in C++ . . . . . 42--48
                      J. Soukup   Implementing patterns  . . . . . . . . . 49--50

C++ Report
Volume 9, Number 5, May, 1997

                       Jim Shur   Exploring Inner Classes in Java 1.1: As
                                  Java matures, it begs comparison to the
                                  robustness of C++. See how JDK 1.1's
                                  inner classes compare to nested classes  18--29, 68