%%% -*-BibTeX-*-
%%% ====================================================================
%%% BibTeX-file{
%%% author = "Nelson H. F. Beebe",
%%% version = "1.06",
%%% date = "19 September 2010",
%%% time = "10:40:45 MDT",
%%% filename = "cppreport.bib",
%%% address = "University of Utah
%%% Department of Mathematics, 110 LCB
%%% 155 S 1400 E RM 233
%%% Salt Lake City, UT 84112-0090
%%% USA",
%%% telephone = "+1 801 581 5254",
%%% FAX = "+1 801 581 4148",
%%% URL = "http://www.math.utah.edu/~beebe",
%%% checksum = "48421 8519 42422 408987",
%%% email = "beebe at math.utah.edu, beebe at acm.org,
%%% beebe at computer.org (Internet)",
%%% codetable = "ISO/ASCII",
%%% keywords = "BibTeX, bibliography, C++ Report",
%%% license = "public domain",
%%% supported = "yes",
%%% docstring = "This is a bibliography of publications in the
%%% magazine C++ Report (CODEN CRPTE7, ISSN
%%% 1040-6042), published by SIGS Publications.
%%%
%%% At version 1.05, the year coverage looked
%%% like this:
%%%
%%% 1991 ( 21) 1994 ( 21) 1997 ( 25)
%%% 1992 ( 34) 1995 ( 26)
%%% 1993 ( 26) 1996 ( 81)
%%%
%%% Article: 234
%%%
%%% Total entries: 234
%%%
%%% The journal has a World-Wide Web site at
%%% http://www.sigs.com/publications/docs/cppr/.
%%%
%%% This bibliography has been collected from
%%% bibliographies in the author's personal
%%% files, from the journal's Web site contents
%%% files, and from the IEEE INSPEC database
%%% (1991--1995).
%%%
%%% Numerous errors in the sources noted above
%%% have been corrected. Spelling has been
%%% verified with the UNIX spell and GNU ispell
%%% programs using the exception dictionary
%%% stored in the companion file with extension
%%% .sok.
%%%
%%% BibTeX citation tags are uniformly chosen
%%% as name:year:abbrev, where name is the
%%% family name of the first author or editor,
%%% year is a 4-digit number, and abbrev is a
%%% 3-letter condensation of important title
%%% words. Citation tags were automatically
%%% generated by software developed for the
%%% BibNet Project.
%%%
%%% In this bibliography, entries are sorted in
%%% publication order, using bibsort -byvolume.
%%%
%%% The checksum field above contains a CRC-16
%%% checksum as the first value, followed by the
%%% equivalent of the standard UNIX wc (word
%%% count) utility output of lines, words, and
%%% characters. This is produced by Robert
%%% Solovay's checksum utility.",
%%% }
%%% ====================================================================
@Preamble{"\input path.sty" #
"\hyphenation{
para-digm
para-digms
Call-eens
Dasch-bach
Thor-sten
}"}
%%% ====================================================================
%%% Acknowledgement abbreviations:
@String{ack-nhfb = "Nelson H. F. Beebe,
University of Utah,
Department of Mathematics, 110 LCB,
155 S 1400 E RM 233,
Salt Lake City, UT 84112-0090, USA,
Tel: +1 801 581 5254,
FAX: +1 801 581 4148,
e-mail: \path|beebe@math.utah.edu|,
\path|beebe@acm.org|,
\path|beebe@computer.org| (Internet),
URL: \path|http://www.math.utah.edu/~beebe/|"}
@String{ack-rc = "Roman Czyborra,
e-mail: \path=|czyborra@dds.nl|"}
%%% ====================================================================
%%% Journal abbreviations:
@String{j-C-PLUS-PLUS-REPORT = "C++ Report"}
%%% ====================================================================
%%% Bibliography entries:
@Article{Booch:1991:CLD,
author = "G. Booch and M. Vilot",
title = "{C++} library design",
journal = j-C-PLUS-PLUS-REPORT,
volume = "3",
number = "6",
pages = "10--14",
month = jun,
year = "1991",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The authors examine some design issues involved in
providing class libraries in C++. Library design is a
natural consequence of object-oriented design (OOD),
where we model the key abstractions of the problem
domain. Over time, the library components become the
reuseable elements of new applications. The authors
take a look at four aspects of C++ library design: the
separation of interface from implementation;
architectures other than the Smalltalk single-tree
approach; the increasing scale of libraries; and
performance concerns and steps toward resolving them.",
acknowledgement = ack-nhfb,
classcodes = "C6110B (Software engineering techniques); C6140D (High
level languages)",
classification = "C6110B (Software engineering techniques); C6140D
(High level languages)",
keywords = "abstractions; C language; C++ library design; Class
libraries; class libraries; Design issues; design
issues; elements; Interface; interface; key; Key
abstractions; Library components; library components;
Object-oriented design; object-oriented design;
object-oriented programming; Performance concerns;
performance concerns; Problem domain; problem domain;
reusability; reuseable; Reuseable elements; Smalltalk
single-; Smalltalk single-tree approach; software;
subroutines; tree approach",
thesaurus = "C language; Object-oriented programming; Software
reusability; Subroutines",
treatment = "P Practical",
}
@Article{Horstmann:1991:FLA,
author = "C. S. Horstmann",
title = "A first look at programming {Windows} with {C++\slash
Views} and {Borland C++}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "3",
number = "6",
pages = "15--18, 24",
month = jun,
year = "1991",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "A discussion is given on the author's experiences with
a C++ class library for programming under Microsoft
Windows: C++/Views Version 1.1, CNS Inc. The author
used the class library in conjunction with the Borland
C++ compiler (Version 2.0). His background makes him
the perfect guinea pig to find out whether someone who
knows C++ but essentially nothing about Windows can
become a productive Windows programmer with a toolkit
like C++/Views. He concludes that the answer is a
definite `yes'.",
acknowledgement = ack-nhfb,
affiliation = "Dept. of Math. and Comput. Sci., San Jose State Univ.,
CA, USA",
classcodes = "C6110 (Systems analysis and programming); C6140D (High
level languages); C6180 (User interfaces)",
classification = "C6110 (Systems analysis and programming); C6140D
(High level languages); C6180 (User interfaces)",
corpsource = "Dept. of Math. and Comput. Sci., San Jose State Univ.,
CA, USA",
keywords = "Borland C++; Borland C++ compiler; C language; C++
class library; C++/Views; compiler; graphical user
interfaces; Microsoft Windows; packages; programming;
software; Windows programmer",
thesaurus = "C language; Graphical user interfaces; Programming;
Software packages",
treatment = "A Application; P Practical; R Product Review",
}
@Article{Druker:1991:WCD,
author = "S. Druker",
title = "`What's that compiler doing, anyway?' --- virtual
function overhead",
journal = j-C-PLUS-PLUS-REPORT,
volume = "3",
number = "6",
pages = "19--20",
month = jun,
year = "1991",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "A programmer's best friend in C++ is a virtual
function. This is the primary vehicle for extending a
program, library, or other package of software. With
the appropriate design in mind, a clever programmer can
design years of value into a package written today. The
author presents a view of what goes on behind the
scenes of the Zortech C++ compiler for DOS in
implementing virtual functions and pointers to member
functions. This particular scheme has several
attractive features. The space required in the objects
themselves does not grow in the presence of multiple
inheritance in the language, unless the object
concerned inherits multiply somewhere. It lends a
natural and efficient implementation for pointers to
member functions. The technique uses an old idea called
thunks to implement these things. In the examples, a
notation is used to represent conceptual ideas. This
notation looks a lot like the programming language C
even though the compiler may not go through a C
translation phase.",
acknowledgement = ack-nhfb,
classcodes = "C6150C (Compilers, interpreters and other processors);
C6140D (High level languages); C6120 (File
organisation); C6110 (Systems analysis and
programming)",
classification = "C6110 (Systems analysis and programming); C6120
(File organisation); C6140D (High level languages);
C6150C (Compilers, interpreters and other processors)",
keywords = "C language; C++; conceptual; Conceptual ideas; data
structures; DOS; ideas; Member functions; member
functions; Multiple inheritance; multiple inheritance;
Pointers; pointers; program compilers; programming;
Programming language C; programming language C; Thunks;
thunks; Virtual function; virtual function; virtual
storage; Zortech C++ compiler",
thesaurus = "C language; Data structures; Program compilers;
Programming; Virtual storage",
treatment = "P Practical",
}
@Article{Coggins:1991:WDP,
author = "J. M. Coggins",
title = "Why does this program run so long?",
journal = j-C-PLUS-PLUS-REPORT,
volume = "3",
number = "6",
pages = "21--24",
month = jun,
year = "1991",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Conventional wisdom suggests that C++ code tends to be
somewhat slower than corresponding C code. Some real
data supports the opposite position: that C++ code can
be faster than corresponding C code. The author shows
that C++ can be competitive with C in execution speed,
but the programmer must exercise some caution in
developing elegant C++ expressions or be ready to pay
the price in performance. The trade-off between
elegance and pragmatics is a familiar one. The one
examined is a particularly dramatic instance involving
the operator+() function.",
acknowledgement = ack-nhfb,
affiliation = "Dept. of Comput. Sci., North Carolina Univ., Chapel
Hill, NC, USA",
classcodes = "C6140D (High level languages); C6110 (Systems analysis
and programming)",
classification = "C6110 (Systems analysis and programming); C6140D
(High level languages)",
corpsource = "Dept. of Comput. Sci., North Carolina Univ., Chapel
Hill, NC, USA",
keywords = "C code; C language; C++ code; elegant C++; Elegant C++
expressions; Execution speed; execution speed;
expressions; Performance; performance; Pragmatics;
pragmatics; Programmer; programmer; programming",
thesaurus = "C language; Programming",
treatment = "P Practical",
}
@Article{Steinhoff:1991:SV,
author = "D. Steinhoff",
title = "{Saber-C++} version 1.0",
journal = j-C-PLUS-PLUS-REPORT,
volume = "3",
number = "6",
pages = "26--27, 30",
month = jun,
year = "1991",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Saber Software has been shipping Saber-C++, their new
C++ programming environment, since 1990. This
second-generation tool builds upon the obvious success
of their earlier programming environment, Saber-C. Many
of the incremental programming and dynamic debugging
techniques they brought to UNIX with that earlier
product are present and expanded. Saber-C++
incorporates class, data, and file browsing, debugging,
incremental linking and a C++ interpreter into an
integrated environment. The product includes a slightly
modified (though `bug-compatible') version of cfront
2.0. In short, this is a tool for serious programming.
Programmers limping along with dbx and dbxtool or
similar tools should sit up and take note that this is
an order of magnitude improvement over what they are
used to.",
acknowledgement = ack-nhfb,
affiliation = "Appl. Dynamic Int., Ann Arbor, MI, USA",
classcodes = "C6115 (Programming support); C6110 (Systems analysis
and programming); C6140D (High level languages)",
classification = "C6110 (Systems analysis and programming); C6115
(Programming support); C6140D (High level languages)",
corpsource = "Appl. Dynamic Int., Ann Arbor, MI, USA",
keywords = "C language; C++; C++ interpreter; C++ programming
environment; dynamic debugging; Dynamic debugging
techniques; File browsing; file browsing; Incremental
linking; incremental linking; Incremental programming;
incremental programming; Integrated environment;
integrated environment; interpreter; programming
environments; Saber-C; Saber-C++; second-generation;
Second-generation tool; software packages; techniques;
tool",
thesaurus = "C language; Programming environments; Software
packages",
treatment = "P Practical; R Product Review",
}
@Article{Booch:1991:ODC,
author = "G. Booch and M. Vilot",
title = "Object-oriented {design-C++} class categories",
journal = j-C-PLUS-PLUS-REPORT,
volume = "3",
number = "7",
pages = "6--10",
month = jul # "-" # aug,
year = "1991",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Looks at the design issues involved in defining the
contents of class libraries. A library designer has to
make many design decisions and many C++ language
features can support these decisions. They describe
some design idioms, or styles of use, of C++ features
employed in building libraries. They discuss some kinds
of C++ classes and how they can be used in libraries or
applications. Note that none of these styles of class
design are directly enforced by the language; they are
merely design conventions. They give each of the kinds
of classes a name to encourage a consistent use of
terms among C++ library designers.",
acknowledgement = ack-nhfb,
classcodes = "C6110 (Systems analysis and programming)",
classification = "C6110 (Systems analysis and programming)",
keywords = "C language; C listings; C++ classes; C++ language; C++
language features; class design; Class design; Class
libraries; class libraries; features; object-oriented
design; Object-oriented design; object-oriented
programming",
thesaurus = "C language; C listings; Object-oriented programming",
treatment = "P Practical",
}
@Article{Eckel:1991:CIC,
author = "B. Eckel",
title = "Containers and iterators in {C++}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "3",
number = "7",
pages = "12--13",
month = jul # "-" # aug,
year = "1991",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The C++ language is all about creating and using
types. One of the important features of types in C++ is
the level of safety that can be built into them. The
author discusses two concepts in object-oriented
programming that allows one to take the raw forms shown
(the array and the index) and convert them into safe,
general-purpose abstractions for all types, not just
built-in types. These abstractions are called
containers and iterators and they will make code easier
to write and more robust.",
acknowledgement = ack-nhfb,
classcodes = "C6110 (Systems analysis and programming); C6140D (High
level languages)",
classification = "C6110 (Systems analysis and programming); C6140D
(High level languages)",
keywords = "Array; array; C language; C listings; C++ language;
Containers; containers; General-purpose abstractions;
general-purpose abstractions; Index; index; Iterators;
iterators; Object-oriented programming; object-oriented
programming; Types; types",
thesaurus = "C language; C listings; Object-oriented programming",
treatment = "P Practical",
}
@Article{Lane:1991:DCA,
author = "A. Lane",
title = "{DOS\slash C++} --- application frameworks",
journal = j-C-PLUS-PLUS-REPORT,
volume = "3",
number = "7",
pages = "14--15",
month = jul # "-" # aug,
year = "1991",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Application frameworks are object-oriented class
libraries that integrate user-interface building
blocks, fundamental data structures and support for
object-oriented input and output. Major components of
an application's interface, such as windows, pull-down
menus, dialog boxes, scroll bars and even a generic
application are modeled as classes in the hierarchy.
This gives programmers the ability to inherit a large
body of functional interface code and frees them to
concentrate on implementing specifics. The author looks
at a couple of simple examples from the forthcoming
Turbo Vision application framework.",
acknowledgement = ack-nhfb,
classcodes = "C6115 (Programming support); C6110 (Systems analysis
and programming)",
classification = "C6110 (Systems analysis and programming); C6115
(Programming support)",
keywords = "application frameworks; Application frameworks; C
language; C listings; data structures; Data structures;
dialog boxes; Dialog boxes; functional; Functional
interface code; interface code; object-oriented;
object-oriented class libraries; Object-oriented class
libraries; programming; pull-down menus; Pull-down
menus; scroll bars; Scroll bars; software tools; Turbo
Vision application framework; user interfaces;
user-interface building blocks; User-interface building
blocks; windows; Windows",
thesaurus = "C language; C listings; Data structures;
Object-oriented programming; Software tools; User
interfaces",
treatment = "P Practical",
}
@Article{Brazille:1991:OIL,
author = "R. Brazille and B. Leggett",
title = "The {Object Interface Library}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "3",
number = "7",
pages = "18--20, 22, 24",
month = jul # "-" # aug,
year = "1991",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "It is well know that object-oriented design can
profitably be applied to the creation of graphical user
interfaces. The author reviews the Object Interface
Library (OI), a collection of C++ classes for the X
Window System that offers C++ objects for common X
`widgets' such as scroll bars, drop-down menus, radio
buttons, icons, text entry fields, etc. The classes are
not related to the Xt widgets in any way, although they
do emulate some of the Intrinsics' mechanism to provide
better compatibility with other X tools. The most
interesting aspect of OI is that programs developed
with it are able to switch their look and feel between
OPEN LOOK and Motif at runtime.",
acknowledgement = ack-nhfb,
classcodes = "C6115 (Programming support); C6180 (User interfaces)",
classification = "C6115 (Programming support); C6180 (User
interfaces)",
keywords = "Application development; application development;
application generators; C language; C++ classes;
Drop-down menus; drop-down menus; graphical; Graphical
user interfaces; Icons; icons; Motif; Object Interface
Library; object-oriented; Object-oriented design;
object-oriented design; OI; OPEN LOOK; programming;
Radio buttons; radio buttons; Scroll bars; scroll bars;
software tools; Text entry fields; text entry fields;
user interfaces; Window System; X; X Window System",
thesaurus = "Application generators; C language; Object-oriented
programming; Software tools",
treatment = "P Practical; R Product Review",
}
@Article{Coplien:1991:ECC,
author = "J. Coplien",
title = "Experience with {CRC} cards in {AT\&T}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "3",
number = "8",
pages = "1, 4--6",
month = sep,
year = "1991",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The object paradigm is an increasingly popular way for
digital system developers to think about problem
solving. Experience has shown that the success of an
object-oriented design depends heavily on three
factors: designers' understanding of the technology,
creating a suitable project sociology and having people
with appropriate problem domain expertise. CRC cards
have been used in a number of AT and T software
projects and their use has played a role in each of
these factors. The author looks at each of these
factors in turn and the role CRC cards play to help
shape and enable an object-oriented development. A CRC
card is a 3*5 index card representing an application
abstraction. It lists the abstraction's class,
responsibilities, and collaborators. CRC cards are used
in interactive design sessions to flesh out the
identity and nature of classes when using
object-oriented analysis techniques. These cards are
filled in at meetings between key system architects,
designers, and customers. The cards become the
documentation for the initial project structure. The
cards may be transferred to a hypertext system for use
by the project at large to document system interfaces
and system functionality in general.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C0310F (Software
development management)",
classification = "C0310F (Software development management); C6110J
(Object-oriented programming)",
keywords = "Application abstraction; application abstraction; AT
and T software projects; AT\&T software;
Class-responsibility-collaboration;
class-responsibility-collaboration; CRC card;
Customers; customers; digital; Digital system
developers; Documentation; documentation; human
factors; Index card; index card; initial project;
Initial project structure; Interactive design sessions;
interactive design sessions; key; Key system
architects; Object paradigm; object paradigm;
Object-oriented design; object-oriented design;
Object-oriented development; object-oriented
development; object-oriented programming; personnel;
Problem domain expertise; problem domain expertise;
Problem solving; problem solving; project engineering;
Project sociology; project sociology; projects;
structure; system architects; system developers; system
documentation; System functionality; system
functionality; systems analysis",
thesaurus = "Human factors; Object-oriented programming; Personnel;
Project engineering; System documentation; Systems
analysis",
treatment = "A Application; P Practical",
}
@Article{Booch:1991:OAD,
author = "G. Booch and M. Vilot",
title = "Object-oriented analysis and design",
journal = j-C-PLUS-PLUS-REPORT,
volume = "3",
number = "8",
pages = "7--10",
month = sep,
year = "1991",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "There exist various kinds of classes useful for
implementing class libraries in C++, as described by B.
Straustrup (1991). These kinds of classes are purely a
design convention: nothing in the language enforces
their `correct' definition and use. However, settling
on a few standard styles can make a given library
clearer and more understandable. Having a common
vocabulary makes it easier to discuss library designs.
The authors look at another important vocabulary-the
vocabulary of the problem domain. They discuss the
difference between analysis and design and the role of
key abstractions and mechanisms in an object-oriented
design.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages)",
keywords = "abstractions; C language; C++; Class libraries; class
libraries; common; Common vocabulary; key; Key
abstractions; Library; library; Library designs;
library designs; Object-oriented design;
object-oriented design; object-oriented programming;
Problem domain; problem domain; reusability; software;
Standard styles; standard styles; vocabulary",
thesaurus = "C language; Object-oriented programming; Software
reusability",
treatment = "P Practical",
}
@Article{Cargill:1991:CCO,
author = "T. Cargill",
title = "{CRC} cards ({OO} programming)",
journal = j-C-PLUS-PLUS-REPORT,
volume = "3",
number = "8",
pages = "11--13",
month = sep,
year = "1991",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Many newcomers to object-oriented programming have
difficulty `finding the objects', that is, finding
appropriate abstractions and capturing them as classes.
A low-tech, paper-and-pencil analysis and design
technique, known as `CRC cards', can help in the search
for the right classes. K. Beck, W. Cunningham (1989)
created CRC cards as a device for teaching
object-oriented programming and R. Wirfs-Brock et al.
(1990), have incorporated the cards into their
`responsibility-driven' design methodology. CRC stands
for class, responsibility, collaboration. The technique
focuses on identifying classes, assigning
responsibilities to classes and recording
collaborations between classes. Responsibilities are
the services that a class provides, as a server, to the
rest of a system. Collaboration is the interaction
between a client and a server-a client collaborates
with a server to obtain services. CRC cards encourage
simultaneous searches for individual classes and
interactions between classes.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C0310F (Software
development management); C6120 (File organisation)",
classification = "C0310F (Software development management); C6110J
(Object-oriented programming); C6120 (File
organisation)",
keywords = "analysis; Class; class;
Class-responsibility-collaboration;
class-responsibility-collaboration; Client; client;
Collaboration; collaboration; CRC cards; data
structures; Design methodology; design methodology;
human factors; object-oriented programming;
paper-and-pencil; Paper-and-pencil analysis;
Responsibility-driven; responsibility-driven; Server;
server; Simultaneous searches; simultaneous searches;
systems analysis; Teaching object-oriented programming;
teaching object-oriented programming",
thesaurus = "Data structures; Human factors; Object-oriented
programming; Systems analysis",
treatment = "P Practical",
}
@Article{Booch:1991:ODP,
author = "G. Booch and M. Vilot",
title = "The object-oriented development process",
journal = j-C-PLUS-PLUS-REPORT,
volume = "3",
number = "9",
pages = "8--11",
month = oct,
year = "1991",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Considers an important aspect of getting organized and
started on a project using the object-oriented
development approach, discussing part of the software
development process model. With an appropriate choice
of tangible design artifacts and review points, we can
represent the incremental and iterative OOD process in
linear form. The authors examine some of the software
project management aspects of object-oriented design.
They discuss some tangible design artifacts and review
points we can use to make the design process more
visible from a project planning perspective. They find
this helps fit a round-trip gestalt design approach
into management systems accustomed to a more linear
perspective.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C0310F (Software
development management)",
classification = "C0310F (Software development management); C6110J
(Object-oriented programming)",
keywords = "analysis; Gestalt design approach; gestalt design
approach; Linear form; linear form; Management systems;
management systems; model; object-; Object-oriented
design; Object-oriented development; object-oriented
development; object-oriented programming; OOD; oriented
design; software development process; Software
development process model; software engineering;
Software project management; software project
management; systems",
thesaurus = "Object-oriented programming; Software engineering;
Systems analysis",
treatment = "P Practical",
}
@Article{Huneke:1991:LCC,
author = "I. Huneke",
title = "Linking {C} with {C++}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "3",
number = "9",
pages = "12, 16",
month = oct,
year = "1991",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "When developing applications in C++, the need
sometimes arises to call C++ functions from sections of
C code. This article suggests a method for providing
such linkage. The basic facility has been tried out
with Release 2.1 of cfront and with Zortech C++, so it
should be portable across all compilers.",
acknowledgement = ack-nhfb,
classcodes = "C6110 (Systems analysis and programming)",
classification = "C6110 (Systems analysis and programming)",
keywords = "C code; C language; C listings; C++; Cfront Release
2.1, software portability; cfront Release 2.1, software
portability; Compilers; compilers; object-oriented;
Object-oriented programming; object-oriented
programming; programming; software portability; Zortech
C++",
thesaurus = "C language; C listings; Object-oriented programming;
Software portability",
treatment = "P Practical",
}
@Article{VanWyk:1991:SEY,
author = "C. J. {Van Wyk}",
title = "Simultaneous equations are your friends",
journal = j-C-PLUS-PLUS-REPORT,
volume = "3",
number = "9",
pages = "14--16",
month = oct,
year = "1991",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Discusses how one can build a class library that
allows C++ programmers to express simultaneous
equations directly in their code. The author considers
nonlinear equations and complex numbers.",
acknowledgement = ack-nhfb,
classcodes = "C6110 (Systems analysis and programming); C7310
(Mathematics)",
classification = "C6110 (Systems analysis and programming); C7310
(Mathematics)",
keywords = "C language; C listings; C++; Class library; class
library; complex numbers; Complex numbers; equations;
mathematics computing; nonlinear; Nonlinear equations;
simultaneous equations; Simultaneous equations",
thesaurus = "C language; C listings; Equations; Mathematics
computing",
treatment = "P Practical",
}
@Article{Coggins:1991:NCC,
author = "J. M. Coggins",
title = "Naming conventions in {C++} libraries",
journal = j-C-PLUS-PLUS-REPORT,
volume = "3",
number = "9",
pages = "17--21",
month = oct,
year = "1991",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Follows a few threads of a long conservation about
naming conventions for C++, especially conventions that
could become part of any standard libraries
accompanying an ANSI/ISO standard C++ language. The
author's suggestions is that, in spite of being almost
impossible to agree on, naming conventions need to be
agreed upon in order to have standardized software and
that the exact names chosen for standard libraries and
classes are important to their reusability.",
acknowledgement = ack-nhfb,
classcodes = "C6110 (Systems analysis and programming)",
classification = "C6110 (Systems analysis and programming)",
keywords = "ANSI/ISO standard; ANSI/ISO standard C++ language; C
language; C listings; C++ language; Naming conventions;
naming conventions; Software reusability; software
reusability; Standardized software; standardized
software",
thesaurus = "C language; C listings; Software reusability",
treatment = "P Practical",
}
@Article{LeJacq:1991:ECY,
author = "J. P. LeJacq",
title = "Education can you do better than {C++}?",
journal = j-C-PLUS-PLUS-REPORT,
volume = "3",
number = "10",
pages = "1, 4--6",
month = nov # "-" # dec,
year = "1991",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Once an organization has made the decision to migrate
to C++, the obvious question arises of how to get from
here to there. The answer entails decisions regarding
languages, compilers, libraries and organization
changes. Certainly one of the most significant factors
is educating the current development team in
object-oriented technology. This article summarizes the
author's experience teaching general object-oriented
design courses and C++-specific courses in industrial
settings. He presents what seems to be an effective
approach and flags some potential problems.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C0220 (Education
and training)",
classification = "C0220 (Education and training); C6110J
(Object-oriented programming)",
keywords = "C language; C++; Compilers; compilers; computer
science education; Libraries; libraries;
object-oriented; Object-oriented design courses;
object-oriented design courses; Object-oriented
technology; object-oriented technology; programming;
Teaching; teaching; training",
thesaurus = "C language; Computer science education;
Object-oriented programming; Training",
treatment = "P Practical",
}
@Article{Booch:1991:ODD,
author = "G. Booch and M. Vilot",
title = "Object-oriented design documents",
journal = j-C-PLUS-PLUS-REPORT,
volume = "3",
number = "10",
pages = "8, 10--12",
month = nov # "-" # dec,
year = "1991",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Describes a possible documentation structure for a
project using object-oriented design. These documents
can be used to make the structure and status of the
development process more visible to the project team.
Of course, each project will have its own
considerations for recording design descriptions.
Project team and size and tolerance for documentation
are particularly influential when structuring design
documents.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming)",
classification = "C6110J (Object-oriented programming)",
keywords = "analysis; Documentation structure; documentation
structure; Object-oriented design documents;
object-oriented design documents; object-oriented
programming; process; Project team size; project team
size; software development; Software development
process; software engineering; systems",
thesaurus = "Object-oriented programming; Software engineering;
Systems analysis",
treatment = "P Practical",
}
@Article{Saks:1991:ACU,
author = "D. Saks",
title = "{ANSI C++} update: works in progress",
journal = j-C-PLUS-PLUS-REPORT,
volume = "3",
number = "10",
pages = "13--14, 16",
month = nov # "-" # dec,
year = "1991",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The ANSI C++ Standards Committee X3J16 meets only
three times a year. Much of the Committee's work is
done between these meetings by small working groups
that clarify and evaluate issues and make proposals for
action by the entire committee. The active working
groups are C Compatibility, Core Language,
Environments, Extensions, Libraries, and Syntax. The
author discusses the work of these groups.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming)",
classification = "C6110J (Object-oriented programming)",
keywords = "ANSI; ANSI C++ Standards Committee; C Compatibility; C
environments; C extensions; C language; C libraries; C
syntax; C++ Standards Committee; Core Language;
object-oriented programming; standards",
thesaurus = "C language; Object-oriented programming; Standards",
treatment = "P Practical",
}
@Article{Horstmann:1991:ILB,
author = "C. Horstmann",
title = "An in-depth look as {Borland C++}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "3",
number = "10",
pages = "17--20",
month = nov # "-" # dec,
year = "1991",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The Borland C++ compiler is a product with many
components and features. The author looks at some of
the more interesting ones in greater detail. He
considers the support for 80*86 modes, compiler quirks,
the debugger, precompiled headers, VROOM overlay link
technique, online help and documentation, amongst other
features.",
acknowledgement = ack-nhfb,
classcodes = "C6150C (Compilers, interpreters and other processors);
C6110J (Object-oriented programming)",
classification = "C6110J (Object-oriented programming); C6150C
(Compilers, interpreters and other processors)",
keywords = "80*86 Modes; 80*86 modes; Borland C++ compiler; C
language; Debugger; debugger; Documentation;
documentation; headers; object-oriented programming;
Online help; online help; Overlay link technique;
overlay link technique; precompiled; Precompiled
headers; program compilers; program debugging; software
packages",
thesaurus = "C language; Object-oriented programming; Program
compilers; Program debugging; Software packages",
treatment = "P Practical; R Product Review",
}
@Article{Coggins:1991:BCA,
author = "J. M. Coggins",
title = "Best of {\path|comp.lang.C++|} --- much ado about
null",
journal = j-C-PLUS-PLUS-REPORT,
volume = "3",
number = "10",
pages = "21--24",
month = nov # "-" # dec,
year = "1991",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Examines the different ways to represent Nothing in
C++. This is worthy of discussion because the
representation of Nothing must have a type. This
question eventually reaches into areas such as
automatic type conversion rules interactions of
preprocessor symbols with the type system,
compatibility problems among C++ implementations,
standardization concerns, and the interaction of
classes with basic types.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming)",
classification = "C6110J (Object-oriented programming)",
keywords = "Automatic type conversion rules; automatic type
conversion rules; C language; C listings; C++;
object-oriented programming; Standardization;
standardization",
thesaurus = "C language; C listings; Object-oriented programming",
treatment = "P Practical",
}
@Article{Soukup:1992:SCL,
author = "J. Soukup",
title = "Selecting a {C++} library",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "1",
pages = "1, 4--6",
month = jan,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "There is a major difference in both the construction
and use of libraries in C and C++. Unless special tools
are available, it is difficult to code a general
library in C for structures such as linked lists,
trees, graphs, or hash tables. However, in C++, whole
organizations can be treated as objects, which helps in
library design and simplifies its use. The availability
of such a library speeds up development, improves code
quality, and greatly enhances the maintainability of
the software. This paper concentrates mainly on
general-purpose libraries that manage basic data
structures such as linked lists, trees, graphs, or
entity-relationship models. These organizations
typically combine several different object types
connected by pointers. It lists the good and bad things
for which one has to watch when selecting a library. It
also suggests a benchmark that measures both ease of
use and library performance.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C0310H
(Equipment and software evaluation methods)",
classification = "C0310H (Equipment and software evaluation methods);
C6110J (Object-oriented programming)",
keywords = "Benchmark; benchmark; C language; C++; C++ library;
Code quality; code quality; Data structures; data
structures; Entity-relationship models;
entity-relationship models; Graphs; graphs; library;
Linked lists; linked lists; maintenance; Object types;
object types; Object-oriented programming;
object-oriented programming; Pointers; pointers;
software; Software maintenance; software maintenance;
software selection; Trees; trees",
thesaurus = "C language; Object-oriented programming; Software
maintenance; Software selection",
treatment = "P Practical",
}
@Article{Booch:1992:ODP,
author = "G. Booch and M. Vilot",
title = "Object-oriented design: physical design: storage
management",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "1",
pages = "7--10",
month = jan,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Considers the design of storage management for the
objects in designs. In OOD, the authors separate the
logical view of the classes and objects in the design
from the physical view of how they are packaged and
allocated. C++ allows us to precisely control the
storage management details when necessary. They
concentrate on one facet of physical design. Storage
management is an issue that faces most C++ developers.
One can use the features of C++ to provide convenient
access to the necessary details.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming)",
classification = "C6110J (Object-oriented programming)",
keywords = "C++; Classes; classes; management; Object-oriented
design; object-oriented design; Object-oriented
programming; object-oriented programming; Objects;
objects; storage; Storage management; systems
analysis",
thesaurus = "Object-oriented programming; Systems analysis",
treatment = "P Practical",
}
@Article{Saks:1992:ACU,
author = "D. Saks",
title = "{ANSI C++} update: works in progress",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "1",
pages = "11--14",
month = jan,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The ANSI C++ standards committee, X3J16, held its
sixth meeting in Lund, Sweden during June 1991. By
careful prior arrangement, the meeting coincided with
the first meeting for the ISO C++ working group, WG21.
The committees met both separately and in joint
session. Although much of the meeting time was spent
deciding how it would be best for the committees to
work together, there was still time for productive
technical discussion and a few significant decisions.
The author discusses the development of an
international standard and European representation for
C++.",
acknowledgement = ack-nhfb,
classcodes = "C6140D (High level languages)",
classification = "C6140D (High level languages)",
keywords = "ANSI C++ standards committee; C language; C listings;
ISO C++ working group; standards",
thesaurus = "C language; C listings; Standards",
treatment = "P Practical",
}
@Article{Horstmann:1992:OCL,
author = "C. Horstmann",
title = "The object-based class library in {Borland C++}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "1",
pages = "15--18",
month = jan,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Borland C++ Version 3.0 includes two class libraries,
principally implementing containers. The first one, the
so-called object-based library, is discussed. It has
been supplied with Borland C++ Version 2.0 and slightly
enhanced in the newest release. The second library is
new to Borland C++ 3.0 and is template based. Both
libraries are included in the professional version of
the compiler. All objects in the object-based library
are derived from an abstract base class Object. The
containers are heterogeneous and can hold any
collection of instances of classes derived from Object.
This setup is commonly known as the Smalltalk approach
and is used in many C++ class libraries. To test how
easy it is to use the library, the author modified a
project from a C++ training course: a simulation of
customers entering a bank and being serviced by an
array of tellers. This simulation program has a queue
holding customers, an array holding tellers, and a
priority queue holding events sorted by a time stamp.
Thus, there are naturally three containers in this
program.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming)",
classification = "C6110J (Object-oriented programming)",
keywords = "Abstract base class; abstract base class; approach;
Array; array; Borland C++ Version 3.0; C language; C
listings; Compiler; compiler; Containers; containers;
Events; events; Object-based class library;
object-based class library; object-oriented
programming; Priority queue; priority queue; Queue;
queue; Simulation; simulation; Smalltalk; Smalltalk
approach; Sorted; sorted; Time stamp; time stamp",
thesaurus = "C language; C listings; Object-oriented programming",
treatment = "P Practical",
}
@Article{Coggins:1992:HFC,
author = "J. M. Coggins",
title = "Handling failed constructors gracefully",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "1",
pages = "20--22",
month = jan,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "A constructor is a member function that is invoked
when an object is created. Its objective is to
initialize the new object to a valid state before any
processing occurs using the object. Some very useful
classes involve creating linkages with the external
environment-files, network connections, user
interfaces, processing accelerators-and the
construction of the object depends on certain states or
properties existing in that external environment. For
example, when we create a file object for reading, we
require the file name to exist. The author discusses
what happens if something goes wrong during
construction C++.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages)",
keywords = "C language; C listings; C++; Classes; classes;
Constructor; constructor; File name; file name; File
object; file object; Object; object; Object-oriented
programming; object-oriented programming",
thesaurus = "C language; C listings; Object-oriented programming",
treatment = "P Practical",
}
@Article{McCluskey:1992:ETI,
author = "G. McCluskey",
title = "An environment for template instantiation",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "2",
pages = "1, 4--7",
month = feb,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The parametrized type or template feature has been
part of C++ for several years. Implementations of the
feature have started to appear in C++ compilers. An
interesting issue is how to handle what is known as
instantiation, the combining of a template with
arguments. The author reviews template basics, briefly
presents existing methods of instantiation, and then
describes the approach taken by one implementation (the
UNIX Systems Laboratories 3.0 compiler) to solve the
instantiation problem. What is described is an
environment for C++ compilation rather than part of the
language itself. Environment implementations are not
subject to standardization the way the language is and,
therefore, vendors are free to make different
implementation choices.",
acknowledgement = ack-nhfb,
classcodes = "C6140D (High level languages); C6150C (Compilers,
interpreters and other processors); C6120 (File
organisation)",
classification = "C6120 (File organisation); C6140D (High level
languages); C6150C (Compilers, interpreters and other
processors)",
keywords = "C language; C++ compilation; C++ compilers; data
structures; Parametrized type; parametrized type;
program compilers; Template feature; template feature;
Template instantiation; template instantiation; UNIX
Systems Laboratories; Vendors; vendors",
thesaurus = "C language; Data structures; Program compilers",
treatment = "P Practical",
}
@Article{Booch:1992:PDS,
author = "G. Booch and M. Vilot",
title = "Physical design: storage and management libraries
({OOP})",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "2",
pages = "8--10",
month = feb,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "An examination is given of C++ storage management
design issues. The authors examine some common designs
for optimizing storage management performance and how
the variety of storage options influences the design of
class libraries. Library design is an interesting case.
The design of storage management in a library must
operate efficiently in the face of unpredictable usage
patterns and a variety of usage contexts. As B.
Stroustrup (1991) observes, `Designing a general
library is much harder than designing an ordinary
program. A program is a solution to a particular
problem in a particular context, but a library must be
the solution to a set of problems encountered in a
number of projects. An ordinary program can make strong
assumptions about its environment, but a good library
has to operate successfully in the contexts provided by
a number of programs'.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages); C6120 (File organisation)",
classification = "C6110J (Object-oriented programming); C6120 (File
organisation); C6140D (High level languages)",
keywords = "C language; C++ storage management design issues;
Class libraries; class libraries; general; General
library; library; management performance;
object-oriented programming; OOP; storage; storage
management; Storage management performance; Storage
options; storage options; subroutines; Unpredictable
usage patterns; unpredictable usage patterns; Usage
contexts; usage contexts",
thesaurus = "C language; Object-oriented programming; Storage
management; Subroutines",
treatment = "P Practical",
}
@Article{Soukup:1992:MD,
author = "J. Soukup",
title = "Memory-resident databases",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "2",
pages = "11--15",
month = feb,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "A discussion is given on the use of memory-resident
databases developed in object-oriented C++. The method
was originally used by CAD designers for VLSI data. The
main concept is the use of memory-resident data which
is treated as a database. Two examples are given to
demonstrate the method: connectivity record for an
electric circuit and music collection catalogue. The
author explains how to implement such a database and
presents benchmarks to show performance.",
acknowledgement = ack-nhfb,
classcodes = "C6160 (Database management systems (DBMS)); C6140D
(High level languages); C6120 (File organisation);
C7410D (Electronic engineering); C7820 (Humanities)",
classification = "C6120 (File organisation); C6140D (High level
languages); C6160 (Database management systems (DBMS));
C7410D (Electronic engineering); C7820 (Humanities)",
keywords = "Benchmarks; benchmarks; C language; CAD; CAD
designers; circuit CAD; connectivity; Connectivity
record; database management systems; designers;
Electric circuit; electric circuit; Memory-resident
data; memory-resident data; Memory-resident databases;
memory-resident databases; music; Music collection
catalogue; music collection catalogue; Object-oriented
C++; object-oriented C++; record; storage management;
VLSI data",
thesaurus = "C language; Circuit CAD; Database management systems;
Music; Storage management",
treatment = "P Practical",
}
@Article{Skelly:1992:GHN,
author = "C. Skelly",
title = "Getting a handle on the new-handler",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "2",
pages = "16--18",
month = feb,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "A problem in moving from a C development environment
to a C++ environment is that C++ constructors don't
return anything. How can we know whether a constructor
has succeeded or failed if constructors never return an
indicating value? Is there a way to determine if the
memory allocation has occurred successfully despite the
silence of tight-lipped C++ constructors? In fact, such
a method does exist. It is built into the language to
handle just such an exigency. A predefined function
pointer, called the -new-handler, can be set by users
to point to a user-defined routine, which will be
executed if ever the new operator should have the
temerity or ill fortune to fail. This user-defined
routine can perform any action it pleases, including
setting an error flag, attempting to recover memory,
exiting, aborting, or, in state-of-the-art C++
environments, throwing an exception. In fact, the
-new-handler is a built-in exception handler packaged
for ease of use.",
acknowledgement = ack-nhfb,
classcodes = "C6140D (High level languages); C6110J (Object-oriented
programming); C6120 (File organisation); C6150J
(Operating systems)",
classification = "C6110J (Object-oriented programming); C6120 (File
organisation); C6140D (High level languages); C6150J
(Operating systems)",
keywords = "C development environment; C language; C++; C++
constructors; C++ environment; constructors; data
structures; Error flag; error flag; Exception;
exception; Exception handler; exception handler; Memory
allocation; memory allocation; object-oriented
programming; pointer; predefined function; Predefined
function pointer; storage allocation; User-defined
routine; user-defined routine",
thesaurus = "C language; Data structures; Object-oriented
programming; Storage allocation",
treatment = "P Practical",
}
@Article{Coggins:1992:AQA,
author = "J. M. Coggins",
title = "An array of questions about arrays",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "2",
pages = "19--22",
month = feb,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Arrays of objects in C++ raise important issues for
language designers and users alike. The issues include
how to initialize the array elements, how to ensure
that the array is properly deallocated, how to return
an array as the result of a function, how to pass
arrays as arguments without copying the array, how to
make sure that an array passed as an argument will not
be changed by the called procedure, how to define
operator=() for a class containing an array, and so on.
Several of these issues have arisen in net
conversation, and a few of them are summarized.",
acknowledgement = ack-nhfb,
affiliation = "Dept. of Comput. Sci., North Carolina Univ., Chapel
Hill, NC, USA",
classcodes = "C6140D (High level languages); C6110J (Object-oriented
programming); C6120 (File organisation)",
classification = "C6110J (Object-oriented programming); C6120 (File
organisation); C6140D (High level languages)",
corpsource = "Dept. of Comput. Sci., North Carolina Univ., Chapel
Hill, NC, USA",
keywords = "Arguments; arguments; Array elements; array elements;
C language; data structures; Deallocated; deallocated;
Function; function; Language designers; language
designers; object-oriented programming; Users; users",
thesaurus = "C language; Data structures; Object-oriented
programming",
treatment = "P Practical",
}
@Article{Hamsath:1992:ZCD,
author = "N. Hamsath",
title = "{Zortech C++ Developers Edition}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "2",
pages = "23--25",
month = feb,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The Developers Edition of Zortech's product, as
reviewed, is an upgrade of the first PC-based AT and T
V2.0 compliant C++ compiler. It requires an IBM PC, XT,
AT, 3/486, or compatible computer, MS-DOS/PC-DOS v3.0
or above, and at least 640 Kb of RAM. As installed, the
total size of the eight-disk DOS version with all
options is about 18 Mb. The disks are in archive form
and can be installed as a unit or installed separately,
as needed. Also, the disks can be read in any order.
Although it does not take long to reload files (if
necessary after the first installation) from the disk,
it is still a chore. Zortech C++V3.0el (ztc) is a C++
and a C compiler (source-level compatible with
Microsoft) with a completely integrated development
environment that supports almost any monitor.",
acknowledgement = ack-nhfb,
affiliation = "Nat. Inst. of Health, Bethesda, MD, USA",
classcodes = "C6150C (Compilers, interpreters and other processors);
C6140D (High level languages)",
classification = "C6140D (High level languages); C6150C (Compilers,
interpreters and other processors)",
corpsource = "Nat. Inst. of Health, Bethesda, MD, USA",
keywords = "640 Kbytes; C compiler; C language; C++ compiler;
Developers Edition; DOS/PC-DOS; IBM computers; IBM PC;
Integrated development environment; integrated
development environment; microcomputer applications;
Microsoft; MS-; MS-DOS/PC-DOS; PC-based AT and T;
PC-based AT\&T; program compilers; software packages;
Source-level compatible; source-level compatible",
numericalindex = "Memory size 6.6E+05 Byte",
thesaurus = "C language; IBM computers; Microcomputer applications;
Program compilers; Software packages",
treatment = "P Practical; R Product Review",
}
@Article{Stroustrup:1992:RTI,
author = "B. Stroustrup and D. Lenkov",
title = "Runtime type identification for {C++}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "3",
pages = "32--42",
month = mar # "-" # apr,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "A proposal is described for a mechanism for runtime
type identification and checked type casts, which is
simple to use, easy to implement, and extensible. This
proposal evolved through a series of earlier proposals
and ideas, and experimental implementations exist.
However this proposal and the features described may
never be accepted into C++.",
acknowledgement = ack-nhfb,
classcodes = "C6140D (High level languages); C6120 (File
organisation)",
classification = "C6120 (File organisation); C6140D (High level
languages)",
keywords = "C language; C++; Checked type casts; checked type
casts; data structures; Experimental implementations;
experimental implementations; Runtime type
identification; runtime type identification",
thesaurus = "C language; Data structures",
treatment = "P Practical",
}
@Article{Dewhurst:1992:DAI,
author = "S. C. Dewhurst",
title = "Distributed abstract interfaces",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "3",
pages = "44--50",
month = mar # "-" # apr,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "In C++, an abstract data type (ADT) and its class
implementation are often viewed as equivalent. This is
a useful simplification for many ADTs in those cases
where the abstract operations of the type can be
represented cleanly in the public (or public and
protected) regions of a single class declaration.
However, not all ADTs are so simple. The author shows
why it is often convenient to distribute the abstract
interface of an ADT among a set of C++ classes. The
usual one-to-one mapping of ADT to class can be viewed
as a degenerate form of this more general case. The
discussion is motivated largely by the problems
associated with performing (abstract) traversals of
ADTs that have (abstract) structure. An extended
discussion of the techniques of control abstraction is
given.",
acknowledgement = ack-nhfb,
classcodes = "C6140D (High level languages); C6110J (Object-oriented
programming); C6120 (File organisation)",
classification = "C6110J (Object-oriented programming); C6120 (File
organisation); C6140D (High level languages)",
keywords = "Abstract data type; abstract data type; Abstract
operations; abstract operations; abstraction; ADT; C
language; C++ classes; class; Class implementation;
control; Control abstraction; data structures;
declaration; Distributed abstract interfaces;
distributed abstract interfaces; implementation;
object-oriented programming; One-to-one mapping;
one-to-one mapping; single class; Single class
declaration",
thesaurus = "C language; Data structures; Object-oriented
programming",
treatment = "P Practical",
}
@Article{Musser:1992:ESC,
author = "J. Musser",
title = "Extending streambufs: class logstrbuf ({OOP})",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "3",
pages = "51--55",
month = mar # "-" # apr,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "It is often desirable to encapsulate a set of existing
operating system services in an object-oriented fashion
to streamline their use within an application. C++
provides the necessary tools for developers, including
those not involved in creating operating systems, to
encapsulate and possibly extend a variety of operating
system services. A solid foundation for many such
services is provided by the iostream library. The
author describes the design of the logstrbuf class,
which was developed to encapsulate the Berkeley Unix
syslog facility. This class is derived from streambuf,
the underlying buffering layer of the iostreams
library. The techniques used can similarly be applied
to other I/O and IPC operations, including sockets,
shared memory, window system IPC and the like. This
example shows how the streambuf class can be used to
achieve powerful results when applied to specific
problem domains.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages); C6120 (File organisation); C6150J
(Operating systems)",
classification = "C6110J (Object-oriented programming); C6120 (File
organisation); C6140D (High level languages); C6150J
(Operating systems)",
keywords = "Berkeley Unix syslog; Berkeley Unix syslog facility; C
language; C++; data structures; facility; I/O;
input-output programs; Iostream library; iostream
library; IPC; IPC operations; Logstrbuf class;
logstrbuf class; object-; Object-oriented fashion;
object-oriented fashion; Operating system services;
operating system services; operations; oriented
programming; Shared memory; shared memory; Sockets;
sockets; Streambuf; streambuf; Underlying buffering
layer; underlying buffering layer; Window system IPC;
window system IPC",
thesaurus = "C language; Data structures; Input-output programs;
Object-oriented programming",
treatment = "P Practical",
}
@Article{Buroff:1992:CO,
author = "S. Buroff and R. Murray",
title = "The {C++} Oracle",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "4",
pages = "9--10",
month = may,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The authors are concerned with the following
questions: If they use a template class and only call
for a few of its member functions, are all member
functions instantiated or only those they call? The
first thing to understand about this question is that
its answer is not part of the definition of C++.
Instead, this is left as a quality of implementation
issue. A C++ compiler is free to instantiate all member
functions or only those referenced without being in
violation of the standard. They term the instantiation
of only the referenced member functions selective
instantiation.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages)",
keywords = "C language; C listings; C++; Compiler; compiler;
functions; member; Member functions; Object-oriented
programming; object-oriented programming; Selective
instantiation; selective instantiation; Template class;
template class",
thesaurus = "C language; C listings; Object-oriented programming",
treatment = "P Practical",
}
@Article{Eckel:1992:VC,
author = "B. Eckel",
title = "Virtual constructors. 2",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "4",
pages = "13--16",
month = may,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "For pt.1, see ibid., vol.4, no.3, p.13-18 (1992). This
paper concludes the presentation of the concept of
virtual constructors. It talks about destructors and
virtual destructor operation when using virtual
constructors and then goes on to discuss code
formatting.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages)",
keywords = "C language; C listings; C++ language; Code formatting;
code formatting; constructors; Destructors;
destructors; Object-oriented programming;
object-oriented programming; virtual; Virtual
constructors; Virtual destructor operation; virtual
destructor operation",
thesaurus = "C language; C listings; Object-oriented programming",
treatment = "P Practical",
}
@Article{Booch:1992:LDS,
author = "G. Booch and M. Vilot",
title = "Logical design: software component libraries",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "4",
pages = "18, 20--22",
month = may,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Considers some of the issues in designing a library of
reusable software components. Such libraries can be
used to help improve productivity in software
development by providing prefabricated, pretested
parts. One can build applications by assembling and
customizing these elements, rather than redeveloping
them for each application. When one models the key
abstractions of a problem domain, the resulting classes
tend to be reusable across the set of applications
built for that domain. One could organize these classes
into a library of reusable components. Existing C++
libraries each focus on specific domains.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6110B (Software
engineering techniques)",
classification = "C6110B (Software engineering techniques); C6110J
(Object-oriented programming)",
keywords = "C language; C++; Key abstractions; key abstractions;
Object-oriented design; object-oriented design;
object-oriented programming; reusability; Reusable
software; reusable software; software; Software
component libraries; software component libraries;
Software development; software development",
thesaurus = "C language; Object-oriented programming; Software
reusability",
treatment = "P Practical",
}
@Article{Skelly:1992:LO,
author = "C. Skelly",
title = "In the land of {OOP}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "4",
pages = "23--26",
month = may,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The author begins an ongoing adventure into some of
the wilder forest regions, along some of the lesser
known paths, that run through the land of
object-oriented programming and C++. He imagines a
generic situation in which a datastream, composed of
packets of information, is being received by a
processing component of some sort. One option for
handling such a stream in C++ is to instantiate a
`handling object' for every data packet received.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming)",
classification = "C6110J (Object-oriented programming)",
keywords = "C language; C++; Data packet; data packet;
Object-oriented programming; object-oriented
programming",
thesaurus = "C language; Object-oriented programming",
treatment = "P Practical",
}
@Article{Soukup:1992:BTC,
author = "J. Soukup",
title = "Beyond templates. 1. ({C++})",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "4",
pages = "27--31",
month = may,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The good news is that C++ compilers are beginning to
support templates. The bad news is that templates do
not do what they were invented for very well. The main
purpose of templates is to provide a mechanism for
building general data structures such as linked lists,
trees, and graphs without giving up the protection of
full static typing. Data structures involve pointer
relations between different types of objects and are,
in the realm of object-oriented programming, often
referred to as associations and aggregations. The
author looks at the following approaches to building
data structures: templates and indirect links;
templates combined with multiple inheritance; templates
inheritance, and a code generator; and class generator
only. He particularly covers the first approach in this
issue. He stretches the use of templates to its limits
and uses new ideas and nonstandard approaches.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6150C
(Compilers, interpreters and other processors)",
classification = "C6110J (Object-oriented programming); C6150C
(Compilers, interpreters and other processors)",
keywords = "Aggregations; aggregations; Associations;
associations; C language; C++ compilers; Class
generator; class generator; Code generator; code
generator; Data structures; data structures; Full
static typing; full static typing; Graphs; graphs;
indirect; Indirect links; Inheritance; inheritance;
Linked lists; linked lists; links; object-;
Object-oriented programming; object-oriented
programming; oriented programming; Pointer relations;
pointer relations; program compilers; Templates;
templates; Trees; trees",
thesaurus = "C language; Data structures; Object-oriented
programming; Program compilers",
treatment = "P Practical",
}
@Article{Horstmann:1992:MCC,
author = "G. Horstmann",
title = "The {Microsoft C\slash C++ Version 7} compiler: {A}
first impression",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "4",
pages = "53--57",
month = may,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The author discusses the Microsoft C/C++ Version 7
compiler. In terms of sales, Borland is clearly the
biggest player in this market. The Microsoft press kit
contains a large number of feature comparisons with
Borland, without mentioning any other vendors at all.
He discusses some of the Microsoft sales arguments, as
well as some other comparisons that the Microsoft
marketing staff wisely omitted from the press kit.",
acknowledgement = ack-nhfb,
classcodes = "C6150C (Compilers, interpreters and other
processors)",
classification = "C6150C (Compilers, interpreters and other
processors)",
keywords = "Borland; C language; Compiler; compiler; Marketing;
marketing; Microsoft C/C++ Version 7; program
compilers",
thesaurus = "C language; Program compilers",
treatment = "P Practical; R Product Review",
}
@Article{Coggins:1992:QCW,
author = "J. M. Coggins",
title = "Questioning conventional `wisdom' about {C++} code
size and execution speed",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "4",
pages = "58--61",
month = may,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Object-oriented design and programming affect how
people think about computer programming and how people
think through computer programming problems.
Eventually, however, it is necessary to get down to
pragmatic concerns such as lines of code and speed of
program development and execution. This column surveys
a few of the more enlightening network postings
concerned with evaluations of the pragmatics of C++.
Such evaluations cannot be conducted effectively
without care for definitions of terms and experimental
controls that is rarely exercised in informal
conversations on the network. First, it considers the
pragmatic concern of source program length.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages)",
keywords = "C language; C++; C++ code size; code size; Execution
speed; execution speed; Object-oriented design;
object-oriented design; Object-oriented programming;
object-oriented programming; Program development;
program development",
thesaurus = "C language; Object-oriented programming",
treatment = "P Practical",
}
@Article{Wilkinson:1992:SCO,
author = "N. M. Wilkinson",
title = "Subtleties of {C++} operator overloading",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "5",
pages = "36--41",
month = jun,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "In C++, a programmer uses the class construct to
create data types that mimic, to a great extent, the
look and behavior of built-in types. As with a built-in
type, the representation of the class can be hidden
from the user and accessed only through operations
defined on the type. Also, the construction and
destruction of objects of the user-defined data type
are handled automatically. Conversions, which are often
invisibly applied, can be defined by the class to and
from other types. Additionally, the C++ class author
may define functions for the class that represent
operators to be applied to that type. Many C++ users
think that these forms are equivalent, but they are
not. And the subtlety of the difference can take an
unsuspecting programmer by surprise. This article
examines a number of the subtle points in declaring and
using overloaded operators in C++. These points will
also illustrate exactly what the compiler will do, and
will not do, to resolve an operator expression.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages); C6150C (Compilers, interpreters and
other processors)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages); C6150C (Compilers, interpreters and
other processors)",
keywords = "built-in; Built-in types; C language; C++; Compiler;
compiler; Data types; data types; Object-oriented
programming; object-oriented programming; Overloaded
operators; overloaded operators; program compilers;
types",
thesaurus = "C language; Object-oriented programming; Program
compilers",
treatment = "P Practical",
}
@Article{Strickland:1992:ODD,
author = "H. Strickland",
title = "Object databases: a deep look at transparency",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "5",
pages = "42--46",
month = jun,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "When some people speak of transparency, they mean
`surface transparency', or `automaticness'. Surface
transparency measures how well something automatically
happens when compiled, unaltered, by a certain product,
or how much you have to do to make something
automatically happen. As a start, surface transparency
is a good measure and a respectable goal, and it may
help to get a demo running in a weekend. For a serious
software development project, deeper measures of
transparency are far more important. This article will
point out some of the issues that need to be addressed
in evaluating `deep transparency'. It presents some
sample interfaces to discuss transparency with
examples. These examples will address several important
concepts that object databases bring to C++. Three of
these are extended object lifetime, expanded object
identity, and automatic maintenance bidirectional
(inverse) relationships.",
acknowledgement = ack-nhfb,
classcodes = "C6160J (Object-oriented databases); C6110J
(Object-oriented programming)",
classification = "C6110J (Object-oriented programming); C6160J
(Object-oriented databases)",
keywords = "Automatic maintenance bidirectional relationships;
automatic maintenance bidirectional relationships; C
language; C++; expanded; Expanded object identity;
Extended object lifetime; extended object lifetime;
Interfaces; interfaces; Object databases; object
databases; object identity; object-oriented;
object-oriented databases; programming; Software
development project; software development project;
Transparency; transparency",
thesaurus = "C language; Object-oriented databases; Object-oriented
programming",
treatment = "P Practical",
}
@Article{Cargill:1992:DVH,
author = "T. Cargill",
title = "A dynamic vector is harder than it looks",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "5",
pages = "47--50",
month = jun,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "There is a subtle bug in the vector template in Glen
McCluskey's article on template instantiation that
should be brought to the attention of programmers who
are considering building a similar class template, see
ibid., vol.4, no.2, p.1-7 (1992). The bug arises from
dangling references, which may appear in a variety of
circumstances. Exactly which expressions in client code
will produce dangling references depends upon the order
of expression evaluation, which, in general, is not
well defined.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming)",
classification = "C6110J (Object-oriented programming)",
keywords = "C language; C++; Dangling references; dangling
references; Dynamic vector; dynamic vector;
instantiation; object-oriented programming; programming
theory; template; Template instantiation; Vector
template; vector template",
thesaurus = "C language; Object-oriented programming; Programming
theory",
treatment = "P Practical",
}
@Article{Leggett:1992:UCS,
author = "B. Leggett",
title = "The {USL C++} Standard Components release 2 (end
user package)",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "5",
pages = "69--73",
month = jun,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Release 2 of the UNIX System Laboratories (USL),
Standard Components (SC) is the end product in a
continuing development of C++ class libraries that has
been going on inside AT and T Bell Labs and USL for
several years. These classes have evolved with the C++
language and its capabilities. They present a robust,
well-tested set of collection, array, and string
classes that are useful in almost any C++ program or
application of any complexity.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages)",
keywords = "Array classes; array classes; AT and T Bell Labs;
AT\&T Bell Labs; C language; C++ class; C++ class
libraries; Collection classes; collection classes; End
user package; end user package; libraries;
object-oriented programming; software tools; Standard
Components release 2; String classes; string classes;
UNIX System Laboratories",
thesaurus = "C language; Object-oriented programming; Software
tools",
treatment = "P Practical; R Product Review",
}
@Article{Meyers:1992:UCE,
author = "S. Meyers",
title = "Using {C++} effectively. Approaches to effectiveness",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "6",
pages = "34--39",
month = jul # "-" # aug,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "As the community of C++ programmers matures, there is
a natural shift from interest in what the language
features are to how to effectively use them. Guidelines
for class interfaces serve as useful starting points
for discussion, but they are hampered by the rich
variety of settings in which C++ is employed.
Constraint-checking programs modeled on lint offer the
advantage of automated detection of constraint
violations, but still suffer from the difficulty in
coming up with constraints that are universally
applicable. Natural language guidelines such as those
found in EFFECTIVE C++ are a good way to initiate C++
programmers into the subtleties of the language, but
such guidelines are rarely amenable to automatic
enforcement. Finally, a constraint language like CCEL
vastly expands the expressiveness and flexibility of an
automatic constraint-checking program, but it cannot
overcome the fact that many useful heuristics for C++
software development are impossible to formalize. The
search for better ways to summarize how to use C++
effectively will continue, of course, but for the
foreseeable future, the best approach is a combination
of informal guidelines with well-defined areas of
applicability, increasingly sophisticated automated
tools, and the insights that can only be gleaned from
bitter experience.",
acknowledgement = ack-nhfb,
affiliation = "Dept. of Comput. Sci., Brown Univ., Providence, RI,
USA",
classcodes = "C6140D (High level languages)",
classification = "C6140D (High level languages)",
corpsource = "Dept. of Comput. Sci., Brown Univ., Providence, RI,
USA",
keywords = "Automated tools; automated tools; C language; C++;
CCEL; class; Class interfaces; Constraint checking
programs; constraint checking programs; Constraint
language; constraint language; Constraint violations;
constraint violations; Expressiveness; expressiveness;
interfaces; Programmers; programmers",
thesaurus = "C language",
treatment = "P Practical",
}
@Article{Tavakkolian:1992:CPP,
author = "S. Tavakkolian",
title = "Crossing paradigms. {A} pilgrim's journey from {C} to
{C++}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "6",
pages = "40--45",
month = jul # "-" # aug,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Changing from C and procedural programming to C++ and
object-oriented (O-O) programming can be a hard
proposition. The author looks at the problem, it is not
just a matter of learning rules for spelling and
syntax, it is learning a completely new way of
expressing thoughts.",
acknowledgement = ack-nhfb,
affiliation = "Claircom, Seattle, WA, USA",
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages)",
corpsource = "Claircom, Seattle, WA, USA",
keywords = "C; C language; C++; object-oriented programming; OO
programming; Procedural programming; procedural
programming",
thesaurus = "C language; Object-oriented programming",
treatment = "P Practical",
}
@Article{Martin:1992:ACP,
author = "R. Martin",
title = "Abstract classes and pure virtual functions",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "6",
pages = "46--52",
month = jul # "-" # aug,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Abstract classes provide a powerful design technique
which promotes code reuse and polymorphism. Abstract
classes are produced by factoring out the common
features of the concrete classes of the application.
Although such factorings are sometimes hard to find,
the effort put into finding them is usually well worth
the benefits of the extra maintainability and
reusability. In general, common features should be
factored out and moved as high as possible in the
inheritance structure. In C++, pure virtual functions
are used to specify the pure interfaces of abstract
classes. An abstract class in C++ must have at least
one pure virtual function. Although pure virtual
functions typically have no implementation, C++ allows
implementations to be given to them. The user must take
care not to invoke pure virtual functions in the
constructors or destructors of an abstract class.",
acknowledgement = ack-nhfb,
classcodes = "C6140D (High level languages); C6110J (Object-oriented
programming)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages)",
keywords = "Abstract classes; abstract classes; C language; C++;
Maintainability; maintainability; object-oriented
programming; Pure virtual functions; pure virtual
functions; Reusability; reusability",
thesaurus = "C language; Object-oriented programming",
treatment = "P Practical",
}
@Article{Ball:1992:ITI,
author = "M. Ball",
title = "Inside templates: implementing {C++} strategies",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "7",
pages = "36--40",
month = sep,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The authors outline the framework of their mythical
C++ compiler. They then consider some embellishments
that can be added and describe the construction of
token streams. The token stream is a good example of a
tool that can be used in several (sometimes unexpected)
places in a C++ compiler. In fact, the entire token
stream mechanism was developed for use in parsing, and
has proved to have further application when
implementing inline functions, class definitions and
now, templates. It's also a good example of code that
developed from an ad hoc technique for handling a
difficult problem (parser lookahead and backtracking)
into a clean and powerful technique with general
applicability.",
acknowledgement = ack-nhfb,
classcodes = "C6150C (Compilers, interpreters and other processors);
C6140D (High level languages); C6110J (Object-oriented
programming)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages); C6150C (Compilers, interpreters and
other processors)",
keywords = "Ad hoc technique; ad hoc technique; Backtracking;
backtracking; C language; C++ compiler; Class
definitions; class definitions; functions; inline;
Inline functions; lookahead; object-oriented
programming; parser; Parser lookahead; Parsing;
parsing; program compilers; program processors;
Templates; templates; Token stream; token stream",
thesaurus = "C language; Object-oriented programming; Program
compilers; Program processors",
treatment = "P Practical",
}
@Article{Becker:1992:MCS,
author = "P. Becker",
title = "A msgstream class for smart formatting: Easing the
translator's job",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "7",
pages = "42--48",
month = sep,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The author briefly summarizes the problems that come
up during translation of program into a different
national language, and describes a variation of the
class ostream that solves one of the biggest ones. The
author discusses text translation, collating sequences;
character sets; and string lengths. He introduces the
msgstream class and the msgbuf class. He provides a C
listing for msgbuf. National language support must be
designed into programs. Put all your text strings into
resources or at least a separate source file. Use
strcoll(), not strcmp(). Use wide chars. Don't
hard-code buffer sizes, and be sure that all buffers
are big enough to allow for growth during translation.
Use flexible formatting techniques. In short, think
about the problems of translating the program for use
with a different language before starting to write the
code. This will make the translator's job much
easier.",
acknowledgement = ack-nhfb,
classcodes = "C6110 (Systems analysis and programming); C6110J
(Object-oriented programming)",
classification = "C6110 (Systems analysis and programming); C6110J
(Object-oriented programming)",
keywords = "C listing; C listings; Character sets; character sets;
collating; Collating sequences; data structures;
flexible; Flexible formatting techniques; formatting
techniques; input-output programs; National language;
national language; object-; oriented programming;
Ostream; ostream; programming; sequences; Strcmp();
strcmp(); Strcoll(); strcoll(); String lengths; string
lengths; strings; system documentation; text; Text
strings; Text translation; text translation; Wide
chars; wide chars",
thesaurus = "C listings; Data structures; Input-output programs;
Object-oriented programming; Programming; System
documentation",
treatment = "P Practical",
}
@Article{Bartels:1992:POO,
author = "D. Bartels and J. Robie",
title = "Persistent objects and object-oriented databases for
{C++}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "7",
pages = "49--50, 52--56",
month = sep,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "To store data in a conventional database, it must be
dissected into a series of two-dimensional tables. Only
predeclared data types are supported. Object-oriented
programming languages have a rich set of features for
creating data types and representing the relationships
among data that are not supported in such databases.
The authors discuss features that an object-oriented
database must support. To illustrate these features we
examine POET, a commercial object-oriented database
system with which the authors are connected.",
acknowledgement = ack-nhfb,
classcodes = "C6160J (Object-oriented databases); C6120 (File
organisation)C6110J (Object-oriented programming)",
classification = "C6110J (Object-oriented programming); C6120 (File
organisation); C6160J (Object-oriented databases)",
keywords = "C language; C listings; Data types; data types;
Object-oriented database; object-oriented database;
object-oriented databases; POET",
thesaurus = "C language; C listings; Object-oriented databases",
treatment = "P Practical",
}
@Article{Carroll:1992:IIM,
author = "M. Carroll",
title = "Invasive inheritance: modifying a base class to enable
inheritance",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "8",
pages = "34--42",
month = oct,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The author calls the act of modifying the intended
base class, then inheriting from it invasive
inheritance. He shows an example of invasive
inheritance in C++. The intended base class represents
the set of binary search trees; the intended derived
class represents the set of red-black trees. A
red-black tree IS-A binary search tree. He shows a
typical implementation of a binary search tree class.
Then he shows that attempting to derive a red-black
tree class from the binary search tree class fails, and
what invasions into the base class one must make to
permit the derivation to work. The invasive inheritance
problem is not unique to C++. He explains what
properties programming languages in general have that
cause the need for such an invasion. Most of the causes
of invasive inheritance could theoretically be removed
from programming languages, but only at the cost of
introducing other problems.",
acknowledgement = ack-nhfb,
affiliation = "AT and T Bell Labs., Murray Hill, NJ, USA",
classcodes = "C6140D (High level languages); C6110J (Object-oriented
programming)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages)",
corpsource = "AT\&T Bell Labs., Murray Hill, NJ, USA",
keywords = "Binary search tree; binary search tree; C language;
C++; Inheritance; inheritance; Intended base class;
intended base class; Invasive inheritance; invasive
inheritance; object-oriented programming; Red-black
trees; red-black trees",
thesaurus = "C language; Object-oriented programming",
treatment = "P Practical",
}
@Article{Banahan:1992:CTM,
author = "M. Banahan",
title = "Cross-over training: making the transition from {C} to
{C++}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "8",
pages = "44--48",
month = oct,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The author has been teaching C programmers to make the
transition to C++ for nearly seven years. Merely
teaching syntax is not enough. Doing so leaves students
knowing how, but not why. Managers are often unhappy at
the end of the process because nobody told them that
they were changing to a very different style of
programming, let alone to a language that is at least
as complex as Ada. The article describes ways found to
produce happiness in the first group, while allaying
fears of the second (to some extent).",
acknowledgement = ack-nhfb,
classcodes = "C0220 (Education and training); C6110J
(Object-oriented programming); C6140D (High level
languages)",
classification = "C0220 (Education and training); C6110J
(Object-oriented programming); C6140D (High level
languages)",
keywords = "C language; computer science education;
object-oriented; programming; Training; training",
thesaurus = "C language; Computer science education;
Object-oriented programming; Training",
treatment = "A Application; P Practical",
}
@Article{Schmidt:1992:SPC,
author = "D. Schmidt",
title = "Systems programming with {C++} wrappers: encapsulating
{IPC} services with object-oriented interfaces",
journal = j-C-PLUS-PLUS-REPORT,
volume = "4",
number = "8",
pages = "50--54",
month = oct,
year = "1992",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The article describes a technique for encapsulating
existing operating system interprocess communication
(IPC) services within object-oriented C++ wrappers.
These services include mechanisms for local IPC (such
as shared memory; semaphores; message queues;
memory-mapped files; named, unnamed, and stream pipes;
and BSD UNIX-domain sockets) and network IPC (such as
remote procedure calls (RPC), BSD Internet-domain
sockets, and System V Transport Layer Interface
(TLI)).",
acknowledgement = ack-nhfb,
classcodes = "C6150N (Distributed systems); C6110J (Object-oriented
programming)",
classification = "C6110J (Object-oriented programming); C6150N
(Distributed systems)",
keywords = "BSD; BSD Internet-domain sockets; BSD UNIX-domain
sockets; C++ wrappers; Interface; interprocess
communication; IPC services; Local IPC; local IPC;
memory; Memory-mapped files; memory-mapped files;
Message queues; message queues; Network IPC; network
IPC; network operating systems; Object-oriented
interfaces; object-oriented interfaces; object-oriented
programming; operating system; Operating system
interprocess communication; Remote procedure calls;
remote procedure calls; Semaphores; semaphores; shared;
Shared memory; System V Transport Layer; System V
Transport Layer Interface; Unix; UNIX-domain sockets",
thesaurus = "Network operating systems; Object-oriented
programming; Unix",
treatment = "P Practical",
}
@Article{Meyers:1993:UCE,
author = "S. Meyers",
title = "Using {C++} effectively. Examining development tools",
journal = j-C-PLUS-PLUS-REPORT,
volume = "5",
number = "1",
pages = "30, 32--35",
month = jan,
year = "1993",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Discusses some questions you might want to direct at
vendors of debuggers, class browsers, and development
environments. Choosing effective tools for C++ software
development is not as easy as it should be, although
the situation is substantially better than it was. Arm
yourself with as much information about your
programming needs as you possibly can, because until
high-quality tools for C++ development become widely
available on all platforms, the best advice remains
unchanged from that of centuries ago: caveat emptor
(let the buyer beware).",
acknowledgement = ack-nhfb,
affiliation = "Dept. of Comput. Sci., Brown Univ., Providence, RI,
USA",
classcodes = "C6115 (Programming support); C0310H (Equipment and
software evaluation methods); C6150G (Diagnostic,
testing, debugging and evaluating systems); C6110J
(Object-oriented programming)",
classification = "C0310H (Equipment and software evaluation methods);
C6110J (Object-oriented programming); C6115
(Programming support); C6150G (Diagnostic, testing,
debugging and evaluating systems)",
corpsource = "Dept. of Comput. Sci., Brown Univ., Providence, RI,
USA",
keywords = "browsers; C language; C++ software development tool
selection; class; Class browsers; Debuggers; debuggers;
Development environments; development environments;
object-oriented languages; program debugging;
programming environments; Programming needs;
programming needs; software selection; software tools",
thesaurus = "C language; Object-oriented languages; Program
debugging; Programming environments; Software
selection; Software tools",
treatment = "P Practical",
}
@Article{Reed:1993:ETC,
author = "D. Reed",
title = "Engineering the transition to {C++}: a manager's
perspective on realizing the benefits of {OOP}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "5",
number = "1",
pages = "36, 38--42",
month = jan,
year = "1993",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Managing the transition from C to C++ necessitates
good engineering. As with any engineering task, the
trade-offs must be understood and evaluated. This
article provides a realistic view of the trade-offs
associated with moving to C++ and object-oriented
programming (OOP). Moving to the language is definitely
a good idea, and it can be done incrementally. If the
incremental approach is taken, the benefits are
received incrementally as well.",
acknowledgement = ack-nhfb,
classcodes = "C0310F (Software development management); C6140D (High
level languages); C6110J (Object-oriented
programming)",
classification = "C0310F (Software development management); C6110J
(Object-oriented programming); C6140D (High level
languages)",
keywords = "C language; C++; DP management; Incremental approach;
incremental approach; Language migration; language
migration; Manager's perspective; manager's
perspective; object-; object-oriented languages;
Object-oriented programming; object-oriented
programming; oriented programming; Trade-offs;
trade-offs",
thesaurus = "C language; DP management; Object-oriented languages;
Object-oriented programming",
treatment = "P Practical",
}
@Article{Vines:1993:SRT,
author = "D. Vines and Z. Kishimoto",
title = "{Smalltalk}'s runtime type support for {C++}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "5",
number = "1",
pages = "44--52",
month = jan,
year = "1993",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The Object Management Group (OMG) is establishing
specifications for a common framework for integrating
distributed applications using an object technology
approach. One of these specifications is the Common
Object Request Broker Architecture (CORBA). It defines
the mechanisms required to transparently apply requests
to objects and receive responses over a network. These
mechanisms are implemented by an object request broker
(ORB) and enable different applications running on
different machine to `inter-operate' with each other.
All of ORB's functions require access to type
information at runtime. To support these features,
runtime type information needs to include: type of
object, methods of type, inheritance of types, identity
of object and type, and instances of type. Smalltalk
supports all these features as part of the language
system, except for the passing of objects across
address spaces. Therefore, instead of developing a new
method, the authors decided to emulate Smalltalk typing
with C++ and to do it in such a way as not to require
any changes to the language itself or existing
compilers.",
acknowledgement = ack-nhfb,
affiliation = "NEC C and C Software Technol. Center, Irvine, TX,
USA",
classcodes = "C6140D (High level languages); C6110J (Object-oriented
programming)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages)",
corpsource = "NEC C and C Software Technol. Center, Irvine, TX,
USA",
keywords = "abstract data types; Architecture; C language; C++;
Common Object Request Broker; Common Object Request
Broker Architecture; CORBA; Interoperating
applications; interoperating applications; Network;
network; Object Management Group; Runtime type support;
runtime type support; Smalltalk",
thesaurus = "Abstract data types; C language; Smalltalk",
treatment = "P Practical",
}
@Article{Coggins:1993:PPL,
author = "J. M. Coggins",
title = "Practical principles for library design. {I}.
Selecting the right abstractions is the key",
journal = j-C-PLUS-PLUS-REPORT,
volume = "5",
number = "2",
pages = "38--42",
month = feb,
year = "1993",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Image processing and analysis presents several design
and programming challenges that exercise the nuances of
both object-oriented design and C++. The article is the
first in a series that discusses how these challenges
have been addressed in IGLOO, the authors
object-oriented image and graphics research library,
which is written in C++. The article describes the
design principles underlying IGLOO and explains some
important trade-offs in tuning IGLOO for its
application domain and user community.",
acknowledgement = ack-nhfb,
affiliation = "North Carolina Univ., Chapel Hill, NC, USA",
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages)",
corpsource = "North Carolina Univ., Chapel Hill, NC, USA",
keywords = "C language; C++; computer graphics; IGLOO; image
processing; object-; Object-oriented design;
object-oriented design; oriented programming; software
reusability; subroutines",
thesaurus = "C language; Computer graphics; Image processing;
Object-oriented programming; Software reusability;
Subroutines",
treatment = "P Practical",
}
@Article{Schmidt:1993:EOS,
author = "D. C. Schmidt",
title = "Encapsulating operating system {IPC}s. An
object-oriented interface for event-driven {UNIX I/O}
multiplexing",
journal = j-C-PLUS-PLUS-REPORT,
volume = "5",
number = "2",
pages = "43--50",
month = feb,
year = "1993",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "For previous part see ibid. vol.4, no.8, p.50-4, 1992.
The article describes a technique for encapsulating
existing operating system (OS) interprocess
communication (IPC) services within object-oriented
(O-O) C++ wrappers. It presents an O-O wrapper for the
I/O multiplexing facilities provided by the BSD
select() and System V UNIX poll() system calls.
Multiplexing is particularly useful for event-driven
network servers that perform I/O on many connections
simultaneously. The article describes a distributed
logging facility that motivates the need for efficient
I/O multiplexing, examines several alternative solution
approaches, evaluates the advantages and disadvantages
of these approaches, and compares them with the
Reactor. Reactor is an extensible O-O class library
written in C++ to provide a higher-level programming
abstraction that simplifies the design and
implementation of event-driven network applications.",
acknowledgement = ack-nhfb,
affiliation = "California Univ., Irvine, CA, USA",
classcodes = "C6150N (Distributed systems); C6110J (Object-oriented
programming); C6155 (Computer communications
software)",
classification = "C6110J (Object-oriented programming); C6150N
(Distributed systems); C6155 (Computer communications
software)",
corpsource = "California Univ., Irvine, CA, USA",
keywords = "BSD select(); computer communications software; data
encapsulation; Distributed logging facility;
distributed logging facility; event-driven network;
Event-driven network servers; event-driven UNIX I/O;
Event-driven UNIX I/O multiplexing; Higher-level
programming abstraction; higher-level programming
abstraction; input-; Interprocess communication;
interprocess communication; multiplexing; network
operating systems; O-O class library; Object-oriented
interface; object-oriented interface; object-oriented
programming; output programs; servers; System calls;
system calls; System V UNIX poll(); Unix",
thesaurus = "Computer communications software; Data encapsulation;
Input-output programs; Multiplexing; Network operating
systems; Object-oriented programming; Unix",
treatment = "P Practical",
}
@Article{Becker:1993:IPR,
author = "P. Becker",
title = "Iterators, portability, and reuse",
journal = j-C-PLUS-PLUS-REPORT,
volume = "5",
number = "2",
pages = "51--54",
month = feb,
year = "1993",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "One very common programming task is to perform some
operation on each element in a set of objects. The set
of objects may be a group of files, and the operation
may be displaying the name of each of the files. This
task shares a common structure with other such tasks,
namely iteration over a set of elements. The author
explores that common structure, illustrate how it can
be encapsulated in several different forms of
iterators, and how those iterators help improve
portability and reusability of code. The author begins
with a simple iterator that runs into serious problems
when he tries to reuse it. By separating the underlying
concept of iteration from the particular application,
he creates an explicit iterator that is much more
reusable. By encapsulating the bookkeeping involved in
performing the iteration, he comes up with a callback
iterator. And by replacing the function pointer in the
callback iterator with a virtual function, he creates
an inherited iterator that is much safer to use than
the callback iterator.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming)",
classification = "C6110J (Object-oriented programming)",
keywords = "Bookkeeping; bookkeeping; C listings; Callback
iterator; callback iterator; Encapsulating;
encapsulating; Function pointer; function pointer;
Inherited iterator; inherited iterator; object-oriented
programming; Portability; portability; Reusability;
reusability; software; software reusability; Virtual
function; virtual function",
thesaurus = "C listings; Object-oriented programming; Software
portability; Software reusability",
treatment = "P Practical",
}
@Article{Atwood:1993:GPC,
author = "W. Atwood and A. Breakstone and D. Britton and T.
Burnett and D. Myers and G. Word",
title = "The {GISMO} project ({C++})",
journal = j-C-PLUS-PLUS-REPORT,
volume = "5",
number = "3",
pages = "38--43",
month = mar # "-" # apr,
year = "1993",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The GISMO (Graphical Interface for Simulation and
Monte Carlo with Objects) project began as a prototype
to test the applicability of object-oriented techniques
to detector simulation and event reconstruction. It was
written using the Objective-C language with a graphical
user interface (GUI) designed using the NeXT Interface
Builder. GISMO will serve both as a tool to design new
generations of high energy physics detectors and as a
tool with which present-day detectors may be more
easily understood.",
acknowledgement = ack-nhfb,
affiliation = "SLAC, Stanford Univ., CA, USA",
classcodes = "C7320 (Physics and Chemistry); C6180G (Graphical user
interfaces); C6110J (Object-oriented programming)",
classification = "C6110J (Object-oriented programming); C6180G
(Graphical user interfaces); C7320 (Physics and
Chemistry)",
corpsource = "SLAC, Stanford Univ., CA, USA",
keywords = "C language; C++; CAD; Detector simulation; detector
simulation; Event reconstruction; event reconstruction;
GISMO; Graphical user interface; graphical user
interface; graphical user interfaces; High energy
physics detectors; high energy physics detectors;
Interface Builder; language; Monte Carlo; NeXT;
object-oriented; Object-oriented techniques;
object-oriented techniques; Objective-C; Objective-C
language; physics computing; programming; simulation",
thesaurus = "C language; CAD; Graphical user interfaces;
Object-oriented programming; Physics computing;
Simulation",
treatment = "A Application; P Practical",
}
@Article{Sakkinen:1993:HSV,
author = "M. Sakkinen",
title = "How should virtual bases be initialized (and
finalized)?",
journal = j-C-PLUS-PLUS-REPORT,
volume = "5",
number = "3",
pages = "44--50",
month = mar # "-" # apr,
year = "1993",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The author argues that fork-join inheritance should
not be able to break the integrity of the base class
subobject: two paths should either share the same
subobject or have completely disjoint subobjects.
Multiple inheritance (MI) in C++ appeared to work like
this, in contrast to many other object-oriented
languages. He discusses some more subtle problems
caused by the C++ approach including problems with
virtual bases and requirements for initialization.",
acknowledgement = ack-nhfb,
affiliation = "Jyvaskyla Univ., Finland",
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages)",
corpsource = "Jyvaskyla Univ., Finland",
keywords = "C language; C++; fork-join; Fork-join inheritance;
inheritance; Initialization; initialization; Object
oriented programming; object oriented programming;
object-; Object-oriented languages; object-oriented
languages; oriented programming; Virtual bases; virtual
bases",
thesaurus = "C language; Inheritance; Object-oriented languages;
Object-oriented programming",
treatment = "P Practical",
}
@Article{Dewhurst:1993:SM,
author = "S. C. Dewhurst",
title = "Subobject members",
journal = j-C-PLUS-PLUS-REPORT,
volume = "5",
number = "3",
pages = "51--53",
month = mar # "-" # apr,
year = "1993",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "How does a base class differ from a member? This
article examines some techniques that allows one to
employ members as the functional equivalent of base
classes, to simplify an implementation, change a
synthetic relationship into a natural one, or to allow
source code to be tailored without altering abstract
type relationships or modifying the C++ source code.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages)",
keywords = "Abstract type relationships; abstract type
relationships; Base class; base class; C language; C++;
Members; members; object-oriented; object-oriented
languages; programming",
thesaurus = "C language; Object-oriented languages; Object-oriented
programming",
treatment = "P Practical",
}
@Article{Webster:1993:CE,
author = "J. Webster and F. Douglas",
title = "{C++} is everywhere",
journal = j-C-PLUS-PLUS-REPORT,
volume = "5",
number = "4",
pages = "36--39",
month = may,
year = "1993",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The authors evaluate the state of C++ applications.
How far has the language come since the definitions of
object-oriented terms and concepts were introduced into
the professional journals . . . since C++ was
introduced as a leading-edge research tool for
scientific applications? Current applications range
from complex network control to the simplest screen
presentations, and include everything from satellites,
rockets, submarines, robots, stock market options and
accounts payable line items. The language has come a
long way in the past five years, and they have asked
users at all ends of the spectrum-developers,
programmers end users-for their experiences in using
C++.",
acknowledgement = ack-nhfb,
classcodes = "C6140D (High level languages); C6110J (Object-oriented
programming)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages)",
keywords = "accounts payable; Accounts payable line items; C
language; C++ applications; complex network; Complex
network control; control; line items; object-oriented
languages; Object-oriented terms; object-oriented
terms; Robots; robots; Rockets; rockets; Satellites;
satellites; Screen presentations; screen presentations;
Stock market options; stock market options; Submarines;
submarines",
thesaurus = "C language; Object-oriented languages",
treatment = "G General Review",
}
@Article{Reid:1993:CFP,
author = "R. J. Reid",
title = "{C++} as a first programming language",
journal = j-C-PLUS-PLUS-REPORT,
volume = "5",
number = "4",
pages = "41--44",
month = may,
year = "1993",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The Computer Science Department at Michigan State
University has started using C++ as the primary
language for programming instruction in its courses.
The author discusses why C++ was chosen. He explains
the course content, assesses results to date and
explores future directions.",
acknowledgement = ack-nhfb,
affiliation = "Dept. of Comput. Sci., Michigan State Univ., East
Lansing, MI, USA",
classcodes = "C0220 (Education and training); C6140D (High level
languages)C6110J (Object-oriented programming)",
classification = "C0220 (Education and training); C6110J
(Object-oriented programming); C6140D (High level
languages)",
corpsource = "Dept. of Comput. Sci., Michigan State Univ., East
Lansing, MI, USA",
keywords = "C language; C++; computer science education; Course
content; course content; First programming language;
first programming language; languages;
object-oriented",
thesaurus = "C language; Computer science education;
Object-oriented languages",
treatment = "A Application; G General Review",
}
@Article{Teale:1993:TTL,
author = "S. Teale",
title = "Transplanting a tree-recursive {LISP} algorithm to
{C++}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "5",
number = "4",
pages = "45--48",
month = may,
year = "1993",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The author takes a small program, illustrating a
typical tree-recursive process, written in the Scheme
dialect of LISP and writes a version of it in C++. A
tree-recursive process typically uses a function that
calls itself more than once, thus generating an
exponentially increasing number of nested
invocations.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming)",
classification = "C6110J (Object-oriented programming)",
keywords = "C listings; C++; object-oriented; object-oriented
languages; programming; recursive functions; Scheme;
software portability; Tree-recursive LISP algorithm;
tree-recursive LISP algorithm",
thesaurus = "C listings; Object-oriented languages; Object-oriented
programming; Recursive functions; Software
portability",
treatment = "P Practical",
}
@Article{Stroustrup:1993:LDU,
author = "B. Stroustrup",
title = "Library design using {C++}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "5",
number = "5",
pages = "14--22",
month = jun,
year = "1993",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The designer of a C++ library has several choices for
the basic structure of a library and can even provide
more than one interface style for a single library. C++
evolved to enable this diversity of library
architectures and some of the newer C++ features are
designed to ease the coexistence of libraries. The
author focuses on generalities and language support for
library building.",
acknowledgement = ack-nhfb,
affiliation = "Dept. of Comput. Structures Res., AT and T Bell Labs.,
Murray Hill, NJ, USA",
classcodes = "C6140D (High level languages); C6110J (Object-oriented
programming)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages)",
corpsource = "Dept. of Comput. Structures Res., AT\&T Bell Labs.,
Murray Hill, NJ, USA",
keywords = "C language; C listings; C++ library; Library
architectures; library architectures; object-;
object-oriented languages; oriented programming;
software reusability",
thesaurus = "C language; C listings; Object-oriented languages;
Object-oriented programming; Software reusability",
treatment = "P Practical",
}
@Article{Lea:1993:GCL,
author = "D. Lea",
title = "The {GNU C++} library",
journal = j-C-PLUS-PLUS-REPORT,
volume = "5",
number = "5",
pages = "24--27",
month = jun,
year = "1993",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The GNU C++ library (libg++) was one of the first
widely available general-purpose C++ class libraries.
Libg++ is mainly an `abstract data structure library'.
Most libg++ classes are somewhat different in design
philosophy, design, and implementation than the classes
ordinarily constructed for specific application. This
article focuses mainly on these differences without
otherwise going into much detail about particular
components.",
acknowledgement = ack-nhfb,
affiliation = "Dept. of Comput. Sci., State Univ. of New York, NY,
USA",
classcodes = "C6140D (High level languages); C6110J (Object-oriented
programming)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages)",
corpsource = "Dept. of Comput. Sci., State Univ. of New York, NY,
USA",
keywords = "Abstract data structure library; abstract data
structure library; abstract data types; C language;
General-purpose C++ class libraries; general-purpose
C++ class libraries; GNU C++ library; Libg++;
object-oriented languages; object-oriented programming;
software reusability",
thesaurus = "Abstract data types; C language; Object-oriented
languages; Object-oriented programming; Software
reusability",
treatment = "P Practical",
}
@Article{Keffer:1993:DAT,
author = "T. Keffer",
title = "The design and architecture of {Tools.h}++",
journal = j-C-PLUS-PLUS-REPORT,
volume = "5",
number = "5",
pages = "28--33",
month = jun,
year = "1993",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Rogue Wave Software's Tools.h++ has its roots in the
Data Analysis and Interactive Modeling Software (DAIMS)
project at the University of Washington. The objective
of the project was to develop reusable mathematical
modeling tools for use in fluid dynamics. The library
includes a set of abstract data types (ADTs), and
corresponding specializing classes, that provides a
framework for persistence, localization, and other
issues, although this is not the central focus of the
library. The author discusses the various concrete
classes offered by Tools.h++, then its various
abstraction facilities. This is followed by a look at
various implementation issues including implementation
conventions, error handling, and dynamic link
libraries.",
acknowledgement = ack-nhfb,
affiliation = "Rogue Wave Software, Corvallis, OR, USA",
classcodes = "C6140D (High level languages); C6110J (Object-oriented
programming)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages)",
corpsource = "Rogue Wave Software, Corvallis, OR, USA",
keywords = "Abstract data types; abstract data types; Abstraction;
abstraction; and Interactive Modeling Software; C
language; C++ library; Data Analysis; Data Analysis and
Interactive Modeling Software; Dynamic link libraries;
dynamic link libraries; Error handling; error handling;
Fluid dynamics; fluid dynamics; modeling tools;
object-oriented languages; object-oriented programming;
reusable mathematical; Reusable mathematical modeling
tools; Rogue Wave Software; software reusability;
Tools.h++",
thesaurus = "Abstract data types; C language; Object-oriented
languages; Object-oriented programming; Software
reusability",
treatment = "P Practical",
}
@Article{Carroll:1993:DUS,
author = "M. Carroll",
title = "Design of the {USL Standard Components}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "5",
number = "5",
pages = "34--39, 53",
month = jun,
year = "1993",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "USL C++ Standard Components (SC) is a general-purpose
library. The principal design goals of SC are wide
utility and efficiency. SC contains a collection of C++
classes that are both useful and efficient in a broad
range of C++ programs. SC also contains tools intended
to make programming in C++ easier. For example. it
contains a tool that can produce an ASCII, T/sub E/X,
or Postcript representation of the class inheritance
hierarchy contained in a given collection of C++ source
files. The author restricts his attention to the
classes.",
acknowledgement = ack-nhfb,
classcodes = "C6140D (High level languages); C6110J (Object-oriented
programming); C6110B (Software engineering
techniques)",
classification = "C6110B (Software engineering techniques); C6110J
(Object-oriented programming); C6140D (High level
languages)",
keywords = "ASCII; C language; C++ programs; Class inheritance
hierarchy; class inheritance hierarchy;
object-oriented; object-oriented languages; Postcript;
programming; software reusability; TEX; USL C++
Standard Components",
thesaurus = "C language; Object-oriented languages; Object-oriented
programming; Software reusability",
treatment = "P Practical",
}
@Article{Booch:1993:SBC,
author = "G. Booch and M. Vilot",
title = "Simplifying the {Booch} Components",
journal = j-C-PLUS-PLUS-REPORT,
volume = "5",
number = "5",
pages = "41--52",
month = jun,
year = "1993",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "What factors contributed to making the C++ Booch
Components into `the incredible shrinking library?'
This article examines, how the concepts of OOD and the
features of C++ helped to organize and simplify the
library. First, it provides a brief overview of the
library showing its contents and organization. Then, it
explores how inheritance and parameterization helped to
streamline and simplify the library. The article
concludes with a summary of how much each design change
contributed to the overall size reduction.",
acknowledgement = ack-nhfb,
classcodes = "C6140D (High level languages); C6110J (Object-oriented
programming)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages)",
keywords = "C language; C++ Booch Components; Inheritance;
inheritance; object oriented; Object oriented design;
object oriented design; Object oriented programming;
object-oriented; object-oriented languages;
Parameterization; parameterization; programming;
Software library; software library; software
reusability",
thesaurus = "C language; Object-oriented languages; Object-oriented
programming; Software reusability",
treatment = "P Practical",
}
@Article{Hansen:1993:EMA,
author = "T. L. Hansen",
title = "Enhancing memory allocation. An array
reallocation\slash renew function for {C++}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "5",
number = "6",
pages = "20--22, 24, 26--30",
month = jul # "-" # aug,
year = "1993",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "In J. Object-Oriented Program., vol.4, no.6, p.54-9
(1991). A. Koenig analysed a renew operator that
relates to operator new and operator delete the same
way the realloc() function relates to the malloc() and
free() functions. He presented a template function
renew<T>() that implements the desired reallocation
without requiring any changes to the C++ language.
However, there are a couple of problems with the
particular implementation Koenig shows. This article
starts with a recap of Koenig's implementation,
discusses the problems with the implementation,
reexamines the requirements being renew<T>(), shows the
results of attempting to implement it on several
existing C++ platforms that support templates, and
discusses some changes that would be necessary to those
compilers in order to implement such a template
function.",
acknowledgement = ack-nhfb,
classcodes = "C6120 (File organisation); C6110J (Object-oriented
programming)",
classification = "C6110J (Object-oriented programming); C6120 (File
organisation)",
keywords = "array reallocation/renew; Array reallocation/renew
function; C listings; C++ language; Compilers;
compilers; function; Memory allocation enhancement;
memory allocation enhancement; object-oriented
programming; Operator delete; operator delete; Operator
new; operator new; Renew operator; renew operator;
Renew<T>(); renew<T>(); storage allocation; Template
function; template function",
thesaurus = "C listings; Object-oriented programming; Storage
allocation",
treatment = "P Practical",
}
@Article{Vinoski:1993:DOC,
author = "S. Vinoski",
title = "Distributed object computing with {CORBA}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "5",
number = "6",
pages = "32--38",
month = jul # "-" # aug,
year = "1993",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The Object Management Group's Object Management
Architecture (OMA) attempts to define, at a high level
of abstraction, the various facilities necessary for
distributed O-O computing. The core of the OMA is the
Object Request Broker (ORB), a mechanism that provides
transparency of object location, activation, and
communication. In 1991 the OMG published revision 1.1
of the Common Object Request Broker Architecture
(CORBA) specification, a concrete description of the
interfaces and services that must be provided by
compliant ORBs. Since then, many OMG member companies
have either started shipping or have announced plans to
ship products based on the CORBA specification. The
CORBA is composed of five major components: ORB core;
interface definition language; dynamic invocation
interface; interface repository; and object adapters.
This article describes each of these components and
shows how they provide the flexibility required to
support a variety of distributed O-O systems,
emphasizing those developed in C++.",
acknowledgement = ack-nhfb,
affiliation = "Hewlett Packard, Chelmsford, MA, USA",
classcodes = "C6110J (Object-oriented programming); C6150N
(Distributed systems)",
classification = "C6110J (Object-oriented programming); C6150N
(Distributed systems)",
corpsource = "Hewlett Packard, Chelmford, MA, USA",
keywords = "Abstraction; abstraction; C language; C++; Common;
Common Object Request Broker Architecture; CORBA;
Distributed object oriented computing; distributed
object oriented computing; distributed processing;
Dynamic invocation interface; dynamic invocation
interface; Group; Interface definition language;
interface definition language; Interface repository;
interface repository; Object adapters; object adapters;
Object Management; Object Management Architecture;
Object Management Group; Object Request Broker
Architecture; object-oriented; ORB core; programming",
thesaurus = "C language; Distributed processing; Object-oriented
programming",
treatment = "G General Review",
}
@Article{Myers:1993:MMC,
author = "N. C. Myers",
title = "Memory management in {C++}. {I}. Fine-tuning your
programs",
journal = j-C-PLUS-PLUS-REPORT,
volume = "5",
number = "6",
pages = "39--41, 43",
month = jul # "-" # aug,
year = "1993",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Because C++ code is naturally organized by class, a
common response to this failure is to overload member
operator new for individual classes. In addition to
being tedious to implement and maintain, however, this
piecemeal approach can actually hurt performance in
large systems. Furthermore, it tends to fragment memory
by keeping large, mostly empty blocks dedicated to each
class. The result can be a quick new/delete cycle that
accidentally causes virtual memory thrashing. At best,
the approach interferes with system-wide tuning
efforts. Thus, while detailed knowledge of the memory
usage patterns of individual classes can be helpful, it
is best applied by tuning memory usage for a whole
program or major subsystem. This article describes an
interface that can ease such tuning in C++ programs.
Before tuning a particular program, however, it pays to
improve performance for all programs by improving the
global memory manager.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6120 (File
organisation)",
classification = "C6110J (Object-oriented programming); C6120 (File
organisation)",
keywords = "C language; C++ programs; Global memory manager;
global memory manager; Memory usage patterns; memory
usage patterns; object-oriented programming;
Performance; performance; Program fine tuning; program
fine tuning; storage management; system-wide;
System-wide tuning efforts; tuning efforts; Virtual
memory thrashing; virtual memory thrashing",
thesaurus = "C language; Object-oriented programming; Storage
management",
treatment = "P Practical",
}
@Article{Barton:1993:SEP,
author = "J. J. Barton and L. R. Nackman",
title = "Scientific and engineering programming in {C++}:
grafting onto our roots",
journal = j-C-PLUS-PLUS-REPORT,
volume = "5",
number = "7",
pages = "26--31",
month = sep,
year = "1993",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Scientists and engineers typically do more numerical
processing than other programmers, and they tend to
structure their programs around mathematical models.
Rapid improvements in numerical processing speed and
the increasingly sophisticated mathematical models used
to formulate technical programming projects have led
science and engineering programmers to use C++ to
tackle the thorny non-numerical parts of their
programs. The authors discuss techniques for exploiting
existing FORTRAN-callable numerical libraries.",
acknowledgement = ack-nhfb,
affiliation = "IBM Thomas J. Watson Res. Center, Hawthorne, NY, USA",
classcodes = "C7300 (Natural sciences); C7400 (Engineering); C6110J
(Object-oriented programming); C4100 (Numerical
analysis)",
classification = "C4100 (Numerical analysis); C6110J (Object-oriented
programming); C7300 (Natural sciences); C7400
(Engineering)",
corpsource = "IBM Thomas J. Watson Res. Center, Hawthorne, NY, USA",
keywords = "C listings; C++; computing; engineering computing;
Engineering programming; engineering programming;
FORTRAN-callable numerical libraries; Mathematical
models; mathematical models; natural sciences;
Nonnumerical programming; nonnumerical programming;
numerical analysis; Numerical processing; numerical
processing; object-oriented programming; Scientific
programming; scientific programming; subroutines",
thesaurus = "C listings; Engineering computing; Natural sciences
computing; Numerical analysis; Object-oriented
programming; Subroutines",
treatment = "P Practical",
}
@Article{Schmidt:1993:CWU,
author = "D. C. Schmidt",
title = "A {C++} wrapper for {UNIX I/O} multiplexing: the
object-oriented design and implementation of the
{Reactor}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "5",
number = "7",
pages = "32--43",
month = sep,
year = "1993",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Describes techniques for encapsulating existing
operating system interprocess communication services
using object-oriented C++ wrappers. I/O multiplexing is
useful for developing event-driven network servers that
receive and process data arriving from multiple clients
simultaneously. This article focuses on the design and
implementation of a C++ wrapper called the Reactor. The
Reactor provides a portable interface to an
object-oriented library of extensible, reusable, and
type-secure C++ classes that encapsulate and enhance
the select() and poll() UNIX I/O multiplexing
facilities. To help simplify network programming, the
Reactor integrates the multiplexing of synchronous and
asynchronous I/O-based events together with timer-based
events. When these events occur, the Reactor
automatically dispatches previously registered
application-defined member functions to handle the
events. In addition to describing the Reactor, this
article also presents a distributed logging facility
that demonstrates how the Reactor simplifies the
development of concurrent, event-driven network
applications.",
acknowledgement = ack-nhfb,
classcodes = "C6150N (Distributed systems); C6110J (Object-oriented
programming)",
classification = "C6110J (Object-oriented programming); C6150N
(Distributed systems)",
keywords = "application-defined; Application-defined member
functions; Asynchronous events; asynchronous events; C
listings; C++ wrapper; Concurrent applications
development; concurrent applications development;
Distributed logging facility; distributed logging
facility; distributed processing; Encapsulation;
encapsulation; event-driven; Event-driven network
servers; input-; member functions; multiplexing;
network servers; object-; Object-oriented design;
object-oriented design; operating; Operating system
interprocess communication services; oriented
programming; output programs; Portable interface;
portable interface; Reactor; software portability;
subroutines; Synchronous events; synchronous events;
system interprocess communication services; Unix; UNIX
I/O; UNIX I/O multiplexing",
thesaurus = "C listings; Distributed processing; Encapsulation;
Input-output programs; Multiplexing; Network servers;
Object-oriented programming; Software portability;
Subroutines; Unix",
treatment = "P Practical",
}
@Article{Stroustrup:1993:WCL,
author = "B. P. Stroustrup",
title = "Why consider language extensions? Maintaining a
delicate balance",
journal = j-C-PLUS-PLUS-REPORT,
volume = "5",
number = "7",
pages = "44--51",
month = sep,
year = "1993",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Formal standardization of C++ started in December 1989
when the ANSI C++ committee, X3J16, was formed. The
initiative came from IBM, DEC, and HP and was supported
by AT and T. In June 1991 the effort became officially
international with the creation of the ISO SC22-WG21.
Thus, a single US national and international C++
standard will emerge. Every living programming language
faces a conflict between stability vs. the need to grow
to meet new challenges and reflect new insights. This
problem will not go away and must be handled delicately
and with common sense. As usual, one person's common
sense is another's lunacy, but no simple and absolute
rule can adequately express a policy on this matter.
The particular example of a proposed extension
discussed in this article, namespaces, is simple,
easily comprehended, and almost completely compatible.
It solves a serious problem, transition from older
styles to use of namespaces is easy, and it has been
implemented. The problem it addresses cannot be
adequately handled with existing language features or
through a library. It is an example of a proposed
extension that deserves to be accepted.",
acknowledgement = ack-nhfb,
affiliation = "Dept. of Comput. Structures Res., AT and T Bell Labs.,
Murray Hill, NJ, USA",
classcodes = "C6140D (High level languages)",
classification = "C6140D (High level languages)",
corpsource = "Dept. of Comput. Structures Res., AT\&T Bell Labs.,
Murray Hill, NJ, USA",
keywords = "ANSI C++ committee; C language; Compatibility;
compatibility; International C++ standard;
international C++ standard; ISO SC22-WG21; Language
extensions; language extensions; Namespaces;
namespaces; Policy; policy; programming languages;
Stability; stability; standardisation; X3J16",
thesaurus = "C language; Programming languages; Standardisation",
treatment = "G General Review; P Practical",
}
@Article{Stal:1993:GDA,
author = "M. Stal and U. Steinmuller",
title = "Generic dynamic arrays: integrating dynamic arrays
into {C++} templates",
journal = j-C-PLUS-PLUS-REPORT,
volume = "5",
number = "8",
pages = "30--35, 38",
month = oct,
year = "1993",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Dynamic arrays should be helpful in many situations
where scaffolding techniques once had to be applied.
They also provide some advantages in programmers who
are developing C++ libraries. The article focuses on
how to integrate dynamic arrays into C++ using
templates. An array is always an ordered collection of
elements. There is a distinction between homogeneous
arrays, where all array elements belong to the same
datatype, and heterogeneous arrays, where the elements
may have different types. The authors confine
themselves to homogeneous arrays, which turns out to be
no real limitation, since heterogeneous arrays can
always be modeled in C++ by using a common base class
for the elements (e.g. array of Object*). Additionally
they do not cover associative arrays or sparse arrays.
The arrays discussed use integral index values starting
with 0 to some limit without having any holes.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages); C6120 (File organisation)",
classification = "C6110J (Object-oriented programming); C6120 (File
organisation); C6140D (High level languages)",
keywords = "abstract data types; C language; C++; C++ libraries;
C++ templates; Generic dynamic arrays; generic dynamic
arrays; Homogeneous arrays; homogeneous arrays;
Integral index values; integral index values;
libraries; Object*; object-oriented languages;
object-oriented programming; Scaffolding; scaffolding",
thesaurus = "Abstract data types; C language; Object-oriented
languages; Object-oriented programming",
treatment = "P Practical",
}
@Article{Reed:1993:EPI,
author = "D. R. Reed",
title = "Exceptions: pragmatic issues with a new language
feature",
journal = j-C-PLUS-PLUS-REPORT,
volume = "5",
number = "8",
pages = "39--44",
month = oct,
year = "1993",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Deciding whether to use a new C++ feature is never
easy. Like all engineering decisions, there are
trade-offs to be made, and only you can decide which
ones you can afford. From his research, the author
found exception handling to be quite usable and looks
forward to using it in future projects. Currently,
however, the use of such a feature must be viewed as an
engineering trade-off. If cross-platform portability of
your source code is an important consideration, you may
want to wait a bit to use C++ exception handling. As
far as performance goes, it is not an issue for most
types of software development.",
acknowledgement = ack-nhfb,
classcodes = "C6140D (High level languages); C6110J (Object-oriented
programming); C6130 (Data handling techniques)",
classification = "C6110J (Object-oriented programming); C6130 (Data
handling techniques); C6140D (High level languages)",
keywords = "C language; C++ feature; Cross-platform portability;
cross-platform portability; Exception handling;
exception handling; object-oriented languages;
object-oriented programming; Software development;
software development; Source code; source code",
thesaurus = "C language; Exception handling; Object-oriented
languages; Object-oriented programming",
treatment = "P Practical",
}
@Article{Strickland:1993:OOD,
author = "H. Strickland",
title = "{ODMG}-93: the object database standard for {C++}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "5",
number = "8",
pages = "45--48",
month = oct,
year = "1993",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The ODMG standard describes a C++ binding to an object
database that not only defines some C++ interface
classes but outlines an approach for defining database
classes and manipulating persistent objects. The
article introduces the part of the ODMG standard that
defines a C++ binding to an object database. This C++
binding not only defines some C++ interface classes,
but it also describes an approach for using C++ to
define database classes and manipulate persistent
objects. The author creates an abbreviation ODMG/C++ to
refer to this base-line subset, and concentrates on
only that part of the standard. The interface in this
subset is largely based on the common subset of
existing products, so it is a `codify existing
practice' standard.",
acknowledgement = ack-nhfb,
classcodes = "C6160J (Object-oriented databases); C6140D (High level
languages)",
classification = "C6140D (High level languages); C6160J
(Object-oriented databases)",
keywords = "binding; C language; C++; C++ binding; C++ interface
classes; Database classes; database classes; languages;
Object database standard; object database standard;
object-oriented; object-oriented databases; ODMG-93;
ODMG/C++; Persistent objects; persistent objects;
standards",
thesaurus = "C language; Object-oriented databases; Object-oriented
languages; Standards",
treatment = "G General Review; P Practical",
}
@Article{Tichy:1994:GGA,
author = "W. F. Tichy and J. Heilig and F. {Newbery Paulisch}",
title = "A generative and generic approach to persistence",
journal = j-C-PLUS-PLUS-REPORT,
volume = "6",
number = "1",
pages = "22--33",
month = jan,
year = "1994",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "A persistence facility saves a program's volatile data
objects on permanent store for later use. In this
article, we propose a method that takes the drudgery
out of the load-process-save model. We demonstrate that
the persistence facility can be produced automatically
by a program generator. The generated routines are
split into type-initialization routines that are used
to record the information about the types used in the
application and generic load and save routines which
rely on this type information. This allows for a
flexible and efficient implementation of persistence as
well as a convenient user interface. To demonstrate the
feasibility of this approach, the persistence facility
described has been incorporated into PGen, a
persistence generator tool for C++. PGen has been
tested on several real-world applications to
demonstrate that the generated routines are comparable
in efficiency to manually written ones (in both time
and space).",
acknowledgement = ack-nhfb,
affiliation = "Karlsruhe Univ., Germany",
classcodes = "C6110J (Object-oriented programming); C6115
(Programming support)",
classification = "C6110J (Object-oriented programming); C6115
(Programming support)",
corpsource = "Karlsruhe Univ., Germany",
keywords = "automatic programming; C language; C++; Generative
approach; generative approach; generic routines;
Generic routines; interface; languages;
Load-process-save model; load-process-save model;
object-oriented; object-oriented programming; objects;
Persistence facility; persistence facility; Persistence
generator tool; persistence generator tool; PGen;
Program generator; program generator;
Type-initialization routines; type-initialization
routines; user; User interface; volatile data; Volatile
data objects",
thesaurus = "Automatic programming; C language; Object-oriented
languages; Object-oriented programming",
treatment = "P Practical",
}
@Article{Churchill:1994:ERS,
author = "S. Churchill",
title = "Exception recovery with smart pointers",
journal = j-C-PLUS-PLUS-REPORT,
volume = "6",
number = "1",
pages = "34--35, 38--42",
month = jan,
year = "1994",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The C++ exception handling feature is designed to
eliminate the time-consuming process of passing return
codes up the call stack when lower-level errors occur.
This article describes smart pointer mechanisms that
can be used to provide a number of valuable services.
Among these is the ability to recover dynamically
allocated memory after an exception occurs. The author
starts by taking a look at a common strategy for
reference counting dynamically allocated objects and
explains how this `ref counting' can be automated using
smart pointers. Then he looks at how the use of smart
pointers provides for the recovery of dynamically
allocated memory when an exception occurs.",
acknowledgement = ack-nhfb,
affiliation = "Fijitsu, Tokyo, Japan",
classcodes = "C6120 (File organisation); C6110J (Object-oriented
programming)",
classification = "C6110J (Object-oriented programming); C6120 (File
organisation)",
corpsource = "Fijitsu, Tokyo, Japan",
keywords = "C language; C++ exception handling feature; Call
stack; call stack; coding errors; collection; data
structures; dynamically allocated; Dynamically
allocated memory; Exception recovery; exception
recovery; garbage; Garbage collection; Lower-level
errors; lower-level errors; memory; Object oriented
programming; object oriented programming;
object-oriented; programming; recovery; Reference
counting; reference counting; Return codes; return
codes; Smart pointers; smart pointers; storage
allocation; storage management; system",
thesaurus = "C language; Coding errors; Data structures;
Object-oriented programming; Storage allocation;
Storage management; System recovery",
treatment = "P Practical",
}
@Article{Arjomandi:1994:CSC,
author = "E. Arjomandi and W. O'Farrell and I. Kalas",
title = "Concurrency support for {C++}: an overview",
journal = j-C-PLUS-PLUS-REPORT,
volume = "6",
number = "1",
pages = "44--50",
month = jan,
year = "1994",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "How do you handle concurrency? Whether through
language support or the use of libraries, the paradigms
of OOP and concurrent programming must work together.
In this article, we review and analyze some of the C++
based concurrent systems. Issues characterizing
concurrent object-oriented systems and techniques used
in adding concurrency to C++ are presented. We compare
concurrent extensions to C++, and concurrent libraries
for C++ where concurrency is kept outside of the
language.",
acknowledgement = ack-nhfb,
affiliation = "York Univ., North York, Ont., Canada",
classcodes = "C6150N (Distributed systems); C6140D (High level
languages); C6110J (Object-oriented programming)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages); C6150N (Distributed systems)",
corpsource = "York Univ., North York, Ont., Canada",
keywords = "C language; C++ based concurrent systems; concurrency
control; concurrent; Concurrent extensions; concurrent
extensions; Concurrent libraries; Concurrent
object-oriented systems; Language support; language
support; libraries; object-oriented languages;
object-oriented systems; subroutines",
thesaurus = "C language; Concurrency control; Object-oriented
languages; Subroutines",
treatment = "G General Review",
}
@Article{Martin:1994:PEO,
author = "R. Martin",
title = "A practical example of object-oriented analysis and
design",
journal = j-C-PLUS-PLUS-REPORT,
volume = "6",
number = "2",
pages = "18--23",
month = feb,
year = "1994",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Provides a case study which explores the topic of
object-oriented analysis and design. Although the
subjects of OOA and OOD are steeped in theory and
current controversy, the author bypasses this and
presents them from a pragmatic, how-to point of view.
There seems to be a great deal of discussion about the
merits of various object oriented languages. Some of
the participants in these discussions favor C++ as an
OOPL based on its nearness to C and its pragmatic
outlook. Others berate C++ as an ugly and incomplete
language because of its nearness to C and its pragmatic
outlook. The author makes a different point altogether:
the quality of an object-oriented application is
determined far more by the quality of its analysis and
design than by the features of the implementation
language. In his opinion, C++ offers features in
sufficient quantity to implement any object-oriented
design.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages)",
keywords = "C; C language; C++; Incomplete language; incomplete
language; methods; object; Object oriented languages;
object-; object-oriented; Object-oriented analysis;
object-oriented analysis; Object-oriented application
quality; Object-oriented design; object-oriented
design; object-oriented languages; object-oriented
programming; oriented application quality; oriented
languages",
thesaurus = "C language; Object-oriented languages; Object-oriented
methods; Object-oriented programming",
treatment = "P Practical",
}
@Article{Silva-Lepe:1994:RDC,
author = "I. Silva-Lepe and W. Hursch and G. Sullivan",
title = "A report on {Demeter C++}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "6",
number = "2",
pages = "24--30",
month = feb,
year = "1994",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Reports on Demeter/C++, an object-oriented software
development method featuring graphical description of
class structures and a high level language for the
definition of object behaviour. C++ programs developed
with Demeter become less dependent on the details of a
specific class structure and thus more adaptive to
change. The Demeter method is supported by a suite of
tools including a graphical user interface, a
consistency checker, C++ code generators, and a
run-time library of generic software. To alleviate the
problem of writing large amounts of mundane code,
Demeter/C++ provides tools for automatically generating
class declarations and member function definitions.
Automatic code generation is based on Demeter's
graphical notation. The author shows how to develop a
sample application using Demeter/C++ and how to adapt
the application to new requirements.",
acknowledgement = ack-nhfb,
affiliation = "Coll. of Comput. Sci., Northeastern Univ., Boston, MA,
USA",
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages); C6180G (Graphical user interfaces);
C6115 (Programming support)",
classification = "C6110J (Object-oriented programming); C6115
(Programming support); C6140D (High level languages);
C6180G (Graphical user interfaces)",
corpsource = "Coll. of Comput. Sci., Northeastern Univ., Boston, MA,
USA",
keywords = "Automatic code generation; automatic code generation;
automatic programming; C language; C++; checker; Class
declarations; class declarations; Class structures;
class structures; Code generators; code generators;
consistency; Consistency checker; Demeter C++; Demeter
method; Demeter/C++; development method; generic;
Generic software; Graphical description; graphical
description; Graphical notation; graphical notation;
graphical user; Graphical user interface; graphical
user interface; High level language; high level
language; interfaces; Member function definitions;
member function definitions; Object behaviour
definition; object behaviour definition; Object
oriented programming; object oriented programming;
object-oriented; object-oriented languages;
object-oriented software; Object-oriented software
development method; programming; Run-time library;
run-time library; software; software tools",
thesaurus = "Automatic programming; C language; Graphical user
interfaces; Object-oriented languages; Object-oriented
programming; Software tools",
treatment = "P Practical",
}
@Article{Havener:1994:CAS,
author = "C. L. Havener",
title = "A {C++} application story",
journal = j-C-PLUS-PLUS-REPORT,
volume = "6",
number = "2",
pages = "31--33",
month = feb,
year = "1994",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "C++ has been used at Epsilon Data Management for the
development of a general data warehouse system on the
Thinking Machines CM5 Connection Machine. Epsilon
creates data-based marketing solutions which often rely
on using large databases for decision support. This
type of database is often called a data warehouse.
Decision support queries require a pass over the entire
database because they take the form of finding all
customers who meet some requirement. We provide an
application story that describes our experiences, both
good and bad, with using C++.",
acknowledgement = ack-nhfb,
affiliation = "Epsilon Data Management Inc., Burlington, MA, USA",
classcodes = "C6110J (Object-oriented programming); C7170
(Marketing); C6140D (High level languages); C6160Z
(Other DBMS); C7102 (Decision support systems)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages); C6160Z (Other DBMS); C7102 (Decision
support systems); C7170 (Marketing)",
corpsource = "Epsilon Data Management Inc., Burlington, MA, USA",
keywords = "C language; C++; CM5; Connection Machine; Customers;
customers; Data warehouse; data warehouse; Data
warehouse system; data warehouse system; data-based;
Data-based marketing solutions; decision support;
Decision support queries; Decision support systems;
decision support systems; Epsilon Data Management;
Large databases; large databases; marketing data;
marketing solutions; Object oriented programming;
object oriented programming; object-oriented;
object-oriented languages; processing; programming;
query processing; systems; Thinking Machines; very
large databases",
thesaurus = "C language; Decision support systems; Marketing data
processing; Object-oriented languages; Object-oriented
programming; Query processing; Very large databases",
treatment = "A Application; P Practical",
}
@Article{Lajoie:1994:EHSa,
author = "J. Lajoie",
title = "Exception handling: supporting the runtime mechanism",
journal = j-C-PLUS-PLUS-REPORT,
volume = "6",
number = "3",
pages = "36--39, 42--43",
month = mar # "-" # apr,
year = "1994",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The C++ exception handling mechanism can be used to
communicate between two unrelated portions of a C++
application-one portion of the application can detect
an exceptional situation and communicate it to the
portion of the application that controls or
synchronizes the work underway. The author reviews some
of the language features provided in C++ to support
exception handling and the underlying mechanisms an
implementation must provide to support these features.
One understands better the behavior of the C++
exception handling features if one understands the work
happening behind the scenes-the work performed by the
compiler and during runtime to support C++ exception
handling.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages); C6150C (Compilers, interpreters and
other processors); C6150J (Operating systems); C6120
(File organisation); C6130 (Data handling techniques)",
classification = "C6110J (Object-oriented programming); C6120 (File
organisation); C6130 (Data handling techniques); C6140D
(High level languages); C6150C (Compilers, interpreters
and other processors); C6150J (Operating systems)",
keywords = "application; C++; C++ application; C++ exception
handling mechanism; Compiler; compiler; data
structures; exception handling; Exceptional situation;
exceptional situation; Language features; language
features; languages; object-oriented; program
compilers; Runtime mechanism; runtime mechanism;
Underlying mechanisms; underlying mechanisms",
thesaurus = "Data structures; Exception handling; Object-oriented
languages; Program compilers",
treatment = "P Practical",
}
@Article{vanLoon:1994:IXW,
author = "R. {van Loon}",
title = "Introducing the {X Window System}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "6",
number = "3",
pages = "45--47",
month = mar # "-" # apr,
year = "1994",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "A discussion is given on the X Window System, version
II and programming X in C++. The author looks at the
history of the X Window System or X and XII for short,
as well as its various components. No knowledge about X
or any other window system is assumed. The area of
graphics and window systems has always been the
playground of object-oriented programmers. A large
number of authors have used some sort of geometric
object-hierarchy in order to demonstrate
object-oriented concepts. Some of the topics presented,
such as the Xt/Intrinsics and Mota are only covered
briefly.",
acknowledgement = ack-nhfb,
classcodes = "C6180 (User interfaces); C6110J (Object-oriented
programming)C6140D (High level languages)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages); C6180 (User interfaces)",
keywords = "C++; concepts; geometric object-hierarchy; Geometric
object-hierarchy; Graphics; graphics; Mota;
object-oriented; Object-oriented concepts;
object-oriented languages; Object-oriented programmers;
object-oriented programming; programmers; software
packages; user interfaces; X Window System; XII;
Xt/Intrinsics",
thesaurus = "Object-oriented languages; Object-oriented
programming; Software packages; User interfaces",
treatment = "P Practical; R Product Review",
}
@Article{Schmidt:1994:DAN,
author = "D. Schmidt",
title = "A domain analysis of network daemon design
dimensions",
journal = j-C-PLUS-PLUS-REPORT,
volume = "6",
number = "3",
pages = "50--59",
month = mar # "-" # apr,
year = "1994",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Server daemons commonly provide clients with
communication-related services that resolve queries,
access file systems, manage routing tables, perform
local system services and integrate multiple remote
services. This article is part of a continuing series
that describes object oriented techniques that may be
used to simplify the development of reliable, robust
and extensible distributed applications. It presents an
object oriented domain analysis of key design decisions
for network server daemons.",
acknowledgement = ack-nhfb,
classcodes = "C6150N (Distributed systems); C6110J (Object-oriented
programming); C6150J (Operating systems); C5630
(Networking equipment)",
classification = "C5630 (Networking equipment); C6110J
(Object-oriented programming); C6150J (Operating
systems); C6150N (Distributed systems)",
keywords = "Clients; clients; Communication-related services;
communication-related services; distributed
applications; distributed processing; extensible;
Extensible distributed applications; File systems; file
systems; Local system services; local system services;
Multiple remote services; multiple remote services;
network; Network daemon design dimensions; network
daemon design dimensions; network operating systems;
Network server daemons; network server daemons; Object
oriented domain analysis; object oriented domain
analysis; Object oriented techniques; object oriented
techniques; object-oriented programming; Query
resolution; query resolution; Reliable applications;
reliable applications; Robust applications; robust
applications; Routing tables; routing tables; servers;
software reliability",
thesaurus = "Distributed processing; Network operating systems;
Network servers; Object-oriented programming; Software
reliability",
treatment = "P Practical",
}
@Article{Horstmann:1994:EIL,
author = "C. S. Horstmann",
title = "Extending the iostream library",
journal = j-C-PLUS-PLUS-REPORT,
volume = "6",
number = "4",
pages = "22--29",
month = may,
year = "1994",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The first release of C++ gave two libraries, complex.h
and stream.h, but many C programmers still use stdio.h
for input and output. Streams, however, are superior to
stdio because they are typesafe, and their
extensibility goes far beyond just adding new types to
the formatting layer. I show that the extensibility
goes far beyond the addition of new types to the
formatting layer. I added a manipulator to convert
printf formatting commands to their stream equivalents,
and I added a new stream class that displays output in
a debug window under Microsoft Windows, fully
supporting all features of the ostream class (including
the new format manipulator). Both additions require
very little code, but the programmer must know where to
hook into the streams framework. This is, of course,
characteristic of programming with frameworks.",
acknowledgement = ack-nhfb,
classcodes = "C6140D (High level languages); C6150G (Diagnostic,
testing, debugging and evaluating systems); C6115
(Programming support); C6110J (Object-oriented
programming)",
classification = "C6110J (Object-oriented programming); C6115
(Programming support); C6140D (High level languages);
C6150G (Diagnostic, testing, debugging and evaluating
systems)",
keywords = "Buffering; buffering; C language; C++; Complex.h;
complex.h; Debug window; debug window; Frameworks;
frameworks; Input; input; Iostream library; iostream
library; Manipulator; manipulator; Microsoft Windows;
object-oriented languages; Ostream class; ostream
class; Output; output; Printf formatting command
conversion; printf formatting command conversion;
program debugging; Stdio.h; stdio.h; Stream.h;
stream.h; subroutines",
thesaurus = "C language; Object-oriented languages; Program
debugging; Subroutines",
treatment = "P Practical",
}
@Article{Moudgill:1994:RM,
author = "M. Moudgill",
title = "Reverse-engineering manipulators",
journal = j-C-PLUS-PLUS-REPORT,
volume = "6",
number = "4",
pages = "30--33",
month = may,
year = "1994",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Normally, our interaction (as C++ programmers) with
the iostream library is confined to using the built-in
extraction (>>operator) and insertion (<<operator)
operators to read and write values, and to overloading
these operators to read and write user defined class
object. Occasionally, however, it becomes necessary to
use the iostream to do something other than read or
write a variable, such as set some iostream control
parameter. For example, we may wish to set the minimum
width of the next item to be printed. We can do this in
two ways. The first uses an explicit function call. The
other way is to use a manipulator to do it. Both of
these methods are illustrated. Clearly, manipulators
result in cleaner-looking and more compact code. Some
techniques for writing manipulators to replace explicit
function calls are outlined.",
acknowledgement = ack-nhfb,
affiliation = "Cornell Univ., Ithaca, NY, USA",
classcodes = "C6110J (Object-oriented programming); C6110B (Software
engineering techniques); C6140D (High level
languages)",
classification = "C6110B (Software engineering techniques); C6110J
(Object-oriented programming); C6140D (High level
languages)",
corpsource = "Cornell Univ., Ithaca, NY, USA",
keywords = "C language; C++ programmers; Explicit function call;
explicit function call; iostream; Iostream control
parameter; iostream control parameter; Iostream
library; item to be printed; library; manipulators;
Minimum width; minimum width; next; Next item to be
printed; object-oriented languages; Reverse-engineering
manipulators; reverse-engineering manipulators;
software engineering; subroutines; writing; Writing
manipulators",
thesaurus = "C language; Manipulators; Object-oriented languages;
Software engineering; Subroutines",
treatment = "P Practical",
}
@Article{Stal:1994:ITE,
author = "M. Stal and U. Steinmuller",
title = "Implementing a text editor using dynamic arrays",
journal = j-C-PLUS-PLUS-REPORT,
volume = "6",
number = "4",
pages = "34--39, 46",
month = may,
year = "1994",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The article demonstrates the usage of dynamic arrays
in a detailed manner. The best way to gain first-hand
experience in the advantages of a new container class
is to use it in the context of a real world
application. To check the suitability of this dynamic
array implementation for nontrivial applications, a
UNIX ed-like line editor has been developed. The
model-view-controller(MVC) design pattern was chosen as
the appropriate application framework for the project.
The main objective is to cover two different aspects
that are important when an editor is implemented: the
usage of dynamic arrays for implementing the text class
of the editor, and the MVC concept and its applications
to the special case of command-line driven editors.",
acknowledgement = ack-nhfb,
affiliation = "Siemens AG, Munich, Germany",
classcodes = "C6130D (Document processing techniques); C6150J
(Operating systems); C6110J (Object-oriented
programming)",
classification = "C6110J (Object-oriented programming); C6130D
(Document processing techniques); C6150J (Operating
systems)",
corpsource = "Siemens AG, Munich, Germany",
keywords = "application; C language; Command-line driven editors;
command-line driven editors; Container class; container
class; Dynamic arrays; dynamic arrays; editor;
Model-view-controller design pattern;
model-view-controller design pattern; Nontrivial
applications; nontrivial applications; object-oriented
programming; real world; Real world application; Text
class; text class; text editing; Text editor; text
editor; Unix; UNIX ed-like line; UNIX ed-like line
editor",
thesaurus = "C language; Object-oriented programming; Text editing;
Unix",
treatment = "A Application; P Practical",
}
@Article{Lajoie:1994:EHSb,
author = "J. Lajoie",
title = "Exception handling: supporting first-class objects",
journal = j-C-PLUS-PLUS-REPORT,
volume = "6",
number = "5",
pages = "35--39",
month = jun,
year = "1994",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Behind the scenes, library implementors can build
exception hierarchies, organizing exceptions into
groups or layers, where every layer becomes more
specific. This article reviews some of the language
features provided in C++ to support exception handling
as well as some of the underlying mechanisms necessary
to support these features.",
acknowledgement = ack-nhfb,
affiliation = "IBM Canada Lab., Canada",
classcodes = "C6110J (Object-oriented programming); C6130 (Data
handling techniques); C6140D (High level languages)",
classification = "C6110J (Object-oriented programming); C6130 (Data
handling techniques); C6140D (High level languages)",
corpsource = "IBM Canada Lab., Canada",
keywords = "C language; C++; exception; Exception handling;
exception handling; Exception hierarchies; First-class
objects; first-class objects; hierarchies; Language
features; language features; library implementors;
Library implementors; Object oriented programming;
object oriented programming; object-oriented languages;
object-oriented programming",
thesaurus = "C language; Exception handling; Object-oriented
languages; Object-oriented programming",
treatment = "P Practical",
}
@Article{Coplien:1994:GPL,
author = "J. O. Coplien",
title = "Generative pattern languages: an emerging direction of
software design",
journal = j-C-PLUS-PLUS-REPORT,
volume = "6",
number = "6",
pages = "18--22, 66--67",
month = jul # "-" # aug,
year = "1994",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "A generative pattern for software is like a
dressmaker's pattern: we use it to make something. The
object paradigm has reshaped the design landscape in
recent years. Many hold object-oriented techniques as
major advances in analysis and design because a single
set of abstractions applies equally well to
architecture, design, and programming. Yet a serious
difficulty with the object paradigm is finding the
right objects in the first place. Finding relationships
between objects, and letting object relationships shape
the choice of objects themselves, is perhaps an even
greater difficulty with object techniques. If we
discover, understand, and capture the patterns in a
given domain, we can package them as tools to make
inexpert designers more effective. Patterns offer broad
new insights and techniques that enrich the context in
which the designer works. Ongoing work on generative
pattern languages is being done by members of the
Hillside Patterns Group, whose members bring
perspectives from leading companies and industry
consultants in the application of object-oriented
techniques. The paper summarizes the state of software
design patterns at this early stage of exploration.",
acknowledgement = ack-nhfb,
affiliation = "Software Prod. Res. Dept., AT and T Bell Labs.,
Naperville, IL, USA",
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages)",
corpsource = "Software Prod. Res. Dept., AT\&T Bell Labs.,
Naperville, IL, USA",
keywords = "Abstractions; abstractions; Generative pattern
languages; generative pattern languages; object; Object
paradigm; Object relationships; object relationships;
object-; object-oriented languages; object-oriented
methods; Object-oriented techniques; object-oriented
techniques; oriented programming; paradigm;
Programming; programming; Software design; software
design; Software design patterns; software design
patterns",
thesaurus = "Object-oriented languages; Object-oriented methods;
Object-oriented programming",
treatment = "P Practical",
}
@Article{Robie:1994:EHO,
author = "J. Robie",
title = "Event handling in object-oriented databases",
journal = j-C-PLUS-PLUS-REPORT,
volume = "6",
number = "6",
pages = "24--27",
month = jul # "-" # aug,
year = "1994",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Event handling provides a convenient way to deal with
some of the everyday problems that arise in database
programming. However, it is not a traditional paradigm
for database programming, and it is currently available
only in a very few object-oriented databases. Many
experienced database programmers have never even
thought of event handling as a database paradigm. I
start by exploring the original event handling
paradigm, which was designed for user interfaces. I
then show how this paradigm can be used in object
oriented databases and explore the relationship between
event handling and distributed objects. Examples are
based on the event handling implemented in POET, an OO
database system.",
acknowledgement = ack-nhfb,
affiliation = "POET Software, Berlin, Germany",
classcodes = "C6160J (Object-oriented databases); C6110 (Systems
analysis and programming)",
classification = "C6110 (Systems analysis and programming); C6160J
(Object-oriented databases)",
corpsource = "POET Software, Berlin, Germany",
keywords = "database; Database programmers; database programmers;
Database programming; Distributed objects; distributed
objects; Event handling; event handling;
Object-oriented databases; object-oriented databases;
POET; programming; User interfaces; user interfaces",
thesaurus = "Object-oriented databases; Programming; User
interfaces",
treatment = "P Practical",
}
@Article{Schmidt:1994:CSC,
author = "D. C. Schmidt",
title = "A case study of {C++} design evolution",
journal = j-C-PLUS-PLUS-REPORT,
volume = "6",
number = "6",
pages = "28--36",
month = jul # "-" # aug,
year = "1994",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "In an effort to capture the dynamics of C++ class
design evolution, the article illustrates the process
by which object-oriented techniques and C++ idioms were
incrementally applied to solve a relatively small, yet
surprisingly subtle problem. This problem arose during
the development of a family of concurrent distributed
applications that execute efficiently on uniprocessor
and multiprocessor platforms. This article focuses on
the steps involved in generalizing from existing code
by using templates and overloading to transparently
parameterize synchronization mechanisms into a
concurrent application. Some of the infrastructure code
is based on components in the freely available ADAPTIVE
Service eXecutive (ASX) framework.",
acknowledgement = ack-nhfb,
affiliation = "California Univ., Irvine, CA, USA",
classcodes = "C6140D (High level languages); C6110J (Object-oriented
programming)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages)",
corpsource = "California Univ., Irvine, CA, USA",
keywords = "ADAPTIVE; ADAPTIVE Service Executive; ASX framework;
C++ design evolution; concurrent; Concurrent
distributed applications; distributed applications;
distributed processing; Infrastructure code;
infrastructure code; Multiprocessor platform;
multiprocessor platform; object oriented; Object
oriented programming; object-; object-oriented
languages; Object-oriented techniques; object-oriented
techniques; oriented programming; Overloading;
overloading; programming; Service Executive;
synchronisation; Synchronization mechanisms;
synchronization mechanisms; Templates; templates;
Uniprocessor platform; uniprocessor platform",
thesaurus = "Distributed processing; Object-oriented languages;
Object-oriented programming; Synchronisation",
treatment = "P Practical",
}
@Article{Vinoski:1994:MCI,
author = "S. Vinoski",
title = "Mapping {CORBA IDL} into {C++}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "6",
number = "7",
pages = "20--23, 55",
month = sep,
year = "1994",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The Common Object Request Broker Architecture (CORBA)
specification, produced by the Object Management Group
(OMG), defines a flexible framework upon which
distributed object-oriented applications can be built.
A key component of CORBA is its Interface Definition
Language (IDL), used to describe object interfaces and
specify the services they provide. IDL is a declarative
language that provides basic data types, constructed
data types, and template data types. These are used in
operation declarations to define argument types and
return types. In turn, operations are used in interface
declarations to specify the services provided by
objects. Before applications can be written to use
objects that have been specified in IDL, the IDL must
be translated into a `real' programming language. Each
programming language requires a different language
mapping that specifies how the various IDL declarations
are translated into it. Currently, the CORBA 1.2
specification describes only how IDL is mapped into the
C language. In December 1992, the OMG issued a request
for proposals for a C++ language mapping. This article
focuses on what appears to be the most controversial
issue facing those of us who are working towards a
standard CORBA C++ mapping: how IDL object references
are best mapped into C++.",
acknowledgement = ack-nhfb,
classcodes = "C6140D (High level languages); C6110J (Object-oriented
programming); C6110F (Formal methods)",
classification = "C6110F (Formal methods); C6110J (Object-oriented
programming); C6140D (High level languages)",
keywords = "Argument types; argument types; Basic data types;
basic data types; C language; C++ language mapping;
Common Object Request Broker Architecture; Constructed
data types; constructed data types; CORBA 1.2; CORBA
1.2 specification; CORBA IDL; data structures;
declarations; Declarative language; declarative
language; Distributed object-oriented applications;
distributed object-oriented applications; Flexible
framework; flexible framework; IDL object references;
interface; Interface declarations; Interface Definition
Language; interfaces; Management Group; object; Object;
Object interfaces; Object Management Group; Object
service specification; object service specification;
object-oriented languages; operation; Operation
declarations; Return types; return types;
specification; specification languages; standards;
Template data types; template data types",
thesaurus = "C language; Data structures; Object-oriented
languages; Specification languages; Standards",
treatment = "G General Review; P Practical",
}
@Article{Crawford:1994:RP,
author = "J. Crawford",
title = "Runtime parameterization. 1",
journal = j-C-PLUS-PLUS-REPORT,
volume = "6",
number = "7",
pages = "24--29",
month = sep,
year = "1994",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "It's a pity about the <generic.h> macros. They were
such a cunningly fashioned means of parameterizing
generic types that one almost half regrets their
obsolescence. But only half. Templates are such a
tidier way of achieving compile-time parameterization
that the appetite is whetted for a similar mechanism
that will delay the choice of the parameter until
run-time. In this article, I sketch a scenario in which
run-time parameterization would suit our needs better
than the compile-time variety.",
acknowledgement = ack-nhfb,
affiliation = "Dept. of Comput. Studies, Inst. of Technol., Aukland,
New Zealand",
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages)",
corpsource = "Dept. of Comput. Studies, Inst. of Technol., Aukland,
New Zealand",
keywords = "C language; C++ programming; compile-time;
Compile-time parameterization; object-oriented
programming; Parameter selection; parameter selection;
parameterization; Run-time parameterization; run-time
parameterization; Templates; templates",
thesaurus = "C language; Object-oriented programming",
treatment = "P Practical",
}
@Article{Vilot:1994:IST,
author = "M. J. Vilot",
title = "An introduction to the {Standard Template Library}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "6",
number = "8",
pages = "22--29, 35",
month = oct,
year = "1994",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Developed at Hewlett--Packard, the Standard Template
Library (STL) contains general-purpose mechanisms,
using C++'s templates for component parameterization. A
notable aspect of this library is that it focuses
primarily on algorithms-once thought to be the
exclusive province of FORTRAN subroutine libraries.
This article focuses on using STL, rather than on
presenting a comprehensive treatment of its internal
technical details. The first section provides an
overview of the library. The second section provides a
series of C++ code examples that illustrate various
aspects of using the library's `algorithm-oriented
generic software' approach. Finally, the last section
concludes with a more detailed overview of the library.
It can be used as a roadmap to the detailed reference
material.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages)",
keywords = "algorithm-oriented generic software;
Algorithm-oriented generic software; C language; C++
code; C++ templates; component parameterization;
Component parameterization; general-purpose;
General-purpose mechanisms; Hewlett--Packard;
mechanisms; object-oriented programming; software
libraries; Standard Template Library; STL",
thesaurus = "C language; Object-oriented programming; Software
libraries",
treatment = "P Practical",
}
@Article{Stroustrup:1994:MVF,
author = "B. Stroustrup",
title = "Making a vector fit for a standard",
journal = j-C-PLUS-PLUS-REPORT,
volume = "6",
number = "8",
pages = "30--34",
month = oct,
year = "1994",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "An important detail of the design of a vector template
class is discussed: how to generalize a vector in such
a way that it can be used conveniently with a variety
of memory models. This vector from A. Stepanov and M.
Lee's (1994) Standard Template Library (STL) is part of
a large, systematic, clean, formally sound,
comprehensible, elegant and efficient framework. The
presentation progresses through a series of versions of
the vector class, from the most obvious to the vector
from the STL library, which is part of the C++
standard. Each example presents a problem, a solution
to that problem, and notes that the simplest and most
common uses of the vector class remain unchanged under
the various generalizations.",
acknowledgement = ack-nhfb,
classcodes = "C6140D (High level languages); C6110J (Object-oriented
programming); C6120 (File organisation)",
classification = "C6110J (Object-oriented programming); C6120 (File
organisation); C6140D (High level languages)",
keywords = "abstract data types; C language; C++ standard;
Generalizations; generalizations; Memory models; memory
models; object-oriented languages; software libraries;
Standard Template Library; standards; STL; Vector
template class; vector template class",
thesaurus = "Abstract data types; C language; Object-oriented
languages; Software libraries; Standards",
treatment = "P Practical",
}
@Article{Davis:1994:ACC,
author = "S. R. Davis",
title = "Armor cladding {C++} classes",
journal = j-C-PLUS-PLUS-REPORT,
volume = "6",
number = "8",
pages = "36--39, 41",
month = oct,
year = "1994",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Bugs exist in any nontrivial program. We must protect
ourselves against them. The small extra effort required
to build in test code to detect and report errors is
repaid many times over during debugging and testing. A
good place to add such checks are at the interfaces
between a class and the application. The principle of
division of labor says that a class should be
responsible for its own welfare. This includes making
the class resistant to illegal input. I examine a few
techniques for making classes resistant to abuse. The
checks presented are for debugging purposes only. The
goal is not to process garbage input, only to recognize
and flag it to the programmer as clearly as possible.
While the techniques mentioned in this article cannot
detect all errors, they can detect a large class of
errors quickly and efficiently, greatly reducing the
amount of effort spent in the debugging and testing
phase, and increasing the quality of the final
product.",
acknowledgement = ack-nhfb,
affiliation = "E-Systems, Greenville, TX, USA",
classcodes = "C6110J (Object-oriented programming); C6150G
(Diagnostic, testing, debugging and evaluating
systems)",
classification = "C6110J (Object-oriented programming); C6150G
(Diagnostic, testing, debugging and evaluating
systems)",
corpsource = "E-Systems, Greenville, TX, USA",
keywords = "C language; C++ classes; class-application;
Class-application interfaces; classes; Division of
labour; division of labour; Error detection; error
detection; Error reporting; error reporting; Garbage
input flagging; garbage input flagging; Illegal input;
illegal input; interfaces; object-oriented programming;
Program debugging; program debugging; Program testing;
program testing; resistant; Resistant classes; Software
quality; software quality; Test code; test code",
thesaurus = "C language; Object-oriented programming; Program
debugging; Program testing; Software quality",
treatment = "P Practical",
}
@Article{Speh:1995:CWW,
author = "M. Speh and C. Dinnell",
title = "{C++} and the {World Wide Web}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "7",
number = "1",
pages = "18--23",
month = jan,
year = "1995",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Since it joined the WWW in early 1993, the C++ Virtual
library has evolved into a huge catalogue of C++
documents. The article deals briefly with getting on
the Web, and discusses information resources of
particular interest to the C++ users' community. At the
end, you should have a rough idea of what's waiting for
you out there on the Web. Even more importantly, you
will know how you can contribute to the Web yourself
either as a lone C++ programmer or as a software
company, and how you can use it as a sophisticated tool
for teaching and learning C++. Only a minimum of
technical information is necessary to get to the Web
and use it effectively. The World Wide Web is a wide
area hypermedia information retrieval initiative aiming
to give universal access to a large universe of
documents.",
acknowledgement = ack-nhfb,
classcodes = "B6210L (Computer communications); C7250N (Front end
systems for online searching); C5620W (Other computer
networks); C7210 (Information services and centres);
C6140D (High level languages); C6110J (Object-oriented
programming)",
classification = "B6210L (Computer communications); C5620W (Other
computer networks); C6110J (Object-oriented
programming); C6140D (High level languages); C7210
(Information services and centres); C7250N (Front end
systems for online searching)",
keywords = "C language; C++ documents; C++ programmer; C++ user
community; C++ Virtual library; front-ends; Information
resources; information resources; Internet;
object-oriented languages; online; retrieval; Software
company; software company; Teaching; teaching;
Universal access; universal access; wide area
hypermedia information; Wide area hypermedia
information retrieval; World Wide Web; WWW",
thesaurus = "C language; Internet; Object-oriented languages;
Online front-ends",
treatment = "P Practical",
}
@Article{Flanagin:1995:DIC,
author = "G. Flanagin and N. Rimmer",
title = "Doing it ({C++} software reuse project)",
journal = j-C-PLUS-PLUS-REPORT,
volume = "7",
number = "1",
pages = "24--28",
month = jan,
year = "1995",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "We discuss a small software project centered around
the construction and use of reusable software
components at an introductory scale. Starting with bare
code fragments, we assembled a small class library
suitable for use in other parts of our company. As a by
product of this pilot project, we were able to define
several levels of reuse, and thereby provide a valuable
vocabulary for discussing reusable components. These
results imply that reuse is indeed doable on an
incremental basis. We found that if reuse is a goal at
the beginning, it is attainable. We hope that readers
will be able to put these findings to good use in
development and project planning.",
acknowledgement = ack-nhfb,
affiliation = "Thuridion, Scotts Valley, CA, USA",
classcodes = "C6110B (Software engineering techniques); C6140D (High
level languages); C6110J (Object-oriented
programming)",
classification = "C6110B (Software engineering techniques); C6110J
(Object-oriented programming); C6140D (High level
languages)",
corpsource = "Thuridion, Scotts Valley, CA, USA",
keywords = "C language; C++ software reuse project; Code
fragments; code fragments; object-oriented languages;
project management; Project planning; project planning;
reusable; Reusable software components; Small class
library; small class library; Small software project;
small software project; software components; software
reusability",
thesaurus = "C language; Object-oriented languages; Project
management; Software reusability",
treatment = "P Practical",
}
@Article{Carroll:1995:TIC,
author = "M. Carroll and M. Ellis",
title = "Tradeoffs of interface classes",
journal = j-C-PLUS-PLUS-REPORT,
volume = "7",
number = "1",
pages = "29--32",
month = jan,
year = "1995",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "We discuss the tradeoffs of C++ interface classes and
inheritance hierarchies built with interface
classes-interfaced hierarchies. We also weigh the
advantages and disadvantages of providing object
factories with interfaced hierarchies.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages); C6120 (File organisation)",
classification = "C6110J (Object-oriented programming); C6120 (File
organisation); C6140D (High level languages)",
keywords = "C language; C++ interface classes; hierarchies;
inheritance; Inheritance hierarchies; inheritance
hierarchies; interfaced; Interfaced hierarchies; Object
factories; object factories; object-; object-oriented
languages; oriented programming; software libraries",
thesaurus = "C language; Inheritance; Object-oriented languages;
Object-oriented programming; Software libraries",
treatment = "P Practical",
}
@Article{Barton:1995:DA,
author = "J. J. Barton and L. R. Nackman",
title = "Dimensional analysis",
journal = j-C-PLUS-PLUS-REPORT,
volume = "7",
number = "1",
pages = "39--40, 42--43",
month = jan,
year = "1995",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Dimensional analysis was adopted for hand computation
of physical formulas for the same reason that type
checking was added to computer programming languages:
to catch errors as early as possible. Computing with
dimensional analysis is simply a matter of using the
appropriate data types in computations and letting the
C++ type system do the checking. Function templates
returning types computed from the argument types make
the construction of dimensional analysis data types
especially easy.",
acknowledgement = ack-nhfb,
affiliation = "IBM Thomas J. Watson Res. Center, Yorktown Heights,
NY, USA",
classcodes = "C7310 (Mathematics computing); C6140D (High level
languages); C6110J (Object-oriented programming); C6120
(File organisation)",
classification = "C6110J (Object-oriented programming); C6120 (File
organisation); C6140D (High level languages); C7310
(Mathematics computing)",
corpsource = "IBM Thomas J. Watson Res. Center, Yorktown Heights,
NY, USA",
keywords = "abstract data types; argument; Argument types; C
language; C++; C++ type system; Data types; data types;
Dimensional analysis; dimensional analysis; Function
templates; function templates; mathematics computing;
object-oriented languages; object-oriented programming;
Physical formulas; physical formulas; Type checking;
type checking; type system; types",
thesaurus = "Abstract data types; C language; Mathematics
computing; Object-oriented languages; Object-oriented
programming",
treatment = "P Practical",
}
@Article{Horstmann:1995:ODT,
author = "C. S. Horstmann",
title = "{OO} design tools with {C++} code generation",
journal = j-C-PLUS-PLUS-REPORT,
volume = "7",
number = "1",
pages = "56--58, 60--64",
month = jan,
year = "1995",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "I focus on the aspect of the various object-oriented
design methodologies that seem useful and
noncontroversial: capture and diagramming of key
classes, class properties and class relationships. My
particular concern is how these activities integrate
with ongoing code development.",
acknowledgement = ack-nhfb,
affiliation = "Dept. of Math. and Comput. Sci., San Jose State Univ.,
CA, USA",
classcodes = "C6110J (Object-oriented programming); C6110F (Formal
methods)C6120 (File organisation)",
classification = "C6110F (Formal methods); C6110J (Object-oriented
programming); C6120 (File organisation)",
corpsource = "Dept. of Math. and Comput. Sci., San Jose State Univ.,
CA, USA",
keywords = "abstract data types; C language; C++ code generation;
class; Class capture; class capture; Class diagramming;
class diagramming; Class properties; Class
relationships; class relationships; Code development;
code development; methodologies; object-oriented
design; Object-oriented design methodologies;
object-oriented languages; object-oriented methods;
object-oriented programming; OO design tools;
properties",
thesaurus = "Abstract data types; C language; Object-oriented
languages; Object-oriented methods; Object-oriented
programming",
treatment = "P Practical",
}
@Article{Vilot:1995:CSL,
author = "M. J. Vilot",
title = "The {C++} standard library",
journal = j-C-PLUS-PLUS-REPORT,
volume = "7",
number = "2",
pages = "28--34",
month = feb,
year = "1995",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "In March 1995, the C++ standardization effort will
enter its sixth year. Although progress on the
definition of Standard C++ may appear to be
frustratingly slow, the pace of any standardization
effort is deliberate. In this case, it has provided
interested members of the C++ community with the time
to consider, debate, and anticipate the effects the
eventual Standard will have on the language and its
users. The article presents an overview of the contents
of the C++ Standard Library. The description of this
library is based on the current Working Paper for the
ANSI XJ16 (ISO WG21) committee, and is therefore
subject to change. However, the basic scope and nature
of the components in the library are well
established.",
acknowledgement = ack-nhfb,
classcodes = "C6115 (Programming support); C6110J (Object-oriented
programming); C6140D (High level languages)",
classification = "C6110J (Object-oriented programming); C6115
(Programming support); C6140D (High level languages)",
keywords = "ANSI XJ16; C language; C++; C++ community; C++
standard library; C++ standardization effort; ISO; ISO
WG21; object-oriented languages; software libraries;
software standards; Standard; Standard C++;
Standardization effort; standardization effort; WG21",
thesaurus = "C language; Object-oriented languages; Software
libraries; Software standards",
treatment = "P Practical",
}
@Article{Remba:1995:SCG,
author = "D. Remba",
title = "A survey of the computer generated imagery landscape",
journal = j-C-PLUS-PLUS-REPORT,
volume = "7",
number = "2",
pages = "36--41",
month = feb,
year = "1995",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The field of computer graphics truly has a limitless
horizon. The applications and content that rely on CGI
(computer generated imagery) techniques are becoming
ubiquitous. Multimedia and CD-ROM technology have
provided yet another outlet for CGI based images and
animations in the form of games, educational software,
and other yet to be discovered applications. The
successful CD-ROM based Myst game exploration
environment is an example of a new hybrid application.
This is a totally synthetic 3D environment with a story
behind it, which you explore and discover at your own
pace. There is no element of reflex or timing in this
game, but rather an ambiance and an engaging virtual
world.",
acknowledgement = ack-nhfb,
classcodes = "C6130B (Graphics techniques); C7820 (Humanities
computing); C6130M (Multimedia); C6180 (User
interfaces); C6160S (Spatial and pictorial databases);
C7830D (Computer games)",
classification = "C6130B (Graphics techniques); C6130M (Multimedia);
C6160S (Spatial and pictorial databases); C6180 (User
interfaces); C7820 (Humanities computing); C7830D
(Computer games)",
keywords = "CD-ROM technology; CD-ROMs; CGI based images; computer
animation; computer games; Computer generated imagery
landscape; computer generated imagery landscape;
Computer graphics; computer graphics; computing;
Educational software; educational software; Games;
games; Hybrid application; hybrid application;
Multimedia; multimedia; Myst game exploration
environment; Synthetic 3D environment; synthetic 3D
environment; virtual reality; Virtual world; virtual
world",
thesaurus = "CD-ROMs; Computer animation; Computer games;
Multimedia computing; Virtual reality",
treatment = "P Practical",
}
@Article{Hickey:1995:CCU,
author = "R. Hickey",
title = "Callbacks in {C++} using template functors",
journal = j-C-PLUS-PLUS-REPORT,
volume = "7",
number = "2",
pages = "42--50",
month = feb,
year = "1995",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "One of the many promises of object oriented
programming is that it will allow for plug and play
software design with reusable components. Designers
will pull objects from their library `shelves' and hook
them together to make software. In C++, this hooking
together of components can be tricky, particularly if
they are separately designed. We are still a long way
from interoperable libraries and application
components. Callbacks provide a mechanism whereby
independently developed objects may be connected
together. They are vital for plug and play programming,
since the likelihood of Vendor A implementing their
library in terms of Vendor B classes, or your home
brewed classes, is nil. Callbacks are in wide use;
however, current implementations differ and most suffer
from shortcomings, not the least of which is their lack
of generality. The article describes what callbacks
are, how they are used, and the criteria for a good
callback mechanism. It summarizes current callback
methods and their weaknesses. It then describes a
flexible, powerful, and easy to use callback technique
based on template functors-objects that behave like
functions.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages); C6110B (Software engineering
techniques)",
classification = "C6110B (Software engineering techniques); C6110J
(Object-oriented programming); C6140D (High level
languages)",
keywords = "C language; C++ callbacks; Callback mechanism;
callback mechanism; Callback methods; callback methods;
Object oriented programming; object oriented
programming; object-oriented; object-oriented
languages; play programming; plug and; Plug and play
programming; programming; Reusable components; reusable
components; software portability; software reusability;
Template functors; template functors",
thesaurus = "C language; Object-oriented languages; Object-oriented
programming; Software portability; Software
reusability",
treatment = "P Practical",
}
@Article{Kontogiorgos:1995:CTA,
author = "T. Kontogiorgos and M. Kim",
title = "A {C++} template-based application architecture",
journal = j-C-PLUS-PLUS-REPORT,
volume = "7",
number = "2",
pages = "51--56, 58",
month = feb,
year = "1995",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Tapar is an application architecture for building
complex IS applications using C++. It provides an
architecture for the following: persistent storage of
C++ objects on a relational database; compile time type
checked interface to the persistent storage and value
management for application data types; memory
management of C++ objects; mapping between object and
relational models. Persistent storage of C++ objects on
a relational database allows applications developed in
Tapar to leverage the mature relational database
technology. There are two issues to be considered:
object (logical) model to physical model mapping; and
transaction control. The application data type value
management addresses the issues of value validation,
default value generation, and compile time protection
from possibly dangerous assignments. The C++ object
memory management functionality ensures that only one
instance of a persistent object is kept in memory and
is properly shared. Tapar does not use any facilities
other than those provided by the C++ language and
simple macro expansions. It maintains the C++ data
model of static name resolutions thereby avoiding any
sort of run time symbolic manipulations. We describe
the three layers of Tapar. These are the object layer,
the process layer and persistence.",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6120 (File
organisation); C6140D (High level languages)",
classification = "C6110J (Object-oriented programming); C6120 (File
organisation); C6140D (High level languages)",
keywords = "abstract data types; Application data type value
management; application data type value management;
Application data types; application data types; C
language; C++ data model; C++ object memory management
functionality; C++ objects; C++ template-based
application architecture; compile time; Compile time
protection; Compile time type checked interface;
compile time type checked interface; complex; Complex
IS applications; database; Default value generation;
default value generation; IS applications; management;
Memory management; memory management; object-oriented
languages; object-oriented programming; Persistent
object; persistent object; Persistent storage;
persistent storage; protection; relational; Relational
database; Run time symbolic manipulations; run time
symbolic manipulations; Static name resolutions; static
name resolutions; storage management; Tapar;
Transaction control; transaction control; value; Value
management; Value validation; value validation",
thesaurus = "Abstract data types; C language; Object-oriented
languages; Object-oriented programming; Storage
management",
treatment = "P Practical",
}
@Article{Vinoski:1995:DEM,
author = "S. Vinoski and D. Schmidt",
title = "{DOC} by example: modelling distributed object
applications",
journal = j-C-PLUS-PLUS-REPORT,
volume = "7",
number = "2",
pages = "64--68",
month = feb,
year = "1995",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "We present an extended example that compares and
contrasts different ways of using C++ and DOC to solve
a representative distributed programming application.
Our example centers around a financial services system,
with a distributed architecture. We focus on a stock
trading application that enables investment brokers to
query stock prices, as well as buy shares of stock. The
quote server that maintains the current stock prices is
physically remote from brokers, who work in various
geographically distributed sites. Therefore, our
application must be developed to work efficiently,
robustly, and securely across a variety of wide area
networks (WAN) and local area (LAN) networks. We
selected the stock trading application since the issues
involved in analyzing, designing, and implementing it
are remarkably similar to many other types of
distributed applications.",
acknowledgement = ack-nhfb,
classcodes = "C7120 (Financial computing); C6110J (Object-oriented
programming); C6110P (Parallel programming); C6150N
(Distributed systems software); C6140D (High level
languages)",
classification = "C6110J (Object-oriented programming); C6110P
(Parallel programming); C6140D (High level languages);
C6150N (Distributed systems software); C7120 (Financial
computing)",
keywords = "C language; C++; Distributed architecture; distributed
architecture; Distributed object application modelling;
distributed object application modelling; DOC;
Financial services system; financial services system;
Geographically distributed sites; geographically
distributed sites; Investment brokers; investment
brokers; Local area networks; local area networks;
networks; object-oriented; object-oriented languages;
parallel programming; programming; quote; Quote server;
Representative distributed programming application;
representative distributed programming application;
server; stock; stock markets; Stock prices; stock
prices; Stock trading application; trading application;
WAN; wide area; Wide area networks",
thesaurus = "C language; Object-oriented languages; Object-oriented
programming; Parallel programming; Stock markets",
treatment = "P Practical",
}
@Article{Ellis:1995:TE,
author = "M. Ellis and M. Carroll",
title = "Tradeoffs of exceptions",
journal = j-C-PLUS-PLUS-REPORT,
volume = "7",
number = "3",
pages = "12, 14, 16",
month = mar # "-" # apr,
year = "1995",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The introduction of the exception handling feature
into the C++ language comes with tradeoffs. The most
significant advantage is that exception handling allows
C++ code to handle errors and other exceptional
conditions elegantly. On the other hand, the presence
of exceptions in C++ necessitates that special care be
taken to ensure that code is exception safe. Classes
must be designed so objects are not rendered
inconsistent when an exception is thrown. Libraries
must be designed to avoid resource leaks and other ill
effects of the nonlocal flow of control caused by an
exception having been thrown.",
acknowledgement = ack-nhfb,
classcodes = "C6140D (High level languages); C6110J (Object-oriented
programming)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages)",
keywords = "C language; C++ language; conditions; exception
handling; Exception handling feature; exception
handling feature; exceptional; Exceptional conditions;
Nonlocal flow; nonlocal flow; object-oriented
languages; Resource leaks; resource leaks",
thesaurus = "C language; Exception handling; Object-oriented
languages",
treatment = "T Theoretical or Mathematical",
}
@Article{Meyers:1995:BOI,
author = "S. Meyers",
title = "Bounding object instantiations. {I}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "7",
number = "3",
pages = "18--22",
month = mar # "-" # apr,
year = "1995",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Using C++, suppose you've only got one printer in your
system, so you'd like to somehow limit the number of
printer objects to one. Or you've only got 16 file
descriptors you can hand out, so you've got to make
sure there are never more than that many file
descriptor objects in existence. How can you do such
things? How can you limit the number of objects?.",
acknowledgement = ack-nhfb,
classcodes = "C6140D (High level languages); C6110J (Object-oriented
programming)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages)",
keywords = "C language; C++; descriptor object; file; File
descriptor object; Object instantiations bounding;
object instantiations bounding; object-oriented
languages; Printer objects; printer objects",
thesaurus = "C language; Object-oriented languages",
treatment = "T Theoretical or Mathematical",
}
@Article{Jordan:1995:IOO,
author = "D. Jordan",
title = "Identifying {ODMG} objects",
journal = j-C-PLUS-PLUS-REPORT,
volume = "7",
number = "3",
pages = "24, 26--27",
month = mar # "-" # apr,
year = "1995",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Object identifiers, their use as database references
and their implementation, are among the fundamental
components within the architecture of an object
database. In evaluating the performance of an object
database, for example, the efficiency of mapping from
object identifiers to the actual object is one of the
primary factors investigated. Each of the object
database vendors takes a different approach to
implementing this mapping. This article will discuss
entity and object identifiers, contrast their use in
relational and object oriented databases, and discuss
their specification within the ODMG standard. When
applications are designed and developed, the entities
modelled in the problem domain usually have identifiers
associated with them to uniquely reference them.
Sometimes an entity will have a natural, real world
name associated with it and this name often becomes the
identifier used in the software model. In other cases
there is no name in the real world so an identifier is
concocted using a sequence number generation facility
or some other similar mechanism.",
acknowledgement = ack-nhfb,
affiliation = "AT and T Bell Labs., USA",
classcodes = "C6160J (Object-oriented databases); C6110J
(Object-oriented programming); C6140D (High level
languages)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages); C6160J (Object-oriented databases)",
corpsource = "AT\&T Bell Labs., USA",
keywords = "C language; Database references; database references;
Entity identifiers; entity identifiers; languages;
model; Object database; object database; Object
identifiers; object identifiers; object-oriented;
object-oriented databases; ODMG objects; Sequence
number generation facility; sequence number generation
facility; software; Software model; Specification;
specification",
thesaurus = "C language; Object-oriented databases; Object-oriented
languages",
treatment = "T Theoretical or Mathematical",
}
@Article{Box:1995:BCC,
author = "D. Box",
title = "Building {C++} components using {OLE2}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "7",
number = "3",
pages = "28--34",
month = mar # "-" # apr,
year = "1995",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Object linking and embedding Version 2 (OLE2) and its
underlying Component Object Model are Microsoft's
solution to the problem of object interoperability,
both at the application level and at the system level.
OLE is essentially a family of interfaces (or data
types) that provide an architecture for
application-level services (e.g., Compound Documents,
Scripting, Controls, and Extensions). These interfaces
define the protocol that is used to access OLE
functionality either from system or user-provided
classes. All OLE interfaces are specified and
implemented using the Component Object Model.",
acknowledgement = ack-nhfb,
affiliation = "DevelopMentor, USA",
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages); C6150N (Distributed systems
software)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages); C6150N (Distributed systems
software)",
corpsource = "DevelopMentor, USA",
keywords = "Application-level services; application-level
services; C language; Component object model; component
object model; Compound documents; compound documents;
Controls; controls; Data types; data types; distributed
processing; Extensions; extensions; interoperability;
languages; object; Object interoperability; Object
linking; object linking; object-oriented; OLE
functionality; OLE2; open systems; Protocol; protocol;
Scripting; scripting; User-provided classes;
user-provided classes",
thesaurus = "C language; Distributed processing; Object-oriented
languages; Open systems",
treatment = "T Theoretical or Mathematical",
}
@Article{Vlissides:1995:PHG,
author = "J. Vlissides",
title = "Pattern hatching-perspectives from the ``gang of
four''",
journal = j-C-PLUS-PLUS-REPORT,
volume = "7",
number = "3",
pages = "36--39",
month = mar # "-" # apr,
year = "1995",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The author discusses design patterns as the basis for
reusable object-oriented software design.",
acknowledgement = ack-nhfb,
affiliation = "IBM Thomas J. Watson Res. Center, Hawthorne, NY, USA",
classcodes = "C6110J (Object-oriented programming); C6110B (Software
engineering techniques)",
classification = "C6110B (Software engineering techniques); C6110J
(Object-oriented programming)",
corpsource = "IBM Thomas J. Watson Res. Center, Hawthorne, NY, USA",
keywords = "design patterns; Design patterns; object-oriented
programming; Pattern hatching; pattern hatching;
reusable object-oriented; Reusable object-oriented
software design; software design; software
reusability",
thesaurus = "Object-oriented programming; Software reusability",
treatment = "T Theoretical or Mathematical",
}
@Article{Lajoie:1995:SUT,
author = "J. Lajoie",
title = "Standards update: type conversions",
journal = j-C-PLUS-PLUS-REPORT,
volume = "7",
number = "3",
pages = "40--46",
month = mar # "-" # apr,
year = "1995",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "New categories of standard conversions have been
created to describe the implicit conversions performed
by an implementation in C++.",
acknowledgement = ack-nhfb,
classcodes = "C6140D (High level languages); C6110J (Object-oriented
programming)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages)",
keywords = "C language; C++; conversions; Implicit conversions;
implicit conversions; object-oriented languages;
software standards; Standard conversions; standard
conversions; type; Type conversions",
thesaurus = "C language; Object-oriented languages; Software
standards",
treatment = "T Theoretical or Mathematical",
}
@Article{Schmidt:1995:UDP,
author = "D. C. Schmidt and P. Stephenson",
title = "Using design patterns to evolve system software from
{UNIX} to {Windows NT}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "7",
number = "3",
pages = "47--60",
month = mar # "-" # apr,
year = "1995",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Developing system software that is reusable across OS
platforms is challenging. Due to constraints imposed by
the underlying OS platforms, it is often impractical to
directly reuse existing algorithms, detailed designs,
interfaces,or implementations. This article describes
our experiences using a large-scale reuse strategy for
system software based on design patterns. Design
patterns capture the static and dynamic structures of
solutions that occur repeatedly when producing
applications in a particular context. Design patterns
are an important technique for improving system
software quality since they address a fundamental
challenge in large-scale software development:
communication of architectural knowledge among
developers. Our experiences with a large-scale reuse
strategy based upon design patterns are described. This
strategy has been used to facilitate the development of
efficient OO telecommunication system software at
Ericsson. We present a case study that describes the
cross-platform evolution of portions of an OO framework
called the ADAPTIVE Service Executive (ASX). The ASX
framework is an integrated collection of components
that collaborate to produce a reusable infrastructure
for developing distributed applications.",
acknowledgement = ack-nhfb,
classcodes = "C6110B (Software engineering techniques); C6110J
(Object-oriented programming)",
classification = "C6110B (Software engineering techniques); C6110J
(Object-oriented programming)",
keywords = "ADAPTIVE Service; ADAPTIVE Service Executive;
architectural; Architectural knowledge; Cross-platform
evolution; cross-platform evolution; Design patterns;
design patterns; Distributed applications; distributed
applications; Executive; knowledge; large-; Large-scale
reuse strategy; object-oriented programming;
reusability; Reusable infrastructure; reusable
infrastructure; scale reuse strategy; software;
software portability; System software; system software;
System software quality; system software quality; UNIX;
Windows NT",
thesaurus = "Object-oriented programming; Software portability;
Software reusability",
treatment = "P Practical",
}
@Article{Barton:1995:ACO,
author = "J. J. Barton and L. R. Nackman",
title = "Algebra for {C++} operators",
journal = j-C-PLUS-PLUS-REPORT,
volume = "7",
number = "3",
pages = "70--74",
month = mar # "-" # apr,
year = "1995",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "We started out in search of a way to express
completeness of and consistency among operators defined
for C++ classes. We applied a time-honored method: we
stole the solution developed in an existing branch of
mathematics and twisted it around until it solved our
problem. The mathematics we used was abstract algebra;
the twisting involved focusing on the operations that
C++ allows us to redefine and ignoring any aspect of
abstract algebra that did not help us to get a
consistent set of operations for a class. As important
as the consistent operations, we also get well defined
names for categories of consistent operations: we can
look at ComplexFloat, see that it is derived from
FieldCategory and, with a little practice, know exactly
what arithmetic operations it will have and how they
are related. What's more, function code in the template
base classes gets reused in any class derived from
them. Our expression of the abstract algebra used
relatively new techniques in C++: function declaration
injection and derived-class parameterized base classes.
Two compilers we tried support these techniques, but
some older compilers may choke. We do not discuss
performance, but we note that a good compiler will
expand the simple inline functions we use in these
templates.",
acknowledgement = ack-nhfb,
affiliation = "IBM Thomas J. Watson Res. Center, Hawthorne, NY, USA",
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages); C4210 (Formal logic)",
classification = "C4210 (Formal logic); C6110J (Object-oriented
programming); C6140D (High level languages)",
corpsource = "IBM Thomas J. Watson Res. Center, Hawthorne, NY, USA",
keywords = "Abstract algebra; abstract algebra; C language; C++
classes; C++ operators; Compilers; compilers;
consistent; Consistent operations; Derived-class
parameterized base classes; derived-class parameterized
base classes; Function code; function code; Function
declaration injection; function declaration injection;
functions; inline; Inline functions; object-oriented;
object-oriented languages; operations; process algebra;
programming",
thesaurus = "C language; Object-oriented languages; Object-oriented
programming; Process algebra",
treatment = "T Theoretical or Mathematical",
}
@Article{Flanagan:1995:RBS,
author = "E. B. Flanagan",
title = "Risky business (software development management)",
journal = j-C-PLUS-PLUS-REPORT,
volume = "7",
number = "3",
pages = "75--76, 78",
month = mar # "-" # apr,
year = "1995",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Every activity has risk; and the development of
software has a place on the list of activities that
involve significant risk. Perhaps that's simply a side
effect of it's dependence on people rather than
machines such as in manufacturing. Regardless of our
efforts to introduce order and structure to the
process, even to use software factory type models, each
software project is new; and the construction or
introduction of anything new involves risk The
recognition and evaluation of that risk is critically
important if it is to be managed. The activities in
software development are as varied as the introduction
of a new primary technology, such as object-oriented
technology, process changes to support new paradigms of
development, new technologies to augment your current
object-oriented development environments, or a new
project. All of these involve some risk. The risks in
our projects or environments can be broken down into
several categories such as business, management, staff
process, or the technology. The author focuses on the
risks for software development organizations as part of
the larger business.",
acknowledgement = ack-nhfb,
classcodes = "C0310F (Software development management)",
classification = "C0310F (Software development management)",
keywords = "development; development organizations;
Object-oriented development environments;
object-oriented development environments;
Object-oriented technology; object-oriented technology;
Process changes; process changes; risk management;
software; Software development; software development
management; Software development organizations;
Software factory type models; software factory type
models; Software project; software project",
thesaurus = "Risk management; Software development management",
treatment = "P Practical",
}
@Article{Box:1995:PKP,
author = "Don Box",
title = "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",
journal = j-C-PLUS-PLUS-REPORT,
volume = "7",
number = "4",
pages = "15--19",
month = may,
year = "1995",
ISSN = "1040-6042",
bibdate = "Thu Apr 23 10:27:26 1998",
acknowledgement = ack-rc,
}
@Article{Berg:1995:OFI,
author = "B. Berg and E. Rowlance",
title = "An object-oriented framework for {I/O}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "7",
number = "4",
pages = "28--35",
month = may,
year = "1995",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "I/O is a natural area for the application of OOD and
programming. The domain contains a wealth of physical
items that are easy to pick up and grab as objects. As
the IBM Rochester laboratory approached the task of
moving the AS/400 operating system from the proprietary
based processor architecture used since its
introduction to a new RISC based architecture, we
realized there would be a significant number of changes
required in the lower layers. We had also become aware
of the limitations of the old software design related
to I/O support. In 1990, the IBM lab in Rochester had
decided on C++ as the strategic language for internal
development and had began building on our experience
with object based programming (abstract data types). As
we looked at the requirements and amount of code change
required to meet them, we decided that we needed to
rewrite significant portions of the code that would
support I/O on the new machine. OOD and C++ were the
logical choice for development. The article describes
the framework that resulted from this effort.",
acknowledgement = ack-nhfb,
affiliation = "IBM Corp., Rochester, MN, USA",
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages); C6150J (Operating systems); C6120
(File organisation)",
classification = "C6110J (Object-oriented programming); C6120 (File
organisation); C6140D (High level languages); C6150J
(Operating systems)",
corpsource = "IBM Corp., Rochester, MN, USA",
keywords = "Abstract data types; abstract data types;
architecture; AS/400 operating system; C language; C++
language; Code change; code change; I/O support; IBM
Rochester; IBM Rochester laboratory; input-output
programs; laboratory; Object based programming; object
based programming; Object-oriented framework;
object-oriented framework; object-oriented languages;
object-oriented programming; OOD; RISC based; RISC
based architecture",
thesaurus = "Abstract data types; C language; Input-output
programs; Object-oriented languages; Object-oriented
programming",
treatment = "A Application",
}
@Article{Veldhuizen:1995:UCT,
author = "T. Veldhuizen",
title = "Using {C++} template metaprograms",
journal = j-C-PLUS-PLUS-REPORT,
volume = "7",
number = "4",
pages = "36--38, 40, 42--43",
month = may,
year = "1995",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Template metaprograms can generate useful code when
interpreted by the compiler, which results in large
speed increases for many applications. A simple example
that generates factorials at compile time is presented.
Although this technique might seem like just a cute C++
trick, it becomes powerful when combined with normal
C++ code. In this hybrid approach, source code contains
two programs: the normal C++ runtime program, and a
template metaprogram that runs at compile time.
Template metaprograms can generate useful code when
interpreted by the compiler, such as a massively
inlined algorithm-that is, an implementation of an
algorithm that works for a specific input size, and has
its loops unrolled. This results in large speed
increases for many applications. The article presents a
simple template metaprogram that generates a bubble
sort algorithm and its performance is analysed.",
acknowledgement = ack-nhfb,
affiliation = "Waterloo Univ., Ont., Canada",
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages); C6150C (Compilers, interpreters and
other processors)",
classification = "C6110J (Object-oriented programming); C6140D (High
level languages); C6150C (Compilers, interpreters and
other processors)",
corpsource = "Waterloo Univ., Ont., Canada",
keywords = "algorithm; bubble sort; Bubble sort algorithm; C
language; C++; C++ runtime program; C++ template
metaprograms; Compiler interpretation; compiler
interpretation; Factorials; factorials; Hybrid
approach; hybrid approach; increases; Massively inlined
algorithm; massively inlined algorithm; Normal C++
code; normal C++ code; object-oriented; object-oriented
languages; program compilers; program interpreters;
programming; runtime program; speed; Speed increases",
thesaurus = "C language; Object-oriented languages; Object-oriented
programming; Program compilers; Program interpreters",
treatment = "P Practical",
}
@Article{Trinoski:1995:CAD,
author = "S. Trinoski and D. Schmidt",
title = "Comparing alternative distributed programming
techniques",
journal = j-C-PLUS-PLUS-REPORT,
volume = "7",
number = "4",
pages = "44--53",
month = may,
year = "1995",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "Various programming techniques for developing
distributed applications are examined and evaluated.
The requirements for a representative distributed
application in the financial services domain have been
outlined in previous articles. This application enables
investment brokers to query the price of a stock as
well as to buy shares of stock. The quote service that
maintains the current stock prices is physically remote
from brokers, who work in geographically distributed
sites. Therefore, our application must work
efficiently, robustly, and securely across various wide
area (WAN) and local area (LAN) networks. We selected
the stock trading application because the issues raised
by analyzing, designing, and implementing it are
representative of the issues that arise when developing
many other types of distributed applications.",
acknowledgement = ack-nhfb,
affiliation = "Hewlett--Packard Co., Chelmsford, MA, USA",
classcodes = "C7120 (Financial computing); C6115 (Programming
support); C5620W (Other computer networks); C5620L
(Local area networks); C6110J (Object-oriented
programming); C6150N (Distributed systems software)",
classification = "C5620L (Local area networks); C5620W (Other computer
networks); C6110J (Object-oriented programming); C6115
(Programming support); C6150N (Distributed systems
software); C7120 (Financial computing)",
corpsource = "Hewlett--Packard Co., Chelmsford, MA, USA",
keywords = "application generators; area networks; Brokers;
brokers; C language; current stock; Current stock
prices; development; distributed applications;
Distributed applications development; Distributed
programming techniques; distributed programming
techniques; electronic trading; Financial services
domain; financial services domain; Geographically
distributed sites; geographically distributed sites;
Investment brokers; investment brokers; local; Local
area networks; local area networks; object-oriented
languages; Physically remote quote service; physically
remote quote service; prices; programming; stock
markets; Stock price querying; stock price querying;
Stock shares buying; stock shares buying; Stock trading
application; stock trading application; Wide area
networks; wide area networks",
thesaurus = "Application generators; C language; Electronic
trading; Local area networks; Object-oriented
languages; Programming; Stock markets; Wide area
networks",
treatment = "P Practical",
}
@Article{Veldhuizen:1995:ET,
author = "T. Veldhuizen",
title = "Expression templates",
journal = j-C-PLUS-PLUS-REPORT,
volume = "7",
number = "5",
pages = "26--31",
month = jun,
year = "1995",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The technique of expression templates is a powerful
and convenient alternative to C-style callback
functions. It allows logical and algebraic expressions
to be passed to functions as arguments, and inlined
directly into the function body. Expression templates
also solve the problem of evaluating vector and matrix
expressions in a single pass without temporaries.",
acknowledgement = ack-nhfb,
affiliation = "Dept. of Syst. Design Eng., Waterloo Univ., Ont.,
Canada",
classcodes = "C6110J (Object-oriented programming); C6115
(Programming support); C4140 (Linear algebra); C6120
(File organisation)",
classification = "C4140 (Linear algebra); C6110J (Object-oriented
programming); C6115 (Programming support); C6120 (File
organisation)",
corpsource = "Dept. of Syst. Design Eng., Waterloo Univ., Ont.,
Canada",
keywords = "abstract data types; Algebraic expressions; algebraic
expressions; Arguments; arguments; C language; C-style
callback functions; Expression templates; expression
templates; expressions; libraries; logical; Logical
expressions; matrix; matrix algebra; Matrix
expressions; object-; object-oriented programming;
oriented languages; Single pass; single pass; software;
Vector expressions; vector expressions",
thesaurus = "Abstract data types; C language; Matrix algebra;
Object-oriented languages; Object-oriented programming;
Software libraries",
treatment = "T Theoretical or Mathematical",
}
@Article{Myers:1995:NUT,
author = "N. Myers",
title = "A new and useful technique: ``traits''",
journal = j-C-PLUS-PLUS-REPORT,
volume = "7",
number = "5",
pages = "32--35",
month = jun,
year = "1995",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "The trait technique is useful immediately, on any
compiler that supports templates. It provides a
convenient way to associate related types, values, and
functions with a template parameter type without
requiring that they be defined as members of the type.
A simple language extension dramatically (and
upward-compatibly) extends the technique to allow
greater flexibility, even at runtime, at no cost in
convenience or efficiency.",
acknowledgement = ack-nhfb,
classcodes = "C6120 (File organisation); C6115 (Programming
support); C6110J (Object-oriented programming); C6150C
(Compilers, interpreters and other processors)",
classification = "C6110J (Object-oriented programming); C6115
(Programming support); C6120 (File organisation);
C6150C (Compilers, interpreters and other processors)",
keywords = "abstract data types; C language; compiler; Compiler;
functions; Functions; language extension; Language
extension; object-oriented languages; program
compilers; software libraries; Template parameter type;
template parameter type; Templates; templates; Trait
technique; trait technique; Types; types; Values;
values",
thesaurus = "Abstract data types; C language; Object-oriented
languages; Program compilers; Software libraries",
treatment = "T Theoretical or Mathematical",
}
@Article{Peden:1995:OAA,
author = "J. H. Peden",
title = "Operator ()() for array of array (of array) class
access",
journal = j-C-PLUS-PLUS-REPORT,
volume = "7",
number = "5",
pages = "36--38, 40--41",
month = jun,
year = "1995",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
abstract = "In their article, Barton and Nackman (1993) make a
case for using templates rather than inheritance for a
TMA class. I argue that, for a class implementing an
AofA, one should use templates and inheritance; an AofA
class defined using the inherent is-a relationship
(e.g., a 4D AofA is a 1D array of 3D arrays) will allow
us to access the elements of each dimension of the
class using operator()().",
acknowledgement = ack-nhfb,
affiliation = "Dept. of Comput. Sci., Longwood Coll., Farmville, VA,
USA",
classcodes = "C6110J (Object-oriented programming); C6120 (File
organisation); C6140D (High level languages)",
classification = "C6110J (Object-oriented programming); C6120 (File
organisation); C6140D (High level languages)",
corpsource = "Dept. of Comput. Sci., Longwood Coll., Farmville, VA,
USA",
keywords = "1D array; 3D; 3D arrays; AofA; Array of array; array
of array; arrays; C language; C++; data structures;
Inheritance; inheritance; languages; object oriented;
Object oriented programming; object-oriented;
object-oriented programming; Operator()();
operator()(); programming; Templates; templates; TMA
class",
thesaurus = "C language; Data structures; Inheritance;
Object-oriented languages; Object-oriented
programming",
treatment = "P Practical",
}
@Article{Lajoie:1996:FOR,
author = "J. Lajoie",
title = "Function overload resolution: selection of the best
viable function",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "1",
pages = "12--17, 56",
month = jan,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6140D (High level languages); C6110J (Object-oriented
programming); C6120 (File organisation)",
corpsource = "Staff Dev., IBM Canada Ltd., Ont., Canada",
keywords = "abstract data types; best viable function; C language;
C++; function name; function overload resolution;
implicit type conversions; object-oriented languages;
object-oriented programming; selection; viable function
parameter",
treatment = "P Practical",
}
@Article{Glass:1996:SAH,
author = "G. Glass",
title = "{STL} in action. Helper algorithms",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "1",
pages = "18--21",
month = jan,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6150E (General utility programs); C6115 (Programming
support); C6110J (Object-oriented programming)",
keywords = "algorithms; C language; C++ Standard Template Library;
efficiency; error-prone work; function; helper;
object-oriented; object-oriented languages; programmer
error; programming; software libraries; STL algorithms;
templatized nonmember; utility programs",
treatment = "P Practical",
}
@Article{Muller:1996:TRH,
author = "H. M. Muller",
title = "Ten rules for handling exception handling
successfully",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "1",
pages = "22--36",
month = jan,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6130 (Data handling techniques); C6110J
(Object-oriented programming)",
keywords = "block-local resource; C language; C++ language; call
stack; catch-block; constraint; exception handling;
object; object-oriented languages; object-oriented
programming; resource; resource acquisitions; resource
management; return statement; secure operations;
shut-down; states; subresources; throw-and-keep
resource; wrapping",
treatment = "P Practical",
}
@Article{Martin:1996:OPS,
author = "R. C. Martin",
title = "The open-closed principle [software maintenance]",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "1",
pages = "37--43",
month = jan,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110B (Software engineering techniques); C6110J
(Object-oriented programming)",
keywords = "C language; C++; changing requirements; classes;
design principle; extension; fixed abstractions;
functions; heuristics; methods; modification; modules;
new code addition; object-oriented; object-oriented
design; object-oriented languages; open-closed
principle; possible behaviour group; software entities;
software maintenance; subroutines; unbounded",
treatment = "P Practical",
}
@Article{Schmidt:1996:CDP,
author = "D. C. Schmidt",
title = "Connector. {A} design pattern for actively
initializing network services",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "1",
pages = "46--50, 52--56",
month = jan,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "B6150P (Communication network design and planning);
B6150M (Protocols); B6210L (Computer communications);
C6155 (Computer communications software); C6150N
(Distributed systems software); C6110J (Object-oriented
programming); C5640 (Protocols)",
corpsource = "Washington Univ., St. Louis, MO, USA",
keywords = "Acceptor pattern; access protocols; active network
service; communication; communication software;
computer communications software; connection
establishment; connection-; connection-oriented network
services; connection-related processing; Connector
design pattern; decoupling; efficient software;
endpoints; extensible software; file transfer;
initialization; network; network service evolution;
object-oriented methods; object-oriented techniques;
operating systems; oriented protocols; passive;
reliable data delivery; remote login; reusability;
reusable; service processing; software; World Wide Web
resource access",
treatment = "P Practical",
}
@Article{Onion:1996:OPM,
author = "F. Onion",
title = "Object persistence in {MFC}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "1",
pages = "57--60",
month = jan,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6140D (High level languages); C6110J (Object-oriented
programming); C6120 (File organisation)",
keywords = "abstract data types; class instances; CObject class;
data; library based runtime class; MFC; object
persistence; object-; object-oriented languages;
oriented programming; simple class hierarchy; STL
container class; structure; structures",
treatment = "P Practical",
}
@Article{Horstmann:1996:CCL,
author = "C. S. Horstmann",
title = "{C++} class libraries for numerical programming",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "1",
pages = "61--64, 66",
month = jan,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C7310 (Mathematics computing); C6110J (Object-oriented
programming); C4140 (Linear algebra); C4190 (Other
numerical methods); C6140D (High level languages)",
corpsource = "San Jose State Univ., CA, USA",
keywords = "C language; C++ class libraries; computing; FORTRAN
LINPACK; Fourier transforms; IMSL Math Module; library;
linear algebra; M++; mathematical; mathematics; number
generators; numerical algorithms; numerical
programming; object-oriented; object-oriented
languages; probability distributions; problems;
programming; programming problems; random; random
number generation; software libraries; statistical
functions",
treatment = "P Practical",
}
@Article{Coplien:1996:HSP,
author = "J. O. Coplien",
title = "The human side of patterns",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "1",
pages = "73--74, 76--78, 80",
month = jan,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6110F (Formal
methods)C6140D (High level languages); C7100 (Business
and administration)",
corpsource = "Software Prod. Res. Dept., AT\&T Bell Labs.,
Naperville, IL, USA",
keywords = "architectural; architecture; business process;
considerations; object oriented practice; object-;
object-oriented languages; object-oriented methods;
organizational issues; organizational practice;
oriented programming; pattern language; process
patterns; recurring patterns; reengineering; software
architectures; system; systems re-engineering",
treatment = "P Practical",
}
@Article{Vlissides:1996:PHP,
author = "J. Vlissides",
title = "Protection. {I}. The {Hollywood} principle",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "2",
pages = "14, 16--19",
month = feb,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6120 (File organisation); C6110J (Object-oriented
programming); C6130S (Data security)",
corpsource = "IBM Thomas J. Watson Res. Center, Hawthorne, NY, USA",
keywords = "architectural artifacts; corruption; data; data
integrity; data protection; errors; file organisation;
file system design; frameworks; Hollywood principle;
implementation artifacts; integrity maintenance; object
oriented programming; object-oriented; programming;
security of data",
treatment = "P Practical",
}
@Article{Leary:1996:CEH,
author = "S. Leary",
title = "{C++} exception handling in multithreaded programs",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "2",
pages = "20--31",
month = feb,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages); C6150J (Operating systems); C6130
(Data handling techniques)",
corpsource = "Dresser-Wayne Ind., USA",
keywords = "C language; C++; exception handling; exception-aware
thread class; exception-safe programming; lightweight
threads; multiprogramming; multitasking; multithreaded
programs; object oriented programming; object-;
object-oriented programming; operating; oriented
languages; OS/2; reusable C++ classes; software
reusability; Solaris; systems; systems (computers);
thread manager class; thread-safe reference counting
class; Windows 95; Windows NT",
treatment = "P Practical",
}
@Article{Kamahele:1996:SCC,
author = "M. L. Kamahele",
title = "{ShMem} --- a {C++} class library for managing objects
in shared memory",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "2",
pages = "32--39, 60",
month = feb,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6120 (File organisation); C6140D (High level
languages); C6110J (Object-oriented programming); C6115
(Programming support)",
corpsource = "Hughes Network Syst. Inc., Germantown, MD, USA",
keywords = "C language; C++; class library; lifetimes; machine
crashes; multiple threads; object management;
object-oriented; object-oriented languages; process;
programming; shared memory; shared memory systems;
ShMem; software libraries; storage allocation; storage
management; thread-safe class library",
treatment = "P Practical",
}
@Article{Fitzpatrick:1996:CSC,
author = "J. Fitzpatrick",
title = "A case study: converting {C} programs to {C++}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "2",
pages = "40--45, 63",
month = feb,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages); C6150C (Compilers, interpreters and
other processors)",
corpsource = "Red Mountain Corp., USA",
keywords = "C; C language; C++; case study; compilers; design;
function prototyping; graphics adapter test program;
object; object-oriented; object-oriented languages;
oriented programming; program compilers; program
interpreters; programming; software projects; type
checking",
treatment = "P Practical",
}
@Article{Cargill:1996:OJC,
author = "T. Cargill",
title = "An overview of {Java} for {C++} programmers",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "2",
pages = "46--49",
month = feb,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6140D (High level languages); C6110J (Object-oriented
programming)",
keywords = "C language; C++; design philosophy; Internet; Java;
object; object oriented language; object-oriented;
object-oriented languages; oriented programming;
programming; Sun Microsystems; World Wide Web browser",
treatment = "P Practical",
}
@Article{Schmidt:1996:CAPa,
author = "D. C. Schmidt and S. Vinoski",
title = "Comparing alternative programming techniques for
multithreaded servers",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "2",
pages = "50--59",
month = feb,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6150N (Distributed systems software); C6110J (Object-
oriented programming); C6160 (Database management
systems (DBMS)); C6140D (High level languages)",
corpsource = "Washington Univ., St. Louis, MO, USA",
keywords = "applications; C; C language; C++; client-server
systems; CORBA; database management; desktop client;
financial data processing; investment brokers;
languages; multithreaded servers; multithreaded
systems; object-oriented; object-oriented programming;
programming; query processing; stock prices; stock
quote database; synchronization; systems; wrappers",
treatment = "P Practical",
}
@Article{Barton:1996:AD,
author = "J. J. Barton and L. R. Nackman",
title = "Automatic differentiation",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "2",
pages = "61--63",
month = feb,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C7310 (Mathematics computing); C4160 (Numerical
integration and differentiation); C6110J
(Object-oriented programming)",
corpsource = "IBM Thomas J. Watson Res. Center, Hawthorne, NY, USA",
keywords = "analytic differentiation; automatic differentiation; C
language; C++; derivatives; differentiation;
expressions; mathematics computing; multicomponent
types; numbers; object oriented programming; object-;
object-oriented programming; operator overloading;
operators; oriented languages; overloaded arithmetic;
Rall; value",
treatment = "P Practical",
}
@Article{Jordan:1996:OOQ,
author = "D. Jordan",
title = "{OQL}: the {Object Query Language}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "2",
pages = "64--66, 71--73",
month = feb,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6140D (High level languages); C6160J (Object-oriented
databases); C6160D (Relational databases)",
corpsource = "AT\&T Bell Labs., USA",
keywords = "abstraction; functional query language; languages;
level; Object Database Management Group; object
oriented database; Object Query Language;
object-oriented databases; object-oriented languages;
ODMG model; OQL; query; relational database; relational
databases; SQL",
treatment = "P Practical",
}
@Article{Jameson:1996:MPL,
author = "K. Jameson",
title = "Multiplatform productivity lessons",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "3",
pages = "CPS4--CPS6, CPS9",
month = mar,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C0310F (Software development management); C6110B
(Software engineering techniques); C6115 (Programming
support)",
keywords = "multiplatform development; multiplatform productivity;
programming environments; software development
environment; software development management; software
engineering; software tools",
treatment = "P Practical",
}
@Article{Jeghers:1996:GDC,
author = "M. Jeghers",
title = "{GUI} development with cross platform toolkits",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "3",
pages = "CPS7--CPS9",
month = mar,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6180G (Graphical user interfaces); C6115 (Programming
support); C6110B (Software engineering techniques)",
keywords = "application program interfaces; cross platform
toolkits; graphical user; graphical user interfaces;
GUI development; interface; least common denominator
functionality; software portability; software tools;
style guide compliance",
treatment = "P Practical",
}
@Article{Martin:1996:LSP,
author = "R. C. Martin",
title = "The {Liskov} substitution principle",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "3",
pages = "14, 16--17, 20--23",
month = mar,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages); C6120 (File organisation)",
keywords = "abstract base classes; abstract polymorphic
interfaces; abstraction; C language; C++; design rules;
functions; hierarchies; inheritance; Liskov
substitution principle; object-; object-oriented
languages; object-oriented programming; Open-Closed
principle; oriented methods; polymorphism; statically
typed languages; virtual",
treatment = "P Practical",
}
@Article{Reeves:1996:CE,
author = "J. W. Reeves",
title = "Coping with exceptions",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "3",
pages = "24--35",
month = mar,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages); C6130 (Data handling techniques)",
keywords = "ANSI ISO C++ committee; ANSI standards; C language;
C++ standard; exception handling; feature set; ISO;
nonexception handling code; object oriented
programming; object-oriented; object-oriented
languages; programming; software standards; standard
libraries; standards",
treatment = "P Practical",
}
@Article{Forguson:1996:PMD,
author = "D. Forguson",
title = "Programming with the {MFC} document template
architecture",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "3",
pages = "36--41",
month = mar,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6180G (Graphical user interfaces); C6130D (Document
processing techniques); C6110J (Object-oriented
programming); C6115 (Programming support)",
corpsource = "Open Syst. Group, St. Louis, MO, USA",
keywords = "document handling; document type registration; drag;
drop; graphical user interfaces; management systems;
MFC document template architecture; object-; oriented
programming; programming; reusable components; software
reusability; user interface; user interfaces; word
processing",
treatment = "P Practical",
}
@Article{Hamilton:1996:RBO,
author = "J. Hamilton",
title = "Reusing binary objects with {DirectToSOM C++}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "3",
pages = "42--51",
month = mar,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6115
(Programming support); C6110B (Software engineering
techniques); C6150C (Compilers, interpreters and other
processors); C6140D (High level languages)",
corpsource = "IBM Canada Ltd., Ont., Canada",
keywords = "binary objects; C language; C++ class libraries; class
library; compatibility; compilers; DirectToSOM C++;
object-oriented programming; program compilers;
release-to-release binary; software libraries; software
reusability; vendors",
treatment = "P Practical",
}
@Article{Box:1996:CSP,
author = "D. Box",
title = "Com smart pointers also considered harmful",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "3",
pages = "54--57",
month = mar,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6140D (High level languages); C6110J (Object-oriented
programming); C6120 (File organisation); C6150C
(Compilers, interpreters and other processors)",
keywords = "abstract data types; C language; C++; class library;
COM interface pointers; Com smart pointers;
exception-safe firewall; IUnknown; object oriented
language; object-oriented languages; object-oriented
programming; program control structures; smart
pointers; SmartInterface class",
treatment = "P Practical",
}
@Article{Onion:1996:DDS,
author = "F. Onion and A. Harrison",
title = "Dynamic data structure serialization in {MFC}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "3",
pages = "58--62",
month = mar,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6120 (File organisation); C6140D (High level
languages)",
keywords = "C language; data structure serialization; data
structures; dynamic data structure; MFC; object
reconstruction; pointer storage",
treatment = "P Practical",
}
@Article{Horstmann:1996:JPS,
author = "C. S. Horstmann",
title = "{Java} programming with {Sun's Java} development kit",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "3",
pages = "63--70",
month = mar,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages); C6150C (Compilers, interpreters and
other processors); C6150G (Diagnostic, testing,
debugging and evaluating systems); C6115 (Programming
support); C5620W (Other computer networks); C6180G
(Graphical user interfaces)",
corpsource = "San Jose State Univ., CA, USA",
keywords = "compiler; debugging; debugging tools; graphical user
interface; graphical user interfaces; high level
languages; Internet; Java; network; object-oriented
programming; object-oriented programming language;
program; program compilers; programming; software
development kit; software tools; Sun Microsystems;
World Wide Web",
treatment = "P Practical",
}
@Article{Vlissides:1996:PMP,
author = "J. Vlissides",
title = "Protection: membership has its privileges",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "4",
pages = "11--13, 16--18, 28",
month = apr,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6130G
(Groupware)",
corpsource = "IBM Thomas J. Watson Res. Center, Hawthorne, NY, USA",
keywords = "design; file organisation; file system protection;
groups; groupware; mediator pattern; membership;
object-oriented programming; patterns; users",
treatment = "P Practical",
}
@Article{Meyers:1996:SP,
author = "S. Meyers",
title = "Smart pointers. {I}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "4",
pages = "19--23",
month = apr,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages); C6120 (File organisation)",
keywords = "assignment; built in pointers; C language; C++;
construction; copying; data structures; dereferencing;
destruction; object-oriented languages; pointer
behavior; smart pointers",
treatment = "P Practical",
}
@Article{VanLoon:1996:PMS,
author = "R. {Van Loon}",
title = "The power of multimedia. Strengthen your applications
to power multimedia features",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "4",
pages = "24--28",
month = apr,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6130M (Multimedia); C7000 (Computer applications)",
keywords = "application; moving pictures; multimedia; multimedia
systems; music; power multimedia; speech",
treatment = "G General Review",
}
@Article{Cohen:1996:DIC,
author = "S. Cohen",
title = "Dynamic inheritance in {C++}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "4",
pages = "30--37",
month = apr,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages)",
corpsource = "Orbotech Ltd., Yavne, Israel",
keywords = "C language; C+; extensibility; inheritance;
object-oriented programming; processing; production
image; reuse; software reusability",
treatment = "P Practical",
}
@Article{VanRooyen:1996:ACN,
author = "M. {Van Rooyen}",
title = "Alternative {C++}. New methods for solving old
problems",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "4",
pages = "38--42",
month = apr,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages)",
keywords = "C language; C++ classes; C++ issues; destruction;
lifetime; object ownership; object-oriented languages;
performance-critical systems",
treatment = "P Practical",
}
@Article{Forguson:1996:EMDa,
author = "D. Forguson",
title = "Extending the {MFC} document template architecture",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "4",
pages = "43--53",
month = apr,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6130D (Document processing techniques); C6110J
(Object-oriented programming)",
corpsource = "Open Syst. Group Inc., St. Louis, MO, USA",
keywords = "application-specific; document handling; document
template architecture; document templates; document
types; documents; Microsoft Foundation Class;
object-oriented programming; view classes",
treatment = "P Practical",
}
@Article{Schmidt:1996:CAPb,
author = "D. C. Schmidt and S. Vinoski",
title = "Comparing alternative programming techniques for
multithreaded {CORBA} servers",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "4",
pages = "56--66",
month = apr,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6110P (Parallel
programming); C6140D (High level languages)",
corpsource = "Washington Univ., St. Louis, MO, USA",
keywords = "C language; complexity; distributed multithreaded
applications; multithreaded CORBA servers;
object-oriented programming; parallel; programming;
programming techniques",
treatment = "P Practical",
}
@Article{Barton:1996:HAI,
author = "J. J. Barton and L. R. Nackman",
title = "Hello {ANSI\slash ISO}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "4",
pages = "68--70, 72--73",
month = apr,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6140D (High level languages); C6110J (Object-oriented
programming)",
corpsource = "IBM Thomas J. Watson Res. Center, Hawthorne, NY, USA",
keywords = "ANSI standards; ANSI/ISO C++ standard; ANSI/ISO
library; C language; C++; class; ISO standards;
languages; library; multiple platforms;
object-oriented",
treatment = "P Practical",
}
@Article{Glass:1996:USS,
author = "G. Glass",
title = "A universal streaming service",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "4",
pages = "74--76, 81--83",
month = apr,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages); C6115 (Programming support)",
keywords = "C language; C++ toolkit; interprocess communication
mechanism; object-oriented programming; persistent;
software tools; STL; transportable; universal streaming
service; USS",
treatment = "P Practical",
}
@Article{Cohen:1996:LPC,
author = "S. Cohen",
title = "Lightweight persistence in {C++}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "5",
pages = "22--32",
month = may,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6160J (Object-
oriented databases); C6150C (Compilers, interpreters
and other processors); C6150J (Operating systems)",
corpsource = "Orbotech Ltd., Yavne, Israel",
keywords = "(computers); C language; C++ compiler; languages;
lightweight persistence; object-oriented;
object-oriented databases; object-oriented DBMS;
object-oriented programming; operating system
platforms; operating systems; portability; program
compilers; software; software portability; standard C++
strategies",
treatment = "P Practical",
}
@Article{Moth:1996:LC,
author = "C. Moth",
title = "Lightweight classes",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "5",
pages = "33--39",
month = may,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6110F (Formal
methods)C6160J (Object-oriented databases); C6120 (File
organisation)",
keywords = "abstract data types; C data types; C language; C
language database libraries; C++; C++ database; code;
lightweight classes; object database; object
serialization code maintenance; object-oriented design
technique; object-oriented methods; object-oriented
programming; programming; software; software libraries;
standardisation; standardization; standards; systems",
treatment = "P Practical",
}
@Article{Linenbach:1996:IRB,
author = "T. Linenbach",
title = "Implementing reusable binary association in {C++}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "5",
pages = "40--47, 51",
month = may,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6110B (Software
engineering techniques)",
corpsource = "Sagent Technol., Menlo Park, CA, USA",
keywords = "C language; C++ language; object; object-oriented
programming; one-to-many; one-to-one relationships;
program modification; relationships; reusability;
reusable binary association; software; software
functionality; software projects",
treatment = "P Practical",
}
@Article{Onion:1996:DDE,
author = "F. Onion and A. Harrison",
title = "Dialog data exchange in {MFC}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "5",
pages = "48--51",
month = may,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6180G (Graphical user interfaces); C6115 (Programming
support); C6110J (Object-oriented programming)",
keywords = "automated transfer; ClassWizard code generator; DDV
mechanism; DDX; dialog box; dialog data exchange;
formatting; graphical user interfaces; MFC;
object-oriented programming; software tools; user
interface management systems; validation of data",
treatment = "P Practical",
}
@Article{Reeves:1996:ESC,
author = "J. Reeves",
title = "Exceptions and {Standard C++}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "5",
pages = "56--59, 62--64",
month = may,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages)",
corpsource = "San Jose State Univ., CA, USA",
keywords = "C language; error conditions; exception handling;
exception-based language; handling exceptions;
object-oriented languages; object-oriented programming;
Standard C++; throwing exceptions",
treatment = "P Practical",
}
@Article{Koenig:1996:IAS,
author = "A. Koenig",
title = "Inheritance, assignment, and slicing",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "5",
pages = "71--72",
month = may,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6120 (File
organisation)",
keywords = "assignment; copying a value; inheritance;
object-oriented programming; slicing",
treatment = "P Practical",
}
@Article{Lajoie:1996:MMR,
author = "J. Lajoie",
title = "The memory model-type representations",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "5",
pages = "73--76, 81--83",
month = may,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6140D (High level languages); C6110J (Object-oriented
programming); C6120 (File organisation)",
corpsource = "IBM Canada Ltd., Canada",
keywords = "C language; C++ memory model; C++ object model; C++
standard committee; data structures; memory model-type
representations; object-oriented languages; storage
layout",
treatment = "P Practical",
}
@Article{Vlissides:1996:KS,
author = "J. Vlissides",
title = "To kill a singleton",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "6",
pages = "10, 12, 16--19",
month = jun,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages); C6120 (File organisation)",
corpsource = "IBM Thomas J. Watson Res. Center, Hawthorne, NY, USA",
keywords = "abstract data types; C language; client; deletion;
design; file system; file system users; global point of
access; multiple instances; object-oriented languages;
object-oriented programming; program; singleton class;
singleton instances; singleton pattern; static Instance
operation; user object; user objects",
treatment = "P Practical",
}
@Article{Meyers:1996:SPN,
author = "S. Meyers",
title = "Smart pointers, nullness, and type conversions",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "6",
pages = "20--23",
month = jun,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages); C6120 (File organisation)",
keywords = "abstract data types; C language; C++ language; dumb
pointers; nullness; object-oriented languages;
object-oriented programming; OOP; program control
structures; smart pointer classes; type conversions",
treatment = "P Practical",
}
@Article{Lakos:1996:LCSa,
author = "J. Lakos",
title = "Large-scale {C++} software design. 1. {Mentor
Graphics} experiences using {C++} for large systems",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "6",
pages = "26--37",
month = jun,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages); C6110B (Software engineering
techniques)",
keywords = "atomic unit; C language; C++ software; complete
abstraction; cyclic link time dependencies; design
time; development; IsA; large scale C++ software
design; large systems; logical; logical design
entities; logical entities; maintainability; Mentor
Graphics experiences; object-oriented; object-oriented
languages; physical dependencies; physical design
rules; programming; relationships; small project
experience; software reusability",
treatment = "P Practical",
}
@Article{Lippman:1996:VO,
author = "S. Lippman",
title = "The varieties of object",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "6",
pages = "38--50",
month = jun,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages); C6120 (File organisation)",
keywords = "aggregation; C language; C++; data encapsulation;
encapsulation; features; inheritance; languages;
object; object-oriented; object-oriented programming;
program performance",
treatment = "T Theoretical or Mathematical",
}
@Article{Mueller:1996:OPL,
author = "T. R. Mueller",
title = "Overcoming the problems in a large scale {C++}
project. {AT\&T's} gamble with {C++} as a primary
programming language",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "6",
pages = "51--52",
month = jun,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C7410F (Communications computing); C0310P (DP
personnel management); C0310F (Software development
management); C6110J (Object-oriented programming);
C6140D (High level languages); C0220 (Computing
education and training)",
corpsource = "AT\&T Bell Labs., Columbus, OH, USA",
keywords = "architecture; C language; C++; C++ usage; Columbus
AT\&T location; examples; expertise; human resource
management; in-house courses; informal seminars;
languages; large scale C++ project; management;
management support; object-oriented; object-oriented
programming; personnel; primary programming language;
programming; project; reliability; risks; software
development management; staff; switching system
building; telecommunication computing; training",
treatment = "P Practical",
}
@Article{Fitzpatrick:1996:RGT,
author = "J. Fitzpatrick",
title = "Redesigning a graphics test program using {C++}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "6",
pages = "54--60",
month = jun,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages)",
keywords = "C; C language; C++; code size; computer graphic
equipment; computers; graphics adapter cards; graphics
test program; IBM compatible; IBM-PC compatible;
machines; MS-DOS program; object oriented methods;
object-oriented; object-oriented languages; operating
systems (computers); program; programming; reusability;
rewriting; software; software modularity; software
reuse; system reengineering; systems re-engineering",
treatment = "P Practical",
}
@Article{Martin:1996:DIP,
author = "R. C. Martin",
title = "The {Dependency Inversion Principle}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "6",
pages = "61--66",
month = jun,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages)",
keywords = "bad software design; C language; C++; Dependency
Inversion Principle; DIP; inheritance; Liskov
Substitution Principle; LSP; object oriented; object-;
object-oriented languages; object-oriented programming;
OCP; Open Closed Principle; oriented methods;
programming; public",
treatment = "P Practical",
}
@Article{Forguson:1996:DVC,
author = "D. Forguson",
title = "Developing the view component in {MFC}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "6",
pages = "67--74, 76",
month = jun,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6130D (Document processing techniques); C6180 (User
interfaces); C6110J (Object-oriented programming)",
corpsource = "Open Syst. Group Inc., St. Louis, MO, USA",
keywords = "application-specific classes; bitmaps; classes;
document; document classes; document handling; logical;
MFC; MFC CView class; Microsoft Foundation Class;
object oriented; object-oriented programming;
persistent data store; programming; reusability;
software; software reuse; spreadsheets; template
architecture; text; user interface; user interfaces;
view; view component",
treatment = "P Practical",
}
@Article{Barton:1996:WCC,
author = "J. J. Barton and L. R. Nackman",
title = "While (converting to {C++}) use iterators",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "6",
pages = "77--78, 83, 87",
month = jun,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages)",
corpsource = "IBM Thomas J. Watson Res. Center, Hawthorne, NY, USA",
keywords = "algorithms-; ANSI ISO C++ standard; ANSI standards; C
language; C++; containers; finite-element; HP; input
file; ISO standards; iterator-container paradigm;
iterators; languages; mesh; object oriented
programming; object-oriented; object-oriented
programming; prototype; SafeSTL; software libraries;
software standards; standard library; STL",
treatment = "P Practical",
}
@Article{Henkel:1996:ECL,
author = "S. Henkel and W. Dangelmaier",
title = "Evaluating class libraries for interprocess
communication",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "7",
pages = "21--29",
month = jul,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6150N (Distributed systems software); C6110J (Object-
oriented programming); C6115 (Programming support)",
keywords = "ACE; C language; C++ class libraries; compilation;
distributed processing; functionality; gcc 2.7.0; GNU;
interprocess communication; Net.h++; object-oriented;
performance; programming; Socket++; software libraries;
software reviews; Solaris 2.4; SPARCstations; Sun; Sun
CC 4.0.1",
treatment = "P Practical; R Product Review",
}
@Article{Kreft:1996:IST,
author = "K. Kreft and A. Langer",
title = "Iterators in the {Standard Template Library}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "7",
pages = "31--37",
month = jul,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages); C6110B (Software engineering
techniques)",
keywords = "C language; C++; extensible framework; generic
programming; iterator adaptors; iterator base classes;
iterator categories; iterator tags; joint ISO/ANSI
standards; language; object-oriented; object-oriented
languages; programming; software libraries; Standard
C++ Library; Standard Template Library; STL iterators",
treatment = "P Practical",
}
@Article{Harrison:1996:EPO,
author = "T. H. Harrison and D. C. Schmidt",
title = "Evaluating the performance of {OO} network programming
toolkits",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "7",
pages = "39--46",
month = jul,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6150N
(Distributed systems software); C6110P (Parallel
programming)",
corpsource = "Dept. of Comput. Sci., Washington Univ., St. Louis,
MO, USA",
keywords = "Broker Architecture; Common Object Request; computing;
data; distributed object; high speed networks; IPC
mechanisms; low speed networks; object-oriented
methods; object-oriented programming; OO network
programming toolkits; open standard; parallel
programming; performance issues; software performance
evaluation; software standards; transfer",
treatment = "P Practical",
}
@Article{Schmidt:1996:CAPc,
author = "D. C. Schmidt and S. Vinoski",
title = "Comparing alternative programming techniques for
multithreaded {CORBA} servers",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "7",
pages = "47--56",
month = jul,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6150N
(Distributed systems software); C5690 (Other data
communication equipment and techniques); C6110P
(Parallel programming)",
corpsource = "Washington Univ., St. Louis, MO, USA",
keywords = "alternative programming techniques; C; C++ wrappers;
concurrency model; CORBA; multithreaded CORBA;
multithreaded stock quote servers; network servers;
object-oriented programming; parallel; programming;
servers; thread per request; thread per session model;
thread pool",
treatment = "P Practical",
}
@Article{Onion:1996:CRC,
author = "F. Onion and A. Harrison",
title = "{Chain of Responsibility} and command targets",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "7",
pages = "57--59, 62--63",
month = jul,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6150E (General
utility programs); C6150J (Operating systems); C6120
(File organisation); C6140D (High level languages)",
keywords = "abstract data types; abstractions; application program
interfaces; behavior encapsulation; C; C++; CCmdTarget
class; Chain of; classes; generic command; language;
message routing; messaging architecture; MFC; MFC
programming; object encapsulation; object-oriented;
object-oriented languages; programming; Responsibility
pattern; targets; Windows API",
treatment = "P Practical",
}
@Article{Reeves:1996:TGE,
author = "J. W. Reeves",
title = "Ten guidelines for exception specification",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "7",
pages = "64--68, 70, 88",
month = jul,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6110F (Formal
methods)C6140D (High level languages); C6130 (Data
handling techniques)",
keywords = "application level; bad-; C language; C++; exception;
exception handling; exception specifications;
exceptions; formal specification; functional
programming; functions; handler(); languages;
object-oriented; object-oriented programming;
programming guidelines; public interface functions;
terminate-; throw(); type definition;
unexpected-handler(); valid; virtual functions",
treatment = "P Practical",
}
@Article{Alicea:1996:UUS,
author = "H. Alicea and G. Glass",
title = "Using the universal streaming service with {CORBA}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "8",
pages = "12--19",
month = sep,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6150N
(Distributed systems software); C6120 (File
organisation)",
corpsource = "Manugistics, Rockville, MD, USA",
keywords = "abstract data types; business object; call-by-;
client-server systems; Common Object Request Broker
Architecture; complex data objects; CORBA; CORBA
clients; CORBA Request handle; distributed systems
development; interface definition language;
interprocess communication; IONA Orbix; lightweight;
mechanism; models; network distribution; object
classes; object-oriented; opaque data types;
pass-by-value; persistent transportable objects;
programming; servers; software libraries; standard; STL
containers; template library; universal streaming
service; value parameter",
treatment = "P Practical",
}
@Article{Vissides:1996:TO,
author = "J. Vissides",
title = "The trouble with {Observer}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "8",
pages = "20--24",
month = sep,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6120 (File
organisation); C6180 (User interfaces); C6130 (Data
handling techniques)",
corpsource = "IBM Thomas J. Watson Res. Center, Yorktown Heights,
NY, USA",
keywords = "C++ language; data encapsulation; data presentations;
definitive information; design patterns;
interface/application data separation; interfaces;
model-view-controller; object-oriented programming;
observer object; Observer pattern; partitioning;
querying; subject object; updating; user",
treatment = "P Practical",
}
@Article{Meyers:1996:SPA,
author = "S. Meyers",
title = "Smart pointers: automating inheritance and const
conversions",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "8",
pages = "25--27",
month = sep,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6120 (File
organisation)",
keywords = "compilers; const conversions; conversion operator;
data conversion; dumb pointer emulation; implicit;
inheritance; inheritance relationships; instantiated
member function; member function templates;
object-oriented programming; smart pointer classes;
subroutines; type conversion operators",
treatment = "P Practical",
}
@Article{White:1996:ADU,
author = "R. G. White",
title = "Advantages and disadvantages of unique representation
patterns",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "8",
pages = "28--35",
month = sep,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6120 (File
organisation); C6110B (Software engineering
techniques)",
keywords = "copy-on-write objects; data structures; design
patterns; dynamic object creation; equality comparison;
large objects; memory cost; memory usage;
multiple-client access; object-oriented programming;
oriented software; processing time; reduction;
reusability; reusable object-; singleton pattern;
software; storage management; unique representation
patterns",
treatment = "P Practical",
}
@Article{Gautier:1996:VR,
author = "P. Gautier",
title = "Visitors revisited",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "8",
pages = "36--39, 42--45",
month = sep,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6120 (File
organisation); C6110B (Software engineering
techniques); C6115 (Programming support)",
corpsource = "Thomson-CSF, Colombes, France",
keywords = "abstract data types; applications programming;
argument type; extension; frameworks;
inheritance-based; libraries; library class
functionality; method selection; object; object-based
programming; object-oriented programming; operation
definition; operation representation; reusable classes;
software; software reusability; structure elements;
template-based approach; triple-dispatch visitor;
visitor; visitor pattern",
treatment = "P Practical",
}
@Article{Bulka:1996:PCS,
author = "D. Bulka",
title = "Performance and {C++}: separating myth from reality",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "8",
pages = "46--54",
month = sep,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages); C6150N (Distributed systems
software)",
keywords = "C language; C++; coding guidelines; Communications
Server for AIX; critical systems; evaluation; high
performance networking software; IBM; languages;
network operating systems; object oriented programming;
object-oriented; object-oriented programming; operating
system; performance; performance penalty; software
performance",
treatment = "P Practical",
}
@Article{Lakos:1996:LCSb,
author = "J. Lakos",
title = "Large-scale {C++} software design: physical hierarchy.
2. Effective testing, improved maintainability,
independent reuse",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "8",
pages = "55--64",
month = sep,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6110B (Software
engineering techniques); C6150C (Compilers,
interpreters and other processors); C6140D (High level
languages)",
corpsource = "Mentor Graphics Corp., Warren, NJ, USA",
keywords = "C language; C++ software design-time; compile-time
coupling; compiled languages; component include;
encapsulation; graph; independent; large-scale C++
software design; large-scale systems; logical;
object-oriented languages; object-oriented programming;
physical dependencies; physical design; physical design
rules; physical hierarchy; program; program compilers;
relationships; run-time efficiency; separate
translation; software maintainability; software
maintenance; software reusability; software reuse;
software testing; testing; units",
treatment = "P Practical",
}
@Article{Koenig:1996:CIS,
author = "A. Koenig",
title = "Copying and insertion in {STL} algorithms",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "8",
pages = "65--66",
month = sep,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6130 (Data handling techniques); C6140D (High level
languages); C6110J (Object-oriented programming); C6115
(Programming support)",
keywords = "C language; C++ standard library; copy algorithm;
copying; data handling; data movement; insertion;
iterator adaptor; memory allocation; object-;
object-oriented languages; oriented programming;
software libraries; Standard Template Library; STL
algorithms; STL containers",
treatment = "P Practical",
}
@Article{Lajoie:1996:CMMa,
author = "J. Lajoie",
title = "The {C++} memory model. Pointer manipulations",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "8",
pages = "67--72",
month = sep,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6120 (File organisation); C6140D (High level
languages); C6110J (Object-oriented programming); C6130
(Data handling techniques)",
keywords = "C language; C++ memory model; C++ programs; C++
Standard; coding practices; Committee; computer
architectures; data handling; data structures;
efficient C++ implementations; languages;
object-oriented; pointer manipulations; software
standards",
treatment = "G General Review",
}
@Article{Coplien:1996:CP,
author = "J. O. Coplien",
title = "Code patterns",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "9",
pages = "18--25",
month = oct,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6115
(Programming support); C6110F (Formal methods)",
corpsource = "Software Production Res. Dept., Bell Lab., Naperville,
IL, USA",
keywords = "automated code; automatic programming; code patterns;
design pattern automation; generation; object-;
object-oriented methods; oriented programming",
treatment = "P Practical",
}
@Article{Lajoie:1996:CMMb,
author = "J. Lajoie",
title = "The {C++} memory model: new and delete operators",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "9",
pages = "26--33, 44",
month = oct,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages)",
corpsource = "IBM Canada Lab., Canada",
keywords = "ANSI standards; ANSI/ISO C++ Standard Committee; C
language; C++ memory model; delete; ISO standards;
languages; new operator; object-oriented;
object-oriented programming; operator; software
standards",
treatment = "P Practical",
}
@Article{Lajoie:1996:CSC,
author = "J. Lajoie",
title = "The {C++ Standards Committee}'s sixth
year-organization and schedule update",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "9",
pages = "30--31",
month = oct,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6140D (High level languages); C6110J (Object-oriented
programming)",
keywords = "ANSI standards; C language; C++ standards committees
sixth year; ISO standards; languages; object-oriented;
schedule update; software standards",
treatment = "G General Review",
}
@Article{Soukup:1996:QP,
author = "J. Soukup",
title = "Quality patterns",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "9",
pages = "34--44",
month = oct,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6110B (Software
engineering techniques); C6120 (File organisation)",
corpsource = "IBM Canada Lab., Canada",
keywords = "abstract data types; C language; code modularity;
modular design; object-oriented languages;
object-oriented programming; quality patterns;
reusability; reusable pattern library coding; software;
software architecture; software libraries",
treatment = "P Practical",
}
@Article{Soukup:1996:ACM,
author = "J. Soukup",
title = "Another controversy: managing groups of cooperating
classes",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "9",
pages = "46--47",
month = oct,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6120 (File
organisation); C6110B (Software engineering
techniques)",
corpsource = "Code Farms Inc., USA",
keywords = "abstract data types; application classes; cooperating
class management; dependency loops; engineering;
manager classes; object-; object-oriented programming;
oriented strategy; overlapping; pattern classes;
relations; software; software architecture",
treatment = "P Practical",
}
@Article{Vinoski:1996:DCD,
author = "S. Vinoski and D. C. Schmidt",
title = "Distributed callbacks and decoupled communication in
{CORBA}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "9",
pages = "48--56, 77",
month = oct,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6150N (Distributed systems software); C6110J (Object-
oriented programming)",
corpsource = "Hewlett--Packard's Distributed Comput. Program,
Chelmsford, MA, USA",
keywords = "client-server systems; client/server; concurrency
control; concurrency models; consumers; CORBA;
decoupled communication; decoupled peer-to-peer;
distributed callbacks; distributed object computing
systems; distributed stock quoting; multithreaded;
object-oriented; OMG Events object service;
programming; relationships; request communication;
response communication; server applications; suppliers;
systems",
treatment = "P Practical",
}
@Article{Forguson:1996:EMDb,
author = "D. Forguson",
title = "Extending the {MFC} document template architecture",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "9",
pages = "57--65",
month = oct,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6130D (Document processing techniques); C6110J
(Object-oriented programming); C6120 (File
organisation); C6110B (Software engineering
techniques)",
corpsource = "Open Systems Group Inc., St. Louis, MO, USA",
keywords = "abstract data types; C++ classes; data selection;
default behavior; development; document; document
class; Foundation Class library; MFC document template
architecture extension; Microsoft; object-oriented
programming; reusability; reuse; software; text
editing; view class; window class; Windows application;
Windows clipboard; windows message; WinEdit; word
processing",
treatment = "P Practical",
}
@Article{Barton:1996:SEC,
author = "J. J. Barton and L. R. Nackman",
title = "Scientific and engineering {C++-is} this standard
input?",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "9",
pages = "66, 68--69",
month = oct,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6140D (High level languages); C7400 (Engineering
computing); C4185 (Finite element analysis)",
keywords = "ANSI/ISO collection; C language; code; engineering
computing; finite element analysis; finite-element
meshes; FORTRAN; FORTRAN-like coding; input stream;
mesh; programs; scientific and engineering C++",
treatment = "A Application; P Practical",
}
@Article{Vlissides:1996:GGS,
author = "J. Vlissides",
title = "{Generation Gap} [software design pattern]",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "10",
pages = "12, 14--18",
month = nov # "-" # dec,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6110F (Formal
methods)C6120 (File organisation); C6115 (Programming
support)",
corpsource = "IBM Thomas J. Watson Res. Center, Hawthorne, NY, USA",
keywords = "automatic code generation; automatic programming; C++
language; class; code encapsulation; data
encapsulation; encapsulation; generated code
modification; Generation Gap; inheritance;
modifications; object-oriented methods; object-oriented
programming; software design pattern; structural;
structured programming",
treatment = "P Practical",
}
@Article{Meyers:1996:RSP,
author = "S. Meyers",
title = "Refinements to smart pointers",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "10",
pages = "19--22",
month = nov # "-" # dec,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6120 (File organisation); C6110J (Object-oriented
programming); C6140D (High level languages)",
keywords = "C language; C++ language; data structures; dumb
pointers; object-oriented languages; object-oriented
programming; refinements; smart pointers",
treatment = "P Practical",
}
@Article{Koenig:1996:CPC,
author = "A. Koenig",
title = "Containers and pointer comparisons",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "10",
pages = "23--26",
month = nov # "-" # dec,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6120 (File organisation); C6110J (Object-oriented
programming)",
keywords = "array elements; arrays; C language; C++ language; data
structures; documentation; implementation; languages;
less-than operator; less<T> template; library
containers; object-oriented; object-oriented
programming; order-based containers; ordered
comparison; pointer comparisons; portable; software
portability; standard-conforming C++ implementation",
treatment = "P Practical",
}
@Article{Kreft:1996:ISC,
author = "K. Kreft and A. Langer",
title = "Iterators in the {Standard C++ Library}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "10",
pages = "27--30, 32",
month = nov # "-" # dec,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6115
(Programming support); C6140D (High level languages);
C6150C (Compilers, interpreters and other processors)",
keywords = "algorithm interfaces; ANSI standards; association; C
language; C++ compiler; compile-time deduction;
function; general-purpose; generic programming
techniques; ISO standards; ISO/ANSI standards
committee; iterative; iterator design; iterator traits;
Library; methods; nonclass types; object-oriented;
object-oriented languages; overloading; program
compilers; programming; software; software libraries;
Standard C++ Library; Standard Template; standards;
STL; type",
treatment = "P Practical",
}
@Article{Lindner:1996:DSH,
author = "M. P. Lindner",
title = "Designing for safe hashing. Implementing efficient
dynamic search structures",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "10",
pages = "36--41",
month = nov # "-" # dec,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6120 (File organisation); C6110J (Object-oriented
programming)",
keywords = "abstract data types; C++ code optimization; C++
compiler; C++ language; C++ Standard Template Library;
class; constructs; data integrity; data structures;
dynamic search structures; efficient; hash-fun class;
hash-stream; hashed data; hasher class; hashing
function design; indexing; object-; object-oriented
design; oriented programming; performance; problems;
public domain software; safety; search; software
libraries; STL; structures; syntax; table size;
type-safety",
treatment = "P Practical",
}
@Article{Lakos:1996:LCSc,
author = "J. Lakos",
title = "Large-scale {C++} software design: levelization,
insulation, and packages. 3. Avoiding excessive
compile- and link-time dependencies",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "10",
pages = "42--56",
month = nov # "-" # dec,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages); C6150C (Compilers, interpreters and
other processors)",
corpsource = "Mentor Graphics, Warren, NJ, USA",
keywords = "C language; compile-time dependencies; cyclic
link-time; dependencies; insulation; large-scale C++
software design; large-scale systems; levelization;
macro unit; macros; methods; object-oriented;
object-oriented programming; packages; physical design;
program compilers",
treatment = "P Practical",
}
@Article{Martin:1996:GOD,
author = "R. C. Martin",
title = "Granularity [object-oriented design]",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "10",
pages = "57--62",
month = nov # "-" # dec,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6110F (Formal
methods)C6110B (Software engineering techniques)",
keywords = "change; engineering; granularity; large
object-oriented applications; large-scale systems;
macro; maintainable software; object-oriented design;
object-oriented methods; packages; release; reusable
software; robust; software; software engineering;
structure; vocabularies",
treatment = "P Practical",
}
@Article{Reeves:1996:EDC,
author = "J. W. Reeves",
title = "Exceptions and debugging [in {C++}]",
journal = j-C-PLUS-PLUS-REPORT,
volume = "8",
number = "10",
pages = "63--71",
month = nov # "-" # dec,
year = "1996",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6150G (Diagnostic, testing, debugging and evaluating
systems); C6110J (Object-oriented programming); C6140D
(High level languages); C6130 (Data handling
techniques)",
keywords = "assert macro; C language; C++ exception handling
mechanism; C++ program debugging; development; error
handling; exception handling; fault; independently
developed components; logic errors; macros;
object-oriented; program debugging; programming;
programming philosophy; runtime errors; software;
software fault tolerance; tolerance",
treatment = "P Practical",
}
@Article{Coplien:1997:PL,
author = "J. O. Coplien",
title = "Pattern languages",
journal = j-C-PLUS-PLUS-REPORT,
volume = "9",
number = "1",
pages = "15--21",
month = jan,
year = "1997",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6140D (High level languages); C6110J (Object-oriented
programming)",
corpsource = "Dept. of Software Production Res., Bell Labs.,
Naperville, IL, USA",
keywords = "architectural; contexts; generativity; object-oriented
languages; pattern catalog; pattern languages; style",
treatment = "G General Review",
}
@Article{Onion:1997:FCF,
author = "F. Onion and A. Harrison",
title = "Framework class factories",
journal = j-C-PLUS-PLUS-REPORT,
volume = "9",
number = "1",
pages = "22--24",
month = jan,
year = "1997",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6120 (File
organisation); C6140D (High level languages)",
keywords = "abstract data types; C language; C++ application
frameworks; CDocTemplate class; class instantiation;
dynamic document object creation; file opening;
framework class factories; MacApp framework; MFC
framework; microcomputer applications; object-oriented
languages; object-oriented programming; templates; user
intervention; user-defined document; virtual
construction",
treatment = "P Practical",
}
@Article{Hansen:1997:HRC,
author = "M. Hansen",
title = "How to reduce code bloat from {STL} containers",
journal = j-C-PLUS-PLUS-REPORT,
volume = "9",
number = "1",
pages = "34--41",
month = jan,
year = "1997",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages); C6150C (Compilers, interpreters and
other processors); C6115 (Programming support)",
keywords = "3.1; adapter template; C language; C++ templates; code
bloat reduction; compile-time complexity; compiler;
components; design-time complexity; executable file
size; generated class; generic class; generic
programming; instantiation; Microsoft Windows;
object-oriented; object-oriented languages; program
compilers; programming; software libraries; Standard
Template Library; STL containers; template container",
treatment = "P Practical",
}
@Article{Martin:1997:JCC,
author = "R. C. Martin",
title = "Java and {C++}: a critical comparison",
journal = j-C-PLUS-PLUS-REPORT,
volume = "9",
number = "1",
pages = "42--49",
month = jan,
year = "1997",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6140D (High level languages); C6110J (Object-oriented
programming)",
keywords = "C language; C++ language; Java; language design
trade-offs; object-oriented languages",
treatment = "G General Review",
}
@Article{Jain:1997:ECC,
author = "P. Jain and D. C. Schmidt",
title = "Experiences converting a {C++} communication software
framework to {Java}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "9",
number = "1",
pages = "50--66",
month = jan,
year = "1997",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110B (Software engineering techniques); C6155
(Computer communications software); C6140D (High level
languages); C6110J (Object-oriented programming)",
corpsource = "Washington Univ., St. Louis, MO, USA",
keywords = "C language; C++ communication software framework;
computer communications software; engineering;
features; flexibility; Java programming; language;
language constructs; language features; object-;
object-oriented programming; object-oriented
programming language; oriented languages; portability;
reverse; run-time; semantics; simplicity; software
conversion; software libraries; software portability;
standard library components",
treatment = "A Application",
}
@Article{Glass:1997:JGL,
author = "G. Glass",
title = "The {Java Generic Library}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "9",
number = "1",
pages = "70--74",
month = jan,
year = "1997",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6115 (Programming support); C6110J (Object-oriented
programming); C6140D (High level languages)",
keywords = "containers; design goals; development systems;
Internet; Internet distribution; Java Development Kit;
Java Generic Library; JGL; object-oriented languages;
reusable; reusable algorithms; software libraries;
software tools; Standard Template Library; STL design
philosophy",
treatment = "P Practical",
}
@Article{Stewart:1997:DEH,
author = "R. L. Stewart and J. Storey and D. Huang",
title = "Decentralized event handling",
journal = j-C-PLUS-PLUS-REPORT,
volume = "9",
number = "2",
pages = "12--19",
month = feb,
year = "1997",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6150N (Distributed systems software); C6110J (Object-
oriented programming)",
keywords = "callback mechanism; CORBA-based TMN; decentralized
event handling; distributed object-oriented
applications; distributed processing; dynamic control
flow configuration; Framework; inheritance; methods;
network; object-oriented; run-time; TCSI;
telecommunication network management;
telecommunications management; telephony; telephony
network; TMN",
treatment = "P Practical",
}
@Article{Kreft:1997:BIS,
author = "K. Kreft and A. Langer",
title = "Building an iterator for {STL} and the {Standard C++
Library}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "9",
number = "2",
pages = "20--27",
month = feb,
year = "1997",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6115
(Programming support); C6140D (High level languages)",
keywords = "C language; compile-time; iterator; object oriented;
object oriented language; object-oriented;
object-oriented languages; polymorphism; program
compilers; programming; reusability; software; software
libraries; software reuse; Standard C++ Library; STL;
user-defined abstractions",
treatment = "P Practical",
}
@Article{Hamilton:1997:UDS,
author = "J. Hamilton",
title = "Using {Distributed SOM} with {DirectToSOM C++}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "9",
number = "2",
pages = "28--36",
month = feb,
year = "1997",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages); C6150N (Distributed systems
software); C6150C (Compilers, interpreters and other
processors)",
keywords = "application writing; binary compatibility; C language;
C++ language semantics; C++ language syntax; C++
programming; class client; CORBA standards; DirectToSOM
C++; DirectToSOM C++ compilers; distributed C++;
distributed processing; Distributed SOM; IBM System
Object Model; independent object model; interlanguage
object sharing; language-; languages; Management Group
Common Object Request Broker standards; networks;
Object; object-oriented; object-oriented programming;
object-oriented programming languages; program
compilers; release-to-release; software standards",
treatment = "P Practical",
}
@Article{Schmidt:1997:OES,
author = "D. C. Schmidt and S. Vinoski",
title = "The {OMG Events Service}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "9",
number = "2",
pages = "37--46",
month = feb,
year = "1997",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C7120 (Financial computing); C6110J (Object-oriented
programming); C6110F (Formal methods); C6150N
(Distributed systems software)",
keywords = "changing stock; client-server systems; consumers;
decoupled communication; event data delivery; financial
data processing; inter-object; notifying stock quoter;
object-; object-oriented programming; OMG Common Object
Services Specification Volume 1.2; OMG Events Service;
oriented methods; stock markets; suppliers; values",
treatment = "P Practical",
}
@Article{Vlissides:1997:TL,
author = "J. Vlissides",
title = "Type laundering",
journal = j-C-PLUS-PLUS-REPORT,
volume = "9",
number = "2",
pages = "47--52",
month = feb,
year = "1997",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6140D (High
level languages); C6120 (File organisation)",
corpsource = "IBM Thomas J. Watson Res. Center, Hawthorne, NY, USA",
keywords = "abstract base class; abstract data types; C language;
design bug; domain-specific events; Event; features;
lost type information recovery; object-oriented
languages; object-oriented programming; storage
management; type laundering",
treatment = "P Practical",
}
@Article{Martin:1997:LS,
author = "R. C. Martin",
title = "Large-scale stability",
journal = j-C-PLUS-PLUS-REPORT,
volume = "9",
number = "2",
pages = "54--60",
month = feb,
year = "1997",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6110S (Software
metrics); C6110B (Software engineering techniques);
C6110F (Formal methods)",
keywords = "C language; conformance measurement; design pattern;
interdependence; large C++ applications; large-scale
stability; methods; metrics; object-oriented;
object-oriented design; object-oriented languages;
object-oriented programming; quality measurement;
software metrics; software quality",
treatment = "P Practical",
}
@Article{Barton:1997:GT,
author = "J. J. Barton and L. R. Nackman",
title = "Generating and transforming",
journal = j-C-PLUS-PLUS-REPORT,
volume = "9",
number = "2",
pages = "62--64",
month = feb,
year = "1997",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Tue Mar 25 13:34:48 MST 1997",
acknowledgement = ack-nhfb,
classcodes = "C6110J (Object-oriented programming); C6120 (File
organisation); C7490 (Computing in other engineering
fields); C7300 (Natural sciences computing); C4185
(Finite element analysis)",
corpsource = "IBM Thomas J. Watson Res. Center, Hawthorne, NY, USA",
keywords = "ANSI standards; C language; classes; computing; data
structure manipulation; data structures; engineering;
engineering programming; FORTRAN-formatted
finite-element mesh; input stream iterators; ISO
standards; mesh; mesh generation; natural sciences;
object-oriented; object-oriented languages;
programming; representation; scientific programming;
software standards; template-based ANSI/ISO
collection",
treatment = "P Practical",
}
@Article{Martin:1997:TAP,
author = "R. C. Martin and J. W. Newkirk and B. Rao",
title = "Taskmaster: an architecture pattern for {GUI}
applications",
journal = j-C-PLUS-PLUS-REPORT,
volume = "9",
number = "3",
pages = "12--14, 16--23",
month = mar,
year = "1997",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Thu Apr 24 09:46:14 MDT 1997",
acknowledgement = ack-nhfb,
classification = "C6180G (Graphical user interfaces); C6115
(Programming support); C6110J (Object-oriented
programming); C6110B (Software engineering
techniques)",
keywords = "graphical user interfaces; object-oriented
programming; software maintenance; software
reusability; user interface management systems;
Taskmaster; architecture pattern; GUI applications;
graphical user interface; object oriented design;
software maintenance; software reuse; system
requirements; data manipulation; software architecture;
high-level abstractions",
treatment = "P Practical",
}
@Article{Thompson:1997:TPC,
author = "P. Thompson and G. Bumgardner",
title = "{Threads.h++}: a portable {C++} library for
multithreaded programming",
journal = j-C-PLUS-PLUS-REPORT,
volume = "9",
number = "3",
pages = "24--37",
month = mar,
year = "1997",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Thu Apr 24 09:46:14 MDT 1997",
acknowledgement = ack-nhfb,
classification = "C6115 (Programming support); C6110J (Object-oriented
programming); C6150J (Operating systems); C6110B
(Software engineering techniques)",
keywords = "application program interfaces; C language;
multiprogramming; object-oriented languages;
object-oriented programming; software libraries;
software portability; synchronisation; Threads.h++;
portable C++ library; multithreaded programming;
application development; multiprocessor machines;
responsive performance; Web browsers; operating
systems; synchronization; low-level procedural API; C
language; thread creation; thread control;
object-oriented abstractions",
treatment = "P Practical",
}
@Article{Jakubik:1997:PPA,
author = "P. Jakubik",
title = "Patterns in practice: abstract client",
journal = j-C-PLUS-PLUS-REPORT,
volume = "9",
number = "3",
pages = "38--44",
month = mar,
year = "1997",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Thu Apr 24 09:46:14 MDT 1997",
acknowledgement = ack-nhfb,
classification = "C6110J (Object-oriented programming); C6140D (High
level languages)",
keywords = "abstract data types; C language; object-oriented
languages; object-oriented programming; abstract client
pattern; object oriented patterns; object interaction;
callbacks; C++ programming",
treatment = "P Practical",
}
@Article{Langer:1997:COO,
author = "A. Langer and K. Kreft",
title = "Combining object-oriented design and generic
programming",
journal = j-C-PLUS-PLUS-REPORT,
volume = "9",
number = "3",
pages = "45--49, 69",
month = mar,
year = "1997",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Thu Apr 24 09:46:14 MDT 1997",
acknowledgement = ack-nhfb,
classification = "C6110J (Object-oriented programming); C6115
(Programming support); C6140D (High level languages)",
keywords = "C language; data structures; object-oriented
languages; object-oriented programming; software
libraries; software reusability; object-oriented
design; generic programming; Standard C++ Library; data
structures; internationalization; stream input-
output",
treatment = "P Practical",
}
@Article{Onion:1997:MM,
author = "F. Onion",
title = "Multithreading in {MFC}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "9",
number = "3",
pages = "50--53, 56",
month = mar,
year = "1997",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Thu Apr 24 09:46:14 MDT 1997",
acknowledgement = ack-nhfb,
classification = "C6110J (Object-oriented programming); C6150J
(Operating systems); C6115 (Programming support)",
keywords = "application program interfaces; multiprogramming;
object-oriented programming; software libraries;
software tools; user interfaces; MFC; multithreaded
programming; Internet queries; remote database hits;
threads; API calls; Windows; software libraries; object
oriented programming; user interface",
treatment = "P Practical",
}
@Article{Reeves:1997:RE,
author = "J. W. Reeves",
title = "Reflections on exceptions",
journal = j-C-PLUS-PLUS-REPORT,
volume = "9",
number = "3",
pages = "57--65",
month = mar,
year = "1997",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Thu Apr 24 09:46:14 MDT 1997",
acknowledgement = ack-nhfb,
classification = "C6110J (Object-oriented programming); C6140D (High
level languages); C6130 (Data handling techniques)",
keywords = "C language; exception handling; object-oriented
languages; object-oriented programming; program
debugging; exception handling; debugging; Standard C++;
development environment; assert macros; object oriented
programming",
treatment = "P Practical",
}
@Article{Davis:1997:WMO,
author = "M. Davis",
title = "Well-mannered objects: tips on porting {C++} to Java",
journal = j-C-PLUS-PLUS-REPORT,
volume = "9",
number = "4",
pages = "14--21",
month = apr,
year = "1997",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Thu Apr 24 09:46:14 MDT 1997",
acknowledgement = ack-nhfb,
classification = "C6110J (Object-oriented programming); C6140D (High
level languages); C6110B (Software engineering
techniques)",
keywords = "C language; client-server systems; object-oriented
languages; object-oriented programming; software
portability; C++ code porting; Java; turnaround time;
software portability; power; simplicity; World Wide Web
applets; client-server applications; Taligent; Unicode
Analytic package; JavaSoft; JDK 1.1; well-behaved
objects; object classes",
treatment = "P Practical",
}
@Article{Cochran:1997:DRC,
author = "G. Cochran and R. Weisz",
title = "Developing reusable code in the real world: process
and techniques",
journal = j-C-PLUS-PLUS-REPORT,
volume = "9",
number = "4",
pages = "22--31",
month = apr,
year = "1997",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Thu Apr 24 09:46:14 MDT 1997",
acknowledgement = ack-nhfb,
classification = "C6110B (Software engineering techniques); C6110J
(Object-oriented programming)",
corpsource = "The Windward Group, Los Gatos, CA, USA",
keywords = "object-oriented programming; software reusability;
reusable code development; object-oriented programming;
class hierarchies; reusable software; software
development group needs; investment; code analysis;
code design; code implementation",
treatment = "P Practical",
}
@Article{Sime:1997:GPM,
author = "J. Sime",
title = "Guarded pointers: moving smart pointers into
multithreaded systems",
journal = j-C-PLUS-PLUS-REPORT,
volume = "9",
number = "4",
pages = "32--41",
month = apr,
year = "1997",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Thu Apr 24 09:46:14 MDT 1997",
acknowledgement = ack-nhfb,
classification = "C6120 (File organisation); C6110J (Object-oriented
programming); C6150N (Distributed systems software);
C6130 (Data handling techniques)",
keywords = "abstract data types; C listings; concurrency control;
data integrity; exception handling; multiprogramming;
object-oriented programming; safety; guarded pointers;
smart pointers; multithreaded systems; concurrency
control pattern; protection proxy pattern; protected
data resource; thread safety mechanisms; reference
count lock",
treatment = "P Practical",
}
@Article{Martin:1997:DPD,
author = "R. C. Martin",
title = "Design patterns for dealing with dual inheritance
hierarchies in {C++}",
journal = j-C-PLUS-PLUS-REPORT,
volume = "9",
number = "4",
pages = "42--48",
month = apr,
year = "1997",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Thu Apr 24 09:46:14 MDT 1997",
acknowledgement = ack-nhfb,
classification = "C6110J (Object-oriented programming); C6120 (File
organisation); C6140D (High level languages)",
keywords = "C language; inheritance; object-oriented languages;
object-oriented methods; object-oriented programming;
C++ design patterns; dual inheritance hierarchies;
object-oriented applications; separation of concerns;
orthogonal concepts; application-related problems;
pattern language; Rungs of a Dual Hierarchy;
Intelligent Children; Stairway to Heaven; RTTI
Visitor",
treatment = "P Practical",
}
@Article{Soukup:1997:IP,
author = "J. Soukup",
title = "Implementing patterns",
journal = j-C-PLUS-PLUS-REPORT,
volume = "9",
number = "4",
pages = "49--50",
month = apr,
year = "1997",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Thu Apr 24 09:46:14 MDT 1997",
acknowledgement = ack-nhfb,
classification = "C6110J (Object-oriented programming); C6120 (File
organisation); C6110F (Formal methods); C6110B
(Software engineering techniques)",
keywords = "abstract data types; object-oriented methods; software
engineering; structural patterns; software design;
software architecture; high-level concepts;
communication; design patterns; object-oriented data
structures; inheritance; data organization; pointers;
arrays",
treatment = "P Practical",
}
@Article{Shur:1997:EIC,
author = "Jim Shur",
title = "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",
journal = j-C-PLUS-PLUS-REPORT,
volume = "9",
number = "5",
pages = "18--29, 68",
month = may,
year = "1997",
CODEN = "CRPTE7",
ISSN = "1040-6042",
bibdate = "Fri May 02 06:51:43 1997",
}