C++ Cxx-Kurs

Programming in C++
Dr. Bernd Mohr [email protected] Forschungszentrum Jlich Germany
1997 - 2003, Dr. Bernd Mohr, Forschungszentrum Jlich, ZAM Version 19 September 2003
Programming in C++
Contents
1 15 35 53 83 105 129 177 231 261 277
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Basics: The C part of C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . From C to C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Pointer Data Members . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . More on Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . More Class Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Advanced I/O . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Array Redesign . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Programming in C++
Contents
295 333 367 473 507 519
Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . More on Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The C++ Standard Library and Generic Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Advanced C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Object-Oriented Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Class std::string . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Appendix English German Dictionary. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Index. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
i ix
Programming in C++
Introduction
Programming in C++
Dr. Bernd Mohr, FZ Jlich, ZAM
Page 1
Introduction
1979 1982 1983 1984 1985 1987 1988 1989 1990 May Jan Dec Jan Oct Oct Feb Dec Jun Jun Dec Mar May May Jul Nov
Programming in C++
History of C++
Bjarne Stroustrup at AT&T Bell Labs starts working on C with Classes 1st external paper on C with Classes C++ named 1st C++ manual Cfront Release 1.0 (first commercial release) The C++ Programming Language [Stroustrup] Cfront Release 1.2 1st GNU C++ release (1.13) 1st Zortech C++ release Cfront Release 2.0 ANSI X3J16 organizational meeting (Washington, DC) 1st ANSI X3J16 technical meeting (Somerset, NJ) 1st Borland C++ release The Annotated C++ Reference Manual (ARM) [Ellis, Stroustrup] Templates accepted (Seattle, WA) Exceptions accepted (Palo Alto, CA)
Dr. Bernd Mohr, FZ Jlich, ZAM Page 2
Introduction
1991 Jun Jun Oct 1992 Feb Mar May 1993 1995 1996 1997 1998 Mar July Apr Dec Nov Jul 1st ISO WG21 meeting (Lund, Schweden) Cfront Release 3.0 (including templates) 1st DEC C++ release (including templates and exceptions) 1st Microsoft C++ release 1st IBM C++ release (including templates and exceptions) Run-time type identification accepted (Portland, OR) Namespaces accepted (Munich, Germany) 1st Public-Comment Draft ANSI/ISO standard 2nd Public-Comment Draft ANSI/ISO standard Final Draft International Standard (FDIS) for C++
History of C++
The C++ Programming Language (2nd edition) [Stroustrup]
International Standard (ISO/IEC 14882:1998, "Programming Language -- C++")
Many changes in compilers in recent years; expect more buy only up-to-date (reference) books!
Programming in C++
Page 3
Introduction
Up-to-date Books
Up-to-date books on C++ should: have examples using bool and namespace include (at least) a chapter on the C++ Standard Library and STL use string and vector in examples mention RTTI and new-style casts Even better they (especially reference guides) include member templates partial specialization operator new[] and operator delete[] Even more better if they contain / explain the new keyword export
Programming in C++
Page 4
Introduction
C++ legality guides what you can and cant do in C++
C++ Legality Books
Stroustrup, The C++ Programming Language, Third Edition or Special Edition (14th printing), Addison-Wesley, 1997 or 2000, ISBN 0-201-88954-4 or ISBN 0-201-70073-5. Stroustrup, Die C++ Programmiersprache, Dritte Auage or Vierte Auage, Addison-Wesley, 1997 or 2000, ISBN 3-8273-1296-5 or 3-8273-1660-X. Covers a lot of ground; Reference style; Better if you know C Lippman and Lajoie, C++ Primer, Third Edition, Addison-Wesley, 1998, ISBN 0-201-82470-1. Tutorial style; Better for novices Koenig and Moo, Accelerated C++, Addison-Wesley, 2000, ISBN 0-201-70353-X. First-rate introductory book that takes a practical approach to solving problems using C++ Josuttis, Objektorientiertes Programmieren in C++, 2. Auage, Addison-Wesley, 2001, ISBN 3-8273-1771-1.
Programming in C++ Dr. Bernd Mohr, FZ Jlich, ZAM Page 5
Introduction
C++ morality guides what you should and shouldn't do in C++ Meyers, Effective C++, Addison-Wesley, 1992, ISBN 0-201-56364-9.
C++ Morality Books
Covers 50 topics in a short essay format; a must for anyone programming C++ Cline and Lomow, C++ FAQs, Addison-Wesley, 1995, ISBN 0-201-58958-3. Covers 470 topics in a FAQ-like Q&A format (see also on-line FAQ) Examples are complete, working programs rather than code fragments or stand-alone classes
Programming in C++
Page 6
Introduction
C++ legality guides Stroustrup, The Design and Evolution of C++, Addison-Wesley, 1994, ISBN 0-201-54330-3.
Additional (Expert) Reading
Explains the rationale behind the design of C++ and its history plus new features Ellis and Stroustrup, The Annotated C++ Reference Manual, (ARM) Addison-Wesley, 1990, ISBN 0-201-51459-1. The former unofficial official standard on C++ C++ morality guides Meyers, More Effective C++, Addison-Wesley, 1996, ISBN 0-201-63371-X. Covers 35 advanced topics: exceptions, efficiency, often used techniques (patterns) Sutter, Exceptional C++ and More Exceptional C++, Addison-Wesley, 2000 and 2002, ISBN ISBN 0-201-61562-2 and 0-201-70434-X. Provides successful strategies for solving real-world problems in C++
Programming in C++
Page 7
Introduction
FZJ C++ WWW Information Index
C++ on the WWW
http://www.fz-juelich.de/zam/PT/lang/cplusplus.html WWW C++ Information http://www.fz-juelich.de/zam/cxx/
Official C++ On-line FAQ http://www.parashift.com/c++-faq-lite/ The Association of C & C++ Users http://www.accu.org/ Book reviews section with over 2400 books http://www.accu.org/bookreviews/public/
Programming in C++
Page 8
Introduction
Some parts of this C++ course is based on the following sources:
Sources
Dr. Aaron Naiman, Jerusalem College of Technology, Object Oriented Programming with C++ http://hobbes.jct.ac.il/%7Enaiman/c++-oop/ Classes, Pointer Data Members, More on Classes, Array Examples Dr. Roldan Pozo, Karin Remington, NIST, C++ Programming for Scientists http://math.nist.gov/pozo/c++class/ Motivation, From C to C++ Sean A Corfield, OCS, C++ - Beyond the ARM http://www.corfield.org/cplusplus.phtml/ Advanced C++ Meyers, Effective C++ and More Effective C++ Stroustrup, Lippman, Murray, ...
Introduction
Name of the Compiler CC (Sun, HP, SGI, Cray) cxx (DEC) xlC (IBM) g++ (GNU) icpc (Intel) KCC (KAI) . . . Typical Compiler Options (UNIX) -O -g -o file -c -D / -I / -U / -E -L / -l Turn Optimization on Turn Debugging on Specify output file name Create object file only Standard cpp options Standard linker options Source File Names .cc .cpp .C .cxx .h .hh .H .hpp
C++ Compiler
C++ source files C++ header files
Compiling and Linking (UNIX) CC -c main.cpp CC -o prog main.cpp sum.cpp -lm Compiler/Programming Environments Visual Workshop (Sun) VisualAge (IBM) Softbench (HP) ObjectCenter (for Sun, HP) Energize (Lucid for Sun, HP) C++ on PCs (Borland, Microsoft, ...) CodeWarrier (Macs, Windows, Unix)
Page 10
Programming in C++
Introduction
Some General Remarks "C++: The Cobol of the 90s"
C++ is a very powerful and complex programming language hard to learn and understand can easily be mis-used, easy to make errors but It is an illusion that you can solve complex, real-world problems with simple tools You need to know the dark sides / disadvantages so you can avoid them this is why for C++ the Morality Books are important What you dont use, you dont pay for (zero-overhead rule) It is easy / possible just to use the parts of C++ you need or like non object-oriented subset only use (class / template) libraries concrete data types ("simple classes") only ...
Introduction
Procedural Programming
Programming Paradigms
[Fortran77, Pascal, C]
Decide what procedures you want; use the best algorithms you can find focus on algorithm to perform desired computation Modular Programming (Data Hiding Principle) Group data with related functions Abstract Data Types (ADT) if more than one object of a type (module) is needed Object Oriented Programming [Simula, Eiffel, Java, C++] [Ada, Clu, Fortran90, C++] [Modula-2, C++]
Decide which modules you want; partition the program so that data is hidden in modules
Decide which types you want; provide a full set of operations for each type
Decide which classes you want; provide a full set of operations for each class; make commonality explicit by using inheritance Generic Programming Decide which classes you want; provide a full set of operations for each class; make commonality of classes or methods explicit by using templates
[Eiffel, C++]
Introduction
C++ is NOT an object-oriented language but
ANSI C and C++
C++ is a multi-paradigm programming language with a bias towards systems programming that supports data abstraction supports object-oriented programming supports generic programming
is a better C "as close to C as possible but no closer" [Stroustroup / Koenig, 1989]
ANSI C89 is almost a subset of C++ (e.g. all examples of [K&R2] are C++!) This is not true for ANSI C99!
Programming in C++
Page 13
Programming in C++
Page 14
Programming in C++
Basics: The C part of C++
Programming in C++
Page 15
Basics
C++ is format-free (like Pascal; Fortran: line-oriented) int *iptr[20]; the same as int*
General Remarks
iptr [ 20 ];
is case-sensitive foo and Foo or FOO are all distinct identifiers! keywords are written lower-case switch, if, while, ... semicolon is statement terminator (Pascal and Fortran: statement separator) if ( expr ) { statement1; statement2; }
Basics
ANSI C Boolean Character Integer (int) char, wchar_t short int int long int float double (in C99) Pascal boolean char integer
Basic Data Types

Fortran logical character(n) integer
FloatingPoint Complex
real
real complex
Size of data types in ANSI C is implementation defined but: short int long and float double ANSI C has also signed and unsigned qualifiers ANSI C has no special boolean type (uses int instead), but C++ now has: bool Fortran also supports different size for integer or real, e.g.,
integer,parameter :: short = selected_int_kind(4) integer(short) :: i
Basics
ANSI C Boolean Character String Integer Integer (octal) Integer (hexdecimal) FloatingPoint Complex 0, (nonzero) c "foo" 456, -9 0177 0xFF, 0X7e 3.89, -0.4e7 Pascal false, true c foo 456, -9 3.89, -0.4e7 Fortran
Literals
.false., .true. c or "c" foo or "foo" 456, -9 3.89, -0.4e7 (-1.0,0.0)
ANSI C has no special boolean type (uses int instead), but C++ now has: bool with constants true and false ANSI C characters and strings can contain escape sequences (e.g. \n, \077, \xFF) ANSI C also has suffix qualifiers for numerical literals: F or f (float), L or l (double / long), U or u (unsigned)
Basics
ANSI C Pascal const PI = 3.1415; SP = ; NEG_PI = -PI; Fortran
Declarations
const const const const
double PI=3.1415; char SP= ; double NEG_PI=-PI; double TWO_PI=2*PI;
real,parameter::PI=3.1415 character,parameter::SP= real,parameter::NEG_PI=-PI real,parameter::TWO_PI=2*PI
typedef int Length; enum State { error, warn, ok }; int a, b; double x; enum State s; int i = 396;
type Length = integer; State = (error, warn, ok); var a, b : integer; x : real; s : State;
integer a, b real x integer::i = 396
ANSI C and Fortran: declarations in any order ANSI C is case-sensitive:

Programming in C++
foo and Foo or FOO are all distinct identifiers!

Basics
ANSI C Numeric Ops Division Modulus Exponentation Incr/Decrement Bit Operators Shift Operators Arith. Comparison Equality Unequality Logical Operators +, -, * / (real) / (int) % ++, -~, ^, &, | <<, >> <, <=, >, >= == != &&, ||, ! Pascal +, -, * / div mod <, <=, >, >= = <> and, or, not
Expressions / Operators
Fortran +, -, * / / mod or modulo ** not, ieor, iand, ior ishft <, <=, >, >= == /= .and., .or., .not. (.eqv. , .neqv.)
Pascal also has sets and corresponding set operators (+, -, *, in, =, <>, <=, >=) ANSI C also has ?: and , operators ANSI C also has short-cuts: a = a op b; can be written as a op= b; ANSI C Precedence rules complicated! Practical rule: * and / before + and -; put parenthesis, (), around anything else!
Basics
ANSI C typedef int Nums[20]; Pascal type Nums = array [0..19] of integer; var c : array [0..9] of char; p, q : Nums; a : array [0..1,0..2] of real; p[4] := -78; a[0,2] := 2.3; Fortran
Arrays
char c[10]; Nums p, q; float a[2][3]; p[4] = -78; a[0][1] = 2.3;
character,dimension(0:9):: c integer,dimension(0:19):: p, q real,dimension(0:1,0:2):: a p(4) = -78 a(0,2) = 2.3
ANSI C arrays always start with index 0, Fortran with default index 1 Pascal and Fortran allow array assignment between arrays of same type Arrays cannot be returned by functions in ANSI C and Pascal ANSI C: a[0,1] is valid expression but a[0,1] a[0][1]!
Basics
ANSI C Pascal Fortran
Records
typedef struct { int level; float temp, press; int lights[5]; } Engine; Engine m1, m2; printf ("%d",m1.level); m2.temp += 22.3; m1.lights[2] = 0;
type Engine = record type Engine level : integer; integer:: level temp, press : real; real:: temp, press lights : array [0..4] integer:: lights(0:4) of integer; end; end type Engine var m1, m2 : Engine; write(m1.level); m2.temp := m2.temp+22.3; m1.lights[2] := 0; type(Engine):: m1, m2 write(*,*) m1%level m2%temp = m2%temp+22.3 m1%lights(2) = 0
Pascal records cannot be returned by functions
Programming in C++
Page 22
Basics
struct names form a separate namespace: struct Engine { int level; float temp, press; int lights[5]; }; usage in declarations and definitions requires keyword struct: struct Engine m1, m2;
typedef of structs
typedef and struct declarations can be combined into one construct: typedef struct Engine { int level; float temp, press; int lights[5]; } Engine; Typically, inner struct declaration needs no name: typedef struct { int level; float temp, press; int lights[5]; } Engine;
typedef can be used to shorten declarations and definitions: typedef struct Engine Engine; Engine m1, m2;
Programming in C++
Page 23
Basics
ANSI C int i; int *a; char *b, *c; Engine *mp; a = &i; *a = 3; b = 0; mp = malloc( sizeof(Engine)); (*mp).level = 0; mp->level = 0; free(mp); var a : ^integer; b, c : ^char; mp : ^Engine; a^ := 3; b := nil; new(mp); mp^.level := 0; dispose(mp); Pascal Fortran integer,target :: i
Pointers
integer,pointer :: a character,pointer :: b, c type(Engine),pointer :: mp a => i a = 3 nullify(b) allocate(mp) mp%level = 0 deallocate(mp)
ANSI C uses constant 0 as null pointer (often with #define NULL 0) ANSI C provides -> short-cut because precedence of the dot is higher than that of * Fortran 95 has: b => null()
Basics
long numbers[5];
ANSI C (and C++) Arrays and Pointers

numbers: numPtr:
long *numPtr = &(numbers[1]); Dereferencing and pointer arithmetic: *numPtr += 2; numPtr += 2; Similarities
/* numbers[1] += 2;
*/
/* numPtr = &(numbers[3]); */
The array name by itself stands for a constant pointer to its first element if (numbers == numPtr) { /*...*/ } Can use array (array[i]) and pointer syntax ( *(array + i) ) for both numPtr[1] = *(numbers + 2); Differences numbers only has an rvalue: refers to address of beginning of array and cannot be changed numPtr also has an lvalue: a (long *) is allocated and can be set to address of a long
Programming in C++ Dr. Aaron Naiman, JCT + Dr. Bernd Mohr, FZ Jlich Page 25
/* == 2[numbers] :-) */
Basics
ANSI C #include "le" Pascal
Program Structure
Fortran include le module Global global constant, variable decls contains function, procedure decls end module program AnyName ! Fortran comment use Global
global constant, type, variable, function and procedure declarations (* Pascal comment1 *) int main() /* C comment */ program AnyName; { Pascal comment2 } global constant, type, variable, function and procedure declarations begin statements end.
{ local declarations statements }
local declarations statements end [program]
ANSI C and Fortran: declarations in any order

Basics
ANSI C int F(double x, int i) Pascal function F(x:real; n:integer):integer; Fortran
Functions
{ local decls statements incl. return expr; } int j; j = 3 * F(2.0, 6);
local decls begin statements incl. F := expr; end; var j:integer; j := 3 * F(2.0, 6);
function F(x,n) integer F integer n real x local decls statements incl. F = expr return end integer j j = 3 * F(2.0, 6)
Pascal allows the definition of local functions, Fortran too with contains (but 1 level only) Default parameter passing: C and Pascal: by value Fortran: by reference Output parameters: C: use pointers Pascal: var Fortran allows additional attributes for parameters: intent and optional
Basics
ANSI C void F(int i) Pascal procedure F(i:integer); local decls begin statements end; Fortran
Procedures
subroutine F(i) integer i local decls statements return end
{ local decls statements }
F(6);
F(6);
call F(6)
Pascal allows the definition of local procedures, Fortran too with contains (but 1 level only) Default parameter passing: C and Pascal: by value Fortran: by reference Output parameters: C: use pointers Pascal: var Fortran allows additional attributes for parameters: intent and optional
Programming in C++
Page 28
Basics
ANSI C if (a<0) negs = negs + 1; if (x*y < 0) { x = -x; y = -y; } if (t == 0) printf("zero"); else if (t > 0) printf("greater"); else printf("smaller"); Pascal if a < 0 then negs := negs + 1; if x*y < 0 then begin x := -x; y := -y end; if t = 0 then write(zero) else if t > 0 then write(greater) else write(smaller); Fortran
Selection
if (a < 0) [then] negs = negs + 1 if (x*y < 0) then x = -x y = -y end if if (t == 0) then write(*,*) zero else if (t > 0) then write(*,*) greater else write(*,*) smaller
Semicolon is statement terminator in ANSI C, statement separator in Pascal Dont mix up assignment (=) and equality test (==) in ANSI C, as assignment is an expression (not a statement) and therefore, if (a = b) {...} is valid syntax!
Basics
ANSI C switch (ch) { case Y: /*NOBREAK*/ case y: doit = 1; break; case N: /*NOBREAK*/ case n: doit = 0; break; default : error(); break; } Pascal case ch of Y, y: doit := true; N, n: doit := false; otherwise error() end;
Multiway Selection
Fortran select case (ch) case (Y,y) doit = .true. case (N,n) doit = .false case default call error() end select
otherwise (also: else) not part of standard Pascal but common extension ANSI C only doesnt allow multiple case labels but this can be implemented by "fall-trough" property Fortran allows ranges in case labels:
Programming in C++
case (a : z, A : Z)
Page 30
Basics
ANSI C for (i=0; i<n; i++) { statements } for (i=n-1; i>=0; i--) { statements } for (i=b; i<e; i+=s) { statements } Pascal for i:=0 to n-1 do begin statements end; for i:=n-1 downto 0 do begin statements end;
Indexed Iteration
Fortran do i=0,n-1 statements end do do i=n-1,0,-1 statements end do do i=b,e-1,s statements end do
In Pascal and Fortran, the control variable (e.g. i) cannot be changed in the loop body Pascal has no support for step != 1 or -1, has to be written as while loop The ANSI C for loop is actually more powerful as shown here
Programming in C++
Page 31
Basics
ANSI C while (expr) { statements } do { statements } while (!expr); for / while / do { continue; statements break; } Pascal while expr do begin statements end; repeat statements until expr;
Controlled-Exit Iteration
Fortran do while (expr) statements end do do statements if (expr) exit end do do cycle statements exit end do
expr in ANSI C do loop must be the negated expr of the corresponding Pascal repeat loop
Programming in C++
Page 32
Basics
Style
As C and C++ are (like many others) format-free programming languages, it is important to program in a consistent style in order to maintain readable source code. One statement per line! Useful comments and meaningful variable/function names double length; /* measured in inch */ Indention style (two major styles popular): int func(int i) { if (i > 0) { return 1; } else { return 0; } } Naming of programming language objects const int MAX_BUF = 256; int my_buffer[MAX_BUF]; int get_buffer();
Programming in C++
int func(int i) { if (i > 0) { return 1; } else ...
const int MAXBUF = 256; int myBuf[MAXBUF]; int getBuffer();

Basics
Access to Command Line Arguments
Programmer has access to command line arguments through two parameters to main() int argc: char *argv[]: argv[0]: argv[1]: ... argv[argc]: number of command line arguments (including name of executable) array of command line arguments (as character strings) name of executable first command line argument always (char *) 0
Command line parsing should be done via UNIX system function getopt() int c, a_flag = 0; while ((c = getopt(argc, argv, "ab:")) != EOF) switch (c) { case a: aflag = 1; break; case b: b_arg = optarg; break; case ?: /* error ... */ break; } for ( ; optind < argc; optind++) next_arg = argv[optind];
Programming in C++
Motivation
Programming in C++
Page 35
Motivation
a small, simple language (by design) boils down to macros, pointers, structs, and functions ideal for short-to-medium size programs and applications lots of code and libraries written in C good efficiency (a close mapping to machine architecture) very stable (ANSI/ISO C) available for pretty much every computer writing of portable programs possible ANSI C and basic libraries (e.g. stdio) are portable however, operating system dependencies require careful design C preprocessor (cpp) is a good, close friend
Features of ANSI C
poor type-checking of K&R C (especially function parameters) addressed by ANSI C so, whats the problem? Why C++?
Dr. Roldan Pozo, NIST
Programming in C++
Page 36
Motivation
Goal: create some C code to manage a stack of numbers
Example: a Stack
a stack is a simple first-in/last-out data structure resembling a stack of plates: elements are removed or added only at the top elements are added to the stack via a function push() elements are removed from the stack via pop() stacks occur in many software applications: from compilers and language parsing, to numerical software one of the simplest container data structures sounds easy enough...
Programming in C++ Dr. Roldan Pozo, NIST Page 37
Motivation
typedef struct { float v[20]; int top; } Stack; Stack *init(void) { Stack *r = malloc(sizeof(Stack)); r->top = 0; return r; } void push(Stack *S, float val) { S->v[(S->top)++] = val; } float pop(Stack *S) { return(S->v[--(S->top)]); } int empty(Stack *S) { return (S->top <= 0); }
Programming in C++ Dr. Roldan Pozo, NIST
Simple Stack in C
19
3 2 1 0 v[20]
top
void finish(Stack *S) { free(S); }

Page 38
Motivation
Using the Stack data structure in C programs Stack *S; S = init(); push(S, 2.31); push(S, 1.19); printf("%g\n", pop(S)); push(S, 6.7); push(S, pop(S) + pop(S));
Simple Stack in C
/* initialize /* push a few elements /* on the stack... /* use return value in /* expressions...
*/ */ */ */ */
/* replace top 2 elements */ /* by their sum */
void MyStackPrint(Stack *A) { int i; if (A->top == 0) printf("[empty]"); else for (i=0; i<A->top; i++) printf(" %g", A->v[i]); } so whats wrong with this?
Motivation
A few gotchas... Stack *A, *B; float x, y; push(A, 3.1415); A = init(); x = pop(A);
Simple Stack Problems
/* oops! forgot to initialize A /* error: A is empty! /* stack is now in corrupt state /* xs value is undefined... /* dont do this! */
*/ */ */ */
A->v[3] = 2.13; A->top = -42; push(A, 0.9); push(A, 6.1); B = init(); B = A; finish(A);
/* OK, assuming As state is valid*/
/* lost old B (memory leak) /* oops! just wiped out A and B
*/ */
Programming in C++
Page 40
Motivation
NOT VERY FLEXIBLE fixed stack size of 20 fixed stack type of float NOT VERY PORTABLE
Simple Stack Problems
function names like empty() and init() likely to cause naming conflicts biggest problem: NOT VERY SAFE internal variables of Stack are exposed to outside world (top, v) their semantics are directly connected to the internal state can be easily corrupted by external programs, causing difficult-to-track bugs no error handling initializing a stack more than once or not at all pushing a full stack / popping an empty stack assignment of stacks (A=B) leads to reference semantics and dangerous dangling pointers
Motivation
typedef struct { float* vals; int top, size; } DStack; DStack *DStack_init(int size) { DStack *r = malloc(sizeof(DStack)); assert (r != 0); r->top = 0; r->size = size; r->vals = malloc(size*sizeof(float)); assert (r->vals != 0); return r; } void DStack_finish(DStack* S) { assert (S != 0); free(S->vals); free(S); S = 0; }
Programming in C++ Dr. Bernd Mohr, FZ Jlich, ZAM
Better Stack in C
Page 42
Motivation
void DStack_assign(DStack* dst, DStack* src) { int i;
Better Stack in C
assert (dst != 0 && src != 0); free(dst->vals); dst->top = src->top; dst->size = src->size; dst->vals = malloc(dst->size*sizeof(float)); assert (dst->vals != 0); for (i=0; i<dst->top; ++i) dst->vals[i] = src->vals[i]; } void DStack_push(DStack* S, float val) { assert (S != 0 && S->top <= S->size); S->vals[S->top++] = val; } float DStack_pop(DStack* S) { assert (S != 0 && S->top > 0); return S->vals[--S->top]; }
Programming in C++
Page 43
Motivation
DStack *DStack_copy(DStack* src) { int i; DStack *r;
Better Stack in C
assert (src != 0); r = malloc(sizeof(DStack)); assert (r != 0); r->top = src->top; r->size = src->size; r->vals = malloc(r->size*sizeof(float)); assert (r->vals != 0); for (i=0; i<r->top; ++i) r->vals[i] = src->vals[i]; return r; } int DStack_empty(DStack* S) { assert (S != 0); return (S->top == 0); }
Programming in C++
Page 44
Motivation
Improvements dynamic size primitive error handling (using assert())
Better Stack in C
function names like DStack_init() less likely to cause naming conflicts
Remaining Problems not flexible regarding to base type of stack dynamic memory allocation requires DStack_finish()or causes memory leak still unsafe New Problems old application code that used S->v no longer works!! copying and assigning DStacks requires DStack_copy() and DStack_assign() or pointer alias problems
Programming in C++
Page 45
Motivation
typedef struct { TYPE *vals; int size, top; } GDStack;
Generic Stack in C (via C preprocessor)
/* Generic(?) Dynamic Stack
*/
void GDStack_push(GDStack *S, TYPE val) {...} How to use: put all source into file GDStack.h in application code do #define TYPE float #include "GDStack.h" GDStack S; #define TYPE int #include "GDStack.h" GDStack S2;
/* Whoa! a stack of floats /* /* /* /* oops! preprocessor warning! macro TYPE redefined error: functions redefined! nice try, but wont work
*/ */ */ */ */
only works if only one type of stack is used in one source le, but that is no good solution...
Motivation
typedef struct { TYPE *vals; int size, top; } GDStack_TYPE;
Generic Stack in C (via editor)
void GDStack_TYPE_push(GDStack_TYPE *S, TYPE val) {...} How to use: put all source into base files GDStack.h and GDStack.c use editors global search&replace to convert TYPE into float or int and store in new files GDStack_float.* and GDStack_int.* in application code do #include "GDStack_float.h" #include "GDStack_int.h" GDStack_float S; GDStack_int S2; GDStack_String T;
/* hey! a stack of floats! /* finally! a stack of ints! /* oops! need some more files...
*/ */ */
works, but is extremely ugly and still has problems...

Motivation
software is constantly being modified better ways of doing things bug fixes algorithm improvements
Reality Check
platform (move from Sun to HP) and environment (new random number lib) changes customer or user has new needs and demands
real applications are very large and complex typically involving more than one programmer you can never anticipate how your data structures and methods will be utilized by application programmers ad-hoc solutions OK for tiny programs, but dont work for large software projects software maintenance and development costs keep rising, and we know its much cheaper to reuse rather than to redevelop code
Programming in C++
Page 48
Motivation
What have we learned from years of software development?
Conclusion
the major defect of the data-structure problem solving paradigm is the scope and visibility that the key data structures have with respect to the surrounding software system So, we would like to have ... DATA HIDING: the inaccessibility of the internal structure of the underlying data type ENCAPSULATION: the binding on an underlying data type with the associated set of procedures and functions that can be used to manipulate the data (abstract data type) INHERITANCE: the ability to re-use code by referring to existing data types in the definition of new ones. The new data type inherits data objects and functionality of the already existing one. OBJECTS
Motivation
There are many object-oriented languages out there, so why C++? compromise between elegance and usefulness Superset of C C in widespread use all C libraries easily usable from C++ Cross-platform availability Mass-market compilers Wide usage on all platforms Popular with programmers Only pay for what you use New ANSI/OSI standard
Why C++?
Page 50
Motivation
So how does C++ help solve our Stack problems?
Solution
provides a mechanism to describe abstract data types by packaging C struct and corresponding member functions together (classes) protects internal data structure variables and functions from the outside world (private and protected keywords) provides a mechanism for automatically initializing and destroying user-defined data structures (constructors and destructors) provides a mechanism for generalizing argument types in functions and data structures (templates) provides mechanism for gracefully handling program errors and anomalies (exceptions) provides mechanism for code reuse (inheritance)
Programming in C++
Page 51
Programming in C++
Page 52
Programming in C++
From C to C++
Programming in C++
Page 53
From C to C++
New Keywords (to C) delete, new class, this, private, public, protected catch, try, throw friend, inline, operator, virtual template Programming in C++
New Keywords
New (to ARM) Used for: Memory Management Classes
mutable typename, export bool, true, false const_cast, static_cast, reinterpret_cast using, namespace typeid, dynamic_cast explicit wchar_t
Exceptions Class member type qualier Templates Boolean datatype New style casts Namespaces RunTime Type Identication Constructor qualier Wide character datatype
Page 54
From C to C++
Alternative: and bitor or xor compl bitand Primary: && | || ^ ~ & Alternative: and_eq or_eq xor_eq not not_eq
Alternative Tokens C99

[iso646.h] Primary: &= |= ^= ! !=
Furthermore, alternative representations are reserved and shall not be used otherwise:
Also, in addition to the trigraphs of ANSI C, C++ supports the following digraphs: Alternative: <% %> %:
Programming in C++
C99
Primary: { } #
Alternative: <: :> %:%:

Primary: [ ] ##
Page 55
From C to C++
New "//" symbol can occur anywhere and signifies a comment until the end of line float r, theta; New "//" comment can be nested // int i = 42; // so is this // this is a comment
Comments C99
Of course, there are the still two other ways to denote comments: with the familiar /* */ pair /* nothing new here... but careful, these do not nest! using the preprocessor via #ifdef, #endif. This is the best method for commenting-out large sections of code. #ifdef CURRENTLY_NOT_NEEDED a = b + c; x = u * v; #endif Remember that the # must be the first non-whitespace character in that line.
*/
From C to C++
Struct / Union
C++ doesn't require that a type name is prefixed with the keywords struct or union (or class) when used in object declarations or type casts. struct Complex { double real, imag; }; Complex c; // has type "struct Complex" A C++ typedef name must be different from any class type name declared in the same scope, except if the typedef is a synonym of the class name with the same name struct Bar { ... }; typedef struct Foo { ... } Bar; typedef struct Foo { ... } Foo; // OK in C, but not C++ // OK in C + C++
In C++, a class declaration introduces the class name into the scope where it is declared and hides any object, function or other declaration of that name in an enclosing scope. In C, an inner scope declaration of a struct tag name never hides an object in an outer scope int x[99]; void f(){ struct x { int a; }; sizeof(x); // sizeof the array in C, sizeof the struct in C++ }
From C to C++
double sum(const double x[], int N) { printf("entered function sum().\n"); double s = 0; int i = 42;
Movable Declarations C99
Local variable declarations in C++ need not be congregated at the beginning of functions:
// note the declarations here...
for (int i=0; i<N; i++) { // also notice the declaration of s += x[i]; // loop variable "i" } int j = i; // j == 42!! return s; } declare variables close to the code where they are used and where they can be initialized particularly useful in large procedures with many local variables this improves code readability and helps avoid type-mismatch errors Note: scope of i in for loop changed in C++ standard! (was: until end of block: now: end of loop) !
From C to C++
C++ allows to specify default arguments for user-defined functions
Default Arguments
default value can either specified in function declaration or definition, but not in both (by convention) this is specified in the function declaration in a header file //myfile.h extern double my_log(double x=1.0, double base=2.71828182845904); //myfile.cpp #include "myfile.h" double my_log(double x, double base) {...} //main.cpp #include "myfile.h" double y = my_log(x); double z = my_log(x, 10); // defaults to log_e // computes log_10
arguments to the call are resolved positionally initialization expression needs not to be constant use only if default values are intuitively obvious and are documented well! the order of evaluation of function arguments (and so their initialization) is unspecified!
From C to C++
References
C++ introduces a new type: reference types. A reference type (sometimes also called an alias) serves as an alternative name for the object with which it has been initialized. a reference type acts like a special kind of pointer. Differences to pointer types: a reference must be initialized (must always refer to some object, i.e., no null reference) no need to test against 0 once initialized, it cannot changed syntax to access reference object is the same as for "normal" objects /* references */ int i = 5, val = 10; int &refVal = val; int &otherRef; refVal++; refVal = i; refVal++; //error! //val/refVal now 11 //val/refval now 5 //val/refVal now 6 /* pointers */ int i = 5, val = 10; int *ptrVal = &val; int *otherPtr; //OK (*ptrVal)++; ptrVal = &i; //val still 11 (*ptrVal)++; // i now 6!
The primary use of a reference type is as an parameter type or return type of a function. They are rarely used directly.
From C to C++
Passing Arguments by Value

void func(int p) { int a = p + 5; p = 7; } int i = 3; func(i); ... /*3*/ 3 i: 3 /*4*/ i: 3
/*3*/ /*1*/ /*2*/ /*4*/ /*1*/ i: Stack: ? ? SP p: a: 3 /*2*/ i:
3 ?
p: a: SP
7 8
7 8 SP
SP
Programming in C++
Page 61
From C to C++
void func(int* p) { int a = *p + 5; *p = 7; } int i = 3; func(&i); ...
Passing Arguments by Reference

void func(int& p) { int a = p + 5; p = 7; } int i = 3; func(i); ...
/*3*/ /*1*/ /*2*/ /*4*/
/*1*/ i: Stack: ? ? SP 3
/*2*/ i: 3
/*3*/ i: 7
/*4*/ i: 7
p: a: ?
p: a: SP
SP 8 8 SP
Programming in C++
Page 62
From C to C++
Function parameters in C (and C++) are always passed by value
Reference Parameters
therefore, output parameters (and structures/arrays for efficiency) have to be passed as pointers caller has to remember to pass the address of the argument (error-prone!) callee has to use * and -> to access parameters in function body (clumsy!) Reference parameters are denoted by & before function argument (like VAR in PASCAL) void print_complex(const Complex& x) { printf("(%g+%gi)", x.real, x.imag); } Complex c; c.real = 1.2; c.imag = 3.4; print_complex(c); // note missing &, prints "(1.2+3.4i)" Side note: const is necessary to allow passing constants/literals to the function reference parameters are only a special case of reference types references cannot be uninitialized if you need NULL values as parameters, you have to use pointers
From C to C++
Inline Functions C99
Aim of inline functions is to reduce the overhead associated with a function call. The effect is to substitute inline each occurrence of the function call with the text of the function body. inline double max(double a, double b) { return (a > b ? a : b ); } inline int square(int i) { return (i*i); } They are used like regular functions.
Advantages: removes overhead; provides better opportunities for further compiler optimization Disadvantages: increases code size; reduces efficiency if abused (e.g. code no longer fits cache) The inline modifier is simply a hint, not a mandate to the C++ compiler. Functions which define arrays are recursive or from with address is taken contain statics, switches, (gotos) are typically not inlined.
From C to C++
Function Overloading
In C++, function argument types, as well as the function name, are used for identification. This means it is possible to define the same function with different argument types. For example, void swap(Complex& i, Complex& j) { Complex t; t = i; i = j; j = t; } void swap(int& i, int& j) { int t; t = i; i = j; j = t; } void swap(int *i, int *j) { int t; t = *i; *i = *j; *j = t; } Complex u, v; swap(u, v); swap(i, j); swap(&i, &j);
Programming in C++
// possible, but should be avoided // why? what happens if you pass 0?
int i, j; // calls Complex version // calls integer reference version // calls integer pointer version
Dr. Roldan Pozo, NIST Page 65
From C to C++
Function Overloading
overloading cannot be based on the return type! (because it is allowed to ignore returned value) use overloaded functions instead of #define func(a,b) ... because type-safety avoids problems when body uses parameters more than once or has more than one statement #define min(a,b) (a<b?a:b) int i=3, j=5, k=min(i++, j); // i now 5!!!
unfortunately, overloaded functions are not as generic as macros, but function templates (more on that later) fix that problem nicely: template<class T> inline void swap(T& i, T& j) { T t; t = i; i = j; j = t; } double x, y; int i, j; swap(x, y); swap(i, j); swap(x, i);
Programming in C++
// compiler generates double version automatically // again for int // error!

From C to C++
void f(); void f(int); f(); // calls f() f(10); // calls f(int); Use argument defaulting when Same algorithm is used for all overloaded functions Appropriate (natural) default argument values exist use function overloading in all other cases Avoid overloading on a pointer and a numerical type
Function Overloading Issues

void g(int x=0); g(); g(10); // calls g(0); // calls g(10);
Choose carefully between function overloading and parameter defaulting
The value 0 used as an actual function argument means int 0 You cannot use the value 0 to represent a null pointer passed as an actual argument A named constant representing "null pointer" (NULL) must be typed void * and must be cast explicitly to a specific pointer type in most contexts (e.g., as function argument) You can declare different named constants to represent "null pointers" for different types
From C to C++
Operator Overloading
Functions arent the only thing that can be overloaded in C++; operators (such as +, *, %, [], ...) are fair game too. Given Complex numbers u, v, w, and z, which is easier to read? w = z * (u + v); or Complex t; C_add(&t, u, v); C_mult(&w, z, t);
How did we do it? Complex operator*(const Complex& a, const Complex& b) { Complex t; t.real = a.real * b.real - a.imag * b.imag; t.imag = a.real * b.imag + a.imag * b.real; return t; } Complex operator+(const Complex& a, const Complex& b) {...} only existing operators can be overloaded; creating new ones (e.g., **) not possible operator precedence, associativity, and "ary-ness" cannot be changed only overload operator if it is "natural" for the given data type (avoid surprises for users!)
From C to C++
Boolean Type C99
The C++ Standard now includes a bool type with the constants true and false
[stdbool.h]
Conditionals (if, while, for, ?:, &&, ||, !) now require a value that converts to bool Comparison and logical operators (==, !=, <, <=, >, >=, &&, ||, !) now return bool Integral and pointer values convert to bool by implicit comparison against zero bool converts to int with false becoming zero and true becoming one Because bool is a distinct type, you can now overload on it void foo(bool); void foo(int); // error on older compilers! now OK
Programming in C++
Page 69
From C to C++
C++ introduces a new concept for handling I/O: file streams. include the C++ header file <iostream> instead of <stdio.h> IOstreams are part of the standard C++ library using namespace std; use the << operator to write data to a stream use the >> operator to read data from a stream
Input/Output
use predefined streams cin, cout, cerr instead of stdin, stdout, stderr #include <iostream> using namespace std; int main(int argc, char *argv[]) { int birth = 1642; char *name = "Issac Newton"; cout << name << " was born " << birth << endl; cout << "What is your birth year? "; if ( ! cin >> birth ) birth = -1; }
From C to C++
Advantages of C++ stream I/O type safety int i = 5; float f = 3.4; printf("%d %f\n", f, i); cout << f << " " << i << endl; extensibility: can be extended for user-defined types
Input/Output
// few compilers catch this! // automatically right
ostream& operator<<(ostream& s, const Complex& x) { s << "(" << x.real << "+" << x.imag << "i)"; // whats wrong? return s; } creates a new way to print Complex numbers in C++: Complex c; c.real=2.1; c.imag=3.6; cout << "c = " << c << endl;
Programming in C++
// prints "c = (2.1+3.6i)"

Page 71
From C to C++
The C way to request dynamic memory from the heap:
Memory Allocation
int *i = (int *) malloc(sizeof(int)); double *d = (double *) malloc(sizeof(double)*NUM); free(d); free(i); The new C++ way: int *i double delete delete = new int; *d = new double[NUM]; [] d; i;
Advantages: type-safe; no type casts needed can be extended for user-defined types handles new int[0]; and delete 0; (takes care of object construction / destruction ) dont mix new/delete with malloc/free [watch out for strdup()! (string duplication)]
From C to C++
Calling C
Because of a C++ feature called name mangling (to support type-safe linking and name overloading), you need a a special declaration to call external functions written in C: extern "C" size_t strlen(const char *s1); It is also possible to declare several functions as extern "C" at once: extern "C" { char *strcpy(char *s1, const char *s2); size_t strlen(const char *s1); } can also be used to "make" a C++ function callable from C How to write header files which can be used for C and C++? #ifdef __cplusplus extern "C" { #endif /* all C declarations come here... #ifdef __cplusplus } #endif
*/
From C to C++
Include Guards
Include guards prevent double declaration errors (no longer allowed in C++) and speed up the compilation Example: lib1.h: lib2.h: main.cpp #include "util.h" ... #include "util.h" ... #include "lib1.h" #include "lib2.h" // ERROR: double declaration // errors for util.h
Use include guards for header files, e.g. util.h: #ifndef UTIL_H #define UTIL_H ... contents of util.h here ... #endif Typically, system header files already use extern "C" and include guards.
From C to C++
Typical C code used the C preprocessor to define symbolic constants: #define PI 3.1415 #define BUFSIZ 1024 Better approach is to use const declarations because it is type-safe compiler knows about it it shows up in the symbol table (debugger knows it too) const float PI = 3.1415; const int BUFSIZ = 1024; static char myBuffer[BUFSIZ];
Constants
// allowed in C++, not in C
Be careful when defining constant strings (note the two const) const char* const programName = "fancy_name_here"; const char* programName = "fancy_name_here"; char* const programName = "fancy_name_here";
//ptr to const char //const pointer

Page 75
From C to C++
In C, union variables or fields have to be named struct foo { union { short i; char ch[2]; } buf; int n; } f; f.buf.i = 0x0001; if (f.buf.ch[0]==0 && f.buf.ch[1]==1) printf("big endian"); else printf("little endian");
Anonymous Unions
In C++, union variables or fields can be anonymous struct foo { union { short i; char ch[2]; }; int n; } f; f.i = 0x0001; if (f.ch[0]==0 && f.ch[1]==1) cout << "big endian"; else cout << "little endian";
Programming in C++
Page 76
From C to C++
More Differences
In C++, a function declared with an empty parameter list takes no arguments. In C, an empty parameter list means that the number and type of the function arguments are "unknown" int f(); // means int f(void) in C++ // int f(unknown) in C
In C++, the syntax for function definition excludes the "old-style" C function. In C, "old-style" syntax is allowed, but deprecated as "obsolescent." void func(i) int i; { ... } instead of void func(int i) { ... }
In C++, types may not be defined in return or parameter types. int i; int i; ("tentative definitions") in the same file is not allowed on C++
Implicit declaration of functions is not allowed Banning implicit int

C99
Page 77
From C to C++
Even More Differences
general expressions are allowed as initializers for static objects (C: constant expressions) sizeof('x') == sizeof(int) in C but not in C++ (typeof x is char) Main cannot be called recursively and cannot have its address taken Converting void* to a pointer-to-object type requires casting It is invalid to jump past a declaration with explicit or implicit initializer static or extern specifiers can only be applied to names of objects or functions (not to types) const objects must be initialized in C++ but can be left uninitialized in C In C++, the type of an enumerator is its enumeration. In C, the type of an enumerator is int. C++ objects of enumeration type can only be assigned values of the same enumeration type. enum color { red, blue, green } c = 1; // valid C, invalid C++
Programming in C++
Page 78
From C to C++
static const int FStack_def_size = 7; struct FStack { float* vals; int top, size; }; FStack *init(int size = FStack_def_size) { FStack *r = new FStack; assert (r != 0); r->top = 0; r->size = size; r->vals = new float[size]; assert (r->vals != 0); return r; } void finish(FStack* S) { assert (S != 0); delete [] S->vals; delete S; S = 0; }
Example FStack
Page 79
From C to C++
Example FStack
void assign(FStack* dst, FStack* src) { assert (dst != 0 && src != 0); delete [] dst->vals; dst->top = src->top; dst->size = src->size; dst->vals = new float[dst->size]; assert (dst->vals != 0); for (int i=0; i<dst->top; ++i) dst->vals[i] = src->vals[i]; } void push(FStack* S, float val) { assert (S != 0 && S->top <= S->size); S->vals[S->top++] = val; } float pop(FStack* S) { assert (S != 0 && S->top > 0); return S->vals[--S->top]; }
Programming in C++
Page 80
From C to C++
Example FStack
FStack *copy(FStack* src) { assert (src != 0); FStack *r = new FStack; assert (r != 0); r->top = src->top; r->size = src->size; r->vals = new float[r->size]; assert (r->vals != 0); for (int i=0; i<r->top; ++i) r->vals[i] = src->vals[i]; return r; } bool empty(FStack* S) { assert (S != 0); return (S->top == 0); }
Programming in C++
Page 81
From C to C++
New keywords Alternative representations // comment struct XXX introduces new type ( typedef struct XXX XXX;) Declarations and statements in any order Default arguments for functions [ Reference type ] Passing values in and out of functions per reference output parameter Type& t efficiency [ Inline functions ] Function overloading const Type& t
Summary
Operator overloading (for user-defined types) Boolean type: bool, true, false Input/output: #include <iostream> using namespace std; cout << var cin >> var if ( handle ) ... new/delete instead of malloc/free extern "C" Include guards Declare constants with const instead of #define
Programming in C++
Page 82
Programming in C++
Classes
Programming in C++
Page 83
Classes
a class can be characterized by three features:
Introduction
Classes provide method for logical grouping; Groupings are of both data and functionality (C struct + associated functions) A class defines a new, user-defined type Defines access rights for members (allowing data hiding, protection, ...) New defined class := C++ specification of abstract data type instance of class := object A class should describe a set of (related) objects (e.g., complex numbers) Data members := variables (also fields) of any type, perhaps themselves of other classes Member functions := actions or operations usually applied to data members important: called through objects Use data members for variation in value, reserve member functions for variation in behavior Normally build by class library programmers
Programming in C++ Dr. Aaron Naiman, Jerusalem College of Technology Page 84
Classes
Concrete Data Types
Explicit aim of C++ to support definition and efficient use of such user-defined types very well Concrete Data Types := user-defined types which are as "concrete" as builtin C types like int, char, or double
should well behave anywhere a built-in C type is well behaved Typical examples: Complex numbers (pointer, offset) pairs Ranges Nodes Source code locations Lines Strings Points Dates Links (value, unit) pairs BCD characters Rectangles Vectors Coordinates Times Associations Disc locations Currencies Rationals Arrays ...
A typical application uses a few directly and many more indirectly from libraries
Classes
The Life of an Object
This all happens to a programming language object (note the symmetry): allocation of memory to hold object data
construction (initialization)
usage
destruction
deallocation of memory
Example: Lecture:
reservation: reserve/occupy lecture room
setup: clean blackboard, switch on projector, ...
usage: give lecture, take and answer questions, ...
breakdown: switch off projector, sort slides, ...
departure: leave lecture room

Dr. Aaron Naiman, Jerusalem College of Technology Page 86
Programming in C++
Classes
Example: an object of type int: { int i; i = 5; /*...*/ j = 5 * i; /*...*/ }
The Life of an Object
allocation of object i of type int
initialization
usage
[destruction not needed for built-in types]
leaves scope: deallocation of memory
For classes: special member functions constructor: automatically called after allocation for class specific initialization destructor: automatically called prior to deallocation for class specific clean-up
Programming in C++
Dr. Aaron Naiman, Jerusalem College of Technology
Page 87
Classes
class Complex { public: /*...*/ private: double re; double im; };
Example: class Complex

// new type with name "Complex" // public interface, can be // accessed by all functions // hidden data/functions for use // by member functions only // note ";" versus end of function
public / protected / private is mainly a permission issue members of base class can be accessed in can be accessed inside class which are client code (member + friend functions) public private protected
public part describes interface to the new type clients can / have to use protected/private determine the implementation access specifiers (public, private, protected) can appear in any order and repeatedly
Classes
Client Program class Complex { public: void pub_mem(); private: void pr_mem(); double re, im; };
Conceptual Organization of a C++ Program

create member function call pub_mem: re im public part private part Object c
pr_mem:
int main() { Complex c; c.pub_mem();
return
c.pr_mem(); }
ERROR: no access
delete
Programming in C++
Page 89
Classes
Responsibility of all constructors (often abbreviated ctor) initialization of all data members (put object in well-defined state) perhaps: set globals, e.g., number of objects perhaps: special I/O for debugging only (why?)
Constructors
Important: constructor is "called" by an object and effects the object (like all member functions) Has the same name as the class Does not specify a return type or return a value (not even void) Cannot be called explicitly, but automatically (Stage ) after creation of new object (Stage ) Different constructors possible through overloading Two special constructors: default and copy if not specified, compiler generates them automatically if needed default ctor: generated as no-op if no other ctor (including copy ctor) exists otherwise error copy ctor: calls recursively copy ctor for each non-static data member of class type
Programming in C++
Page 90
Classes
Default constructor := willing to take no arguments class Complex { public: Complex(void) { re = 0.0; im = 0.0; } private: /* ... */ };
Default Constructor
// Complex default constructor
// ... usage in an application Complex c1, *cp = &c1; // just as with int Rule: member function definitions included in class definitions are automatically inline! re and im: declared by and belong to calling object (c1 above) Note: constructor not called for cp! How about constructors with client initialization?
Classes
class Complex { public: Complex(double r) { re = r; im = 0.0; } Complex(double r, double i) { re = r; im = i; } }; // ... usage in an application Complex c3(3.5), c4 = -1.0, c5(-0.7, 2.0);
"Regular" Constructors
"regular" constructor := initialize object with user supplied arguments
// Construct Complex out of // real number // Construct Complex out of // real and imaginary part
Any constructor call with a single argument can use "=" form (e.g., c4) Such a constructor is also used by the compiler to automatically convert types if necessary! These three constructors can be combined by using default arguments!
Classes
class Complex {
Default Constructor Take II
public: Complex(double r = 0.0, double i = 0.0) { re = r; im = i; } private: /* ... */ }; // ... usage in an application Complex c2, // NOT: c2()! c3(3.5), // c3 calls ctor with argument 3.5 c4 = -1.0, c5(-0.7, 2.0); Supply default arguments for all data members can be used as default constructor Note: c2() declares a function which returns a Complex How about same-class, object-to-object initialization, e.g., int i, j = i; ?
Programming in C++
Page 93
Classes
Complex(const Complex& rhs) { re = rhs.re; im = rhs.im; }
Copy Constructor
// why reference type?
Purpose: to initialize with another (existing) Complex object ("cloning")
// ... usage in an application Complex c6(c3), c7 = c2; // just like: int i(-4), j = i; complex_sin(c7); // copy ctor called if pass/return by value Has the same name as the class (as every constructor) and has exactly one argument of type "reference to const classtype" Argument passed by reference for effiency and mimic built-in type syntax to avoid calling constructor/destructor for temporary Complex object (on stack) even worse: to avoid recursive copy constructor calling!! rhs.re and rhs.im (rhs := right hand side) since constructor is member function access even to different objects private members but rhs. necessary to specify other object
Classes
class Complex { public: ~Complex(void) {} }; Placed in public: section Has the same name as class prepended with ~ Does not specify a return type or return a value (not even void) Does not take arguments Cannot be overloaded!!! // Complex dtor
Destructor
Is not called explicitly but automatically (Stage ) prior to deallocation of an Complex object (Stage ) Primary purpose/responsibility: cleanup (nothing needed for Complex) Default compiler-generated (no-op) destructor
Dr. Aaron Naiman, JCT + Dr. Bernd Mohr, FZ Jlich
Programming in C++
Page 95
Classes
What do we have so far? class Complex {
Complex Class Definition
public: // default constructor Complex(double r = 0.0, double i = 0.0) { re = r; im = i; } // copy constructor Complex(const Complex& rhs) { re = rhs.re; im = rhs.im; } // destructor ~Complex(void) {} private: double re; double im; }; But this is kind of boring...
Classes
To access (i.e., read from) data members class Complex { public: double real(void) {return re;} double imag(void) {return im;} }; // ... called by double d = c2.real(), e = cp->imag(); Required, as client has no access to private fields
Access Member Functions
Access syntax is the same as for C struct: ("." for member, "->" for pointer member access) Why functions? Consistency Flexibility (check parameter validity; implement no access / read-only, read-write access) can be replaced by computation (e.g. calculate polar coordinates out of (re,im)) Choose user-friendly, meaningful names for functions (moreso than for data members)
Programming in C++
Page 97
Classes
To modify (i.e, write to) data members class Complex { public: void real(double r) {re = r;} void imag(double i) {im = i;} }; // ... called by c5.imag(c1.real()); Exploiting function overloading How about object-to-object assignment? Involves: c1.real(c6.real()); c1.imag(c6.imag());
Modify Member Functions
2 access member function, 2 modify member function calls
Programming in C++
Page 98
Classes
class Complex { public: Complex& operator=(const Complex& rhs) if (this == &rhs) return *this; // re = rhs.re; im = rhs.im; // return *this; // } };
Assignment
{ time-saving self-test copy data return "myself"
// ... called by c1 = c6; // c1 calls operator with argument c6 // can also be written as: c1.operator=(c6); Function name: operator= if not defined, compiler automatically defines one (doing memberwise copying)! Reference (i.e., lvalue) returned for speed and daisy-chaining: c6 = c5 = c3; // c6.operator=(c5.operator=(c3)); match return value and argument type!
Classes
reference argument for speed and to avoid constructor/destructor calls to enable self-test New keyword this is defined for every body of member functions
Assignment Self-Test
a short-cut for "pointer to myself" i.e., "pointer to calling object" Reasons for self-test speed another reason later Possible self-assignment situations Complex& c8 = c3, *pc = &c2; // later ... c3 = c8; // or vice versa *pc = c2; // ditto Dont forget the operator=() self-test!
Classes
Copy Constructor vs. Assignment Operator
Construction: Complex c9 = c2; or: complex_sin(c2); Assignment: c9 = c2;
create can new daisy-chain object copy constructor operator=()
selfassignment check
returns reference to *this
Programming in C++
Page 101
Classes
To test equality to another Complex object For now, just a field-wise "and" test User can define == operator
Equality Test Operator
class Complex { public: bool operator==(const Complex& rhs) { return ((real() == rhs.real()) && (imag() == rhs.imag())); } }; // ... called by if (c7 == c2) cout << "Yup, theyre equal!" << endl; real() will be inline, so no slowdown, but makes maintenance easier Use public interface when possible and not harmful!
Programming in C++
Page 102
Classes
e.g., Addition: c6 = c1 + c8;
Math Member Operators
class Complex { public: const Complex operator+(const Complex& rhs) { return Complex(real()+rhs.real(), imag()+rhs.imag()); } }; Why return const object? disallow expressions like c6 = (c1 + c8)++; c6++++; Why call constructor? result of addition is new Complex object; unlikely that this already exists and it is const And why return by value (and not by reference)? Local value is deallocated before leaving function scope returned reference would be undefined!
Programming in C++
Page 103
Classes
Complex Class Definition
class Complex { // comments missing for space conservation public: Complex(double r = 0.0, double i = 0.0) {re = r; im = i;} Complex(const Complex& rhs) {re = rhs.re; im = rhs.im;} ~Complex(void) {} double real(void) {return re;} double imag(void) {return im;} void real(double r) {re = r;} void imag(double i) {im = i;} Complex& operator=(const Complex& rhs); bool operator==(const Complex& rhs) { return ((real()==rhs.real()) && (imag()==rhs.imag())); } const Complex operator+(const Complex& rhs) { return Complex(real()+rhs.real(), imag()+rhs.imag()); } // define all other missing operators and functions here... private: double re, im; };
Programming in C++
Pointer Data Members
Programming in C++
Page 105
Pointer vs. non-Pointers
What are the issues if a class includes data members which are of pointer type? Free store allocation (and deallocation) Pointers usually indicate this Who should do this and keep track? (class or user?) How about the constructors and destructor? Pointer value vs. what it points to For object assignment, do we want memberwise assignment of pointer fields? No! What should operator==() mean? identity? equal if same object (i.e. same address) equality? equal if same contents (i.e. same value or state) Lets look at the popular String class
Programming in C++
Page 106
Pointer Data Member

Beware of difference between arrays and pointers! char *str1 = "foo"; char str2[4] = "foo";
Motivation String Class
C++ character strings are really NUL terminated arrays of char (as in C)
// = {f, o, o, \0};
// sizeof(str1) != sizeof(str2) sometimes! str1: f o o \0 str2: f o o \0 if (str1 != str2) str1 = str2; str1: f o o \0 str2: f o o \0 arrays cannot be assigned char str3[4] = "bar"; str2 = str3;
// compares/copies pointer!
// ERROR!
Page 107

char *str1 = new char[42]; char *str2 = new char[7]; str2 = str1; delete [] str1; cout << str2[7] << endl;
More Pointer Assignment Problems

// areas are allocated // address is copied over // old contents of str2 lost // area is deallocated // area is accessed, but undefined
General problem/hazard: two pointers to same free store allocation Usually, on assignment, we want copy of info pointed to ("deep" copy), not copy of address (bitwise "shallow" copy) memory leaks Deep copy: deallocate old info if necessary (to avoid memory leak) new allocation assertion of success copy info over
Pointer Data Member
ANSI C String Library
So, to work with C++ character strings, need to use new/delete and ANSI C String library! Frequently used string functions: strcmp compares strings, returns <0, 0, >0 if s1<s2, s1==s2, s1>s2 int strcmp(char *s1, char *s2); strcpy copies strings, dst=src, dst must have enough space char *strcpy(char *dst, char *src); strcat appends a copy of src to the end of dst, dst must have enough space char *strcat(char *dst, char *src); strlen returns the number of bytes in s (without the terminating NUL character) size_t strlen(char *s); strdup returns a pointer to a new string which is duplicate of s uses malloc, user responsible for freeing space char *strdup(char *s); ...

char *str1 = "foo"; str2[4] = "foo"; str3[4] = "bar";
ANSI C String Library
But even with ANSI C String library functions, our examples still not work as expected:
if (strcmp(str1, str2) != 0) strcpy(str1, str2); //ERROR: typically core dumps strcpy(str2, str3); Even more problems: char *str1; char str2[3]; strcpy(str1, "foo"); strcpy(str2, "foo"); //ERROR: no space allocated for str1 //ERROR: not enough space // (forgot terminating NUL)
need better, automatically managed String objects!

The Life of a String Object
What memory allocation issues occur during the lifetime of a String object?
allocation of memory for hold pointer to String data (sizeof(char *))
construction: perhaps new to allocate space for data
usage: perhaps other free storing (operator=(), ...)
destruction: perhaps delete to deallocate data
deallocation of memory for pointer
Goal: conceal all free store business from client (user)
Programming in C++
Page 111

class String { public: // ... private: char *str; };
String Class Skeleton
// constructors, destructor, ... // place to store string value
For information hiding, dont let client know value of str What functions should be in public?
A good start: what do constructors look like?
Programming in C++
Page 112

Default constructor String() { str = new char[1]; assert(str != 0); str[0] = \0; } Char* constructor
String Constructors
// Default: empty string // checking // = ""
String(const char *s) { if (s) { // safety str = new char[strlen(s) + 1]; // allocating assert(str != 0); // checking strcpy (str, s); // copying } else { str = new char[1]; assert(str != 0); // checking str[0] = \0; // = "" } } Use of default argument would save extra default constructor code

Copy Constructor
String Copy Constructor
String(const String& rhs) { int len = strlen(rhs.str); str = new char [len + 1]; // allocating assert(str != 0); // checking strcpy (str, rhs.str); // copying } Recall: Signature: classname(const classname&); Copy constructor initializes from another (existing) object no need for null pointer check as rhs.str != 0 always
Default constructor, char* constructor, and copy constructor share a lot of code Use private helper function (e.g., set_str)

#include <assert.h> #include <string.h>
set_str()
// safe (checking s, not str) and sound, all in one place void set_str(const char *s) { if (s) { int len = strlen(s); str = new char [len + 1]; assert(str != 0); strcpy (str, s); } else { str = new char[1]; assert(str != 0); str[0] = \0; } } Can now be used by constructors and others....
// safety // allocating // checking // copying
// checking // = ""

Default and copy constructor
Constructors/Destructor
class String { public: String(const char *s = 0) { set_str(s); } String(const String& rhs) { set_str(rhs.str); } private: char *str; void set_str(const char *) { /* ... */ } }; Recall: constructors responsible for initialization pointer initialization: allocate memory from free store, or set to 0 Destructor ~String(void) {delete [] str;} When String object leaves scope, destructor (responsibility: cleanup) is called Rule: call delete for each pointer data member
Programming in C++
Page 116

class String { public: const char *c_str(void) { return (const char *) str; } }; With Complex real(), a copy of re is returned So to with c_str(), a copy of str pointer is returned But, copy refers to address of character array itself Client could change character array indirectly! Ouch! const ensures that this will not happen: String s1, s2(s1), s3 = "I am s3"; char *cs1 = s2.c_str(); const char *cs2 = s1.c_str(); cout << s3.c_str() << endl;
Programming in C++
Access Member Function
// error! // OK // OK
Page 117

String& operator=(const String& rhs) { delete [] str; set_str (rhs.str); return *this; } String s4("foo"), s5("bar"); f o o \0 str s4 s4 = s5; f o o \0 str s4 b a r \0 str s5 str s5
String Assignment Operator

//poor implementation
b a r \0
b a r \0
Recall: reference returned for daisy-chaining s4 = s3 = s2 = "And now something completely different...";

//poor implementation
String& operator=(const String& rhs) { delete [] str; set_str (rhs.str); return *this; } What if String* ps6 = &s4; ps6:
f o o \0 str s4
// and later *ps6 = s4; ??? ps6: str s4 We need to check for self assignment!
class String { public: String& operator=(const String& rhs) { if (this != &rhs) { delete [] str; set_str(rhs.str); } return *this; } }; // ... later s1 = s2; Note: Self-test performed on object addresses, not (char *) value Earlier reason for self-test: speed Now also: avoid catastrophic delete before set_str()
Programming in C++
Page 120

s4 = "zap"; // works!!
(char *) to String Assignment
We can initialize a String with a character string; how about assignment? How does this work? Compiler automatically generates code along the lines of: String tmp("zap"); s4.operator=(tmp); tmp.~String(); For efficiency, we can do better by implementing a character string assignment operator: class String { public: String& operator=(const char *rhs) { if (str == rhs) return *this; delete [] str; set_str(rhs); return *this; } }; s4 = "baz"; Modify member function c_str(char*) not necessary because of operator=(char*)
operator=() Lessons
There can be several overloaded versions of the assigment operator. T& operator=(const T&) is sometimes called copy assigment operator Do not forget the self-test! Have operator=() assign all data members (just like constructors) Another difference to copy constructor (recall earlier table): to delete old free store allocation After operator=() invocation corresponding pointer fields are not the same, but typically point to copies of the same data (deep copy) Without copy constructor and operator=() definitions compiler will perform memberwise copying (bitwise) leads to incorrect multiple pointers to same data pointer data elds dene copy constructor and operator=() !!!!

Obvious one: strlen():
Other String Capabilities
class String { public: int length(void) { return strlen(str); } }; Equality testing (operator==()) String concatenation (operator+(), operator+=()) Finding a char in a String Finding a String (or (char *)) in a String Change to lower/upper case ... Lets dene the rst two operators
Programming in C++
Page 123
operator=() is different for classes with pointer fields What about operator==()?
Definition: equality if dereferenced data is the same class String { public: bool operator==(const String& rhs) { if (this == &rhs) return true; return strcmp(str, rhs.str) == 0; } };
// time saver
Programming in C++
Page 124
Concatenation Operator
class String { public: const String operator+(const String& rhs) { char* r = new char [length() + rhs.length() + 1]; assert(r != 0); strcpy(r, str); strcat(r, rhs.str); String result(r); delete [] r; return result; } }; String a = "Hi, ", b = "mom!", c = a + b; Recall: cannot return reference! Using operator+() results in 2 calls each to copy constructor and destructor!!
// temp
// init with lhs // add rhs // construct String object // free temporary
Programming in C++
Page 125

#include <assert.h> #include <string.h> class String {
String.h
// bad! missing documentation
public: String(const char *s = 0) { set_str(s); } String(const String& rhs) { set_str(rhs.str); } ~String(void) { delete [] str; } const char *c_str(void) { return (const char *) str; } int length(void) { return strlen(str); } String& operator=(const char *rhs) { /* ... */ } String& operator=(const String& rhs) { /* ... */ } bool operator==(const String& rhs) { /* ... */ } const String operator+(const String& rhs) { /* ... */ } /* ... */ private: void set_str(const char *) { /* ... */ } char *str; };

#include <iostream> using namespace std; #include "String.h"
Using the String Class
int main(int argc, char *argv[]) { String red = "red", blue = "blue", purple = red, clear; // oops, fixing purple = "purple";
if ((red + blue) == purple) cout << "Its a MIRACLE! How did you get " << purple.c_str() << "?" << endl; return 0; }
Programming in C++
Page 127
Pointer Data Member

Use String class instead of C++ character strings fortunately, new C++ standard library includes string class #include <iostream> #include <string> using namespace std; string s1 = "hello"; string s2 = s1 + ", world!"; cout << s2 << endl; Learn about it and use it! [ see also string class description in appendix ] Possible enhancements/optimizations: store length copy into old space if possible (and avoid delete/new) reference counting (see chapter "More Class Examples")
String Summary
Programming in C++
Page 128
Programming in C++
More on Classes
Programming in C++
Page 129
More on Classes
Scope and Related Global Functions
Member function bodies in class definition violate principle of "separation of implementation and interface" and make it hard to read class String { int length(void) { return strlen(str); } ... }; Move member functions bodies outside of class definition Class scope: members associated to class with scope operator "::" class String { int length(void); ... }; int String::length(void) { return strlen(str); } // this is String::length() // not a global function // length()!
Programming in C++
Page 130
More on Classes
Scope and Related Global Functions
Scope operator without class name refers to global scope int x[99]; void foo() { struct x {int a;}; sizeof(::x); } // compare to example // on page 55
Recall: building a class library for others to use .h #included for interface .cpp #includes .h and is compiled away for linking Therefore, other related global functions, e.g., declared in String.h bool sound_same(const String&, const String&); defined in String.cpp bool sound_same(const String& s1, const String& s2) { ... }
Programming in C++
Page 131
More on Classes
Class interface foo.h: class foo definition declarations of global functions Class implementation foo.cpp: #include "foo.h"
File Organization of Class Information
(missing) definitions of member functions definitions of global functions User program prog.cpp: #include "foo.h" Implementation of user code (including main()) that uses class foo Compilation (on UNIX): Compile class implementation: CC -O -c foo.cpp Later compile prog.cpp: CC -O -c prog.cpp And finally link: CC -O -o prog prog.o foo.o
More on Classes
const Complex cplx_pi(3.14); cplx_pi = 3.0; double pi = cplx_pi.real();
Constant Member Functions
const allows the compiler to help enforce the "read-only" constraint
// error! good! // error! oops!
Problem: compiler doesnt know whether member function changes object doesnt allow to call member function on const object Solution: declare member function to be const Member function declaration: add const after parameter list class Complex { double real(void) const; }; Member function definition: add const between parameter list and function body double Complex::real(void) const { return re; } const char *String::c_str(void) const { return (const char*) str; }
More on Classes
Constant Member Functions
const member function can also be invoked on non-const objects, but not vice-versa String s1 = "bim"; const String s2 = "bam"; const char *str1 = s1.c_str(); const char *str2 = s2.c_str(); s1 = s2; s2 = s1; // OK! // OK! // OK! // error!
It is possible to overload a member function based on its constness class String { public: do_special(void) { /*will be called for non-const strings*/ } do_special(void) const { /*will be called for const strings*/ } ... }; Global and static functions cannot be declared const. Why?
More on Classes
#include <assert.h> #include <string.h> class String {
Example: String.h
// bad! missing documentation
public: String(const char *s = 0) { set_str(s); } String(const String& rhs) { set_str(rhs.str); } ~String(void) { delete [] str; } const char *c_str(void) const { return (const char *) str; } int length(void) const; String& operator=(const char *rhs); String& operator=(const String& rhs); bool operator==(const String& rhs) const; const String operator+(const String& rhs) const; /* ... */ private: void set_str(const char *); char *str; };
More on Classes
#include "String.h" int String::length(void) const { return strlen(str); }
Example: String.cpp
String& String::operator=(const String& rhs) { if (this != &rhs) { delete [] str; set_str(rhs.str); } return *this; } String& String::operator=(const char *rhs) { /* ... */ } /* ... */
Programming in C++
Page 136
More on Classes
Literals
Literals and Pointer to Class Objects
Not possible to define literals (constants) of a userdefined class Complex c1 = 1 + 2i; // NOT POSSIBLE!!! Literals of the basic types can be used if conversion constructor provided Complex c2 = 5.0; Pointer to Class Objects Possible to dynamically allocate objects of class type Complex *cp1 = new Complex; // uses default constructor Complex *cp2 = new Complex(1.0,4.5); // uses "normal" constructor Possible to dynamically allocate arrays of objects of class type Complex *carray1 = new Complex[3]; // array of 3 Complex Complex *carray2 = new Complex[3](1.0,4.5); // NOT POSSIBLE !!! if initialization of different values needed, use array of pointers: Complex *carray[3]; for (int i=0; i<3; i++) carray[i] = new Complex(5*i*i);
// calls Complex(double,double);
More on Classes
Class Arrays
Fixed-length arrays of class objects can be declared and initialized like arrays of built-in types: #include "Complex.h" int main (int argc, char *argv) { int i=1, ia1[3], ia2[] = { 5, i, ia1[2] }; Complex c=1.0, ca1[3], ca2[] = { 5.0, Complex(3.4, 4.5), c, ca1[2] }; } Use braces as usual for array initialization Individual element initialization (any constructor) single argument: as is multiple arguments: use constructor form
// // // //
ctor(double) ctor(double, double) copy ctor copy ctor
More on Classes
Preference of Member Functions
Situation: designing new function related to class Question: make the function global or a member? Answer in general: make it a member keep things object-oriented and neat E.g., for matrix multiplication: Cln = Alm Bmn Matrix A(3,2), B(2,7); // ... later Matrix C(A.rows(), B.cols()) = A * B; Neatness: object calls instead of being an argument But in two situations this fails...
Programming in C++
Page 139
More on Classes
We currently have
Back to Complex::operator+()
const Complex operator+(const Complex& rhs) { return Complex(real()+rhs.real(), imag()+rhs.imag()); } // ... called by c6 = c1 + c8; // fine and dandy What if we want mixed-type addition? c6 = c1 + 19; c6 = 19 + c1; // still OK, or // error! Why isnt addition commutative?
To understand, look at explicit function call c6 = c1.operator+(19); c6 = 19.operator+(c1); // implicit int -> Complex conversion // no int class, so no member function
Rule: no implicit conversions on invoking object Solution: define global function for Complex addition
More on Classes
Global form for addition
Global Complex Addition
const Complex operator+(const Complex& lhs, const Complex& rhs) { return Complex(lhs.real()+rhs.real(), lhs.imag()+rhs.imag()); } Note single argument of Complex::operator+(), and two here Now both arguments of operator+() can be converted Reminder: even though global, declare in Complex.h, define in Complex.cpp Dont forget to define related operators: e.g., define operator+=() out of operator+() const Complex& operator+=(const Complex& rhs) {//very bad idea!!! return *this = *this + rhs; } Can we do even better? yes, start with operator+=() inline const Complex& operator+=(const Complex& rhs) { re += rhs.re; im += rhs.im; return *this; }
More on Classes
Define operator+() out of operator+=()
Keeping Operators Consistent
const Complex operator+(const Complex& lhs, const Complex& rhs) { return Complex(lhs) += rhs; } Also, define operator++() out of operator+=() const Complex& operator++() { // prefix form: increment and fetch *this += 1; // should be better: this->re += 1; return *this; } Then, define operator++(int) out of operator++() to distinguish postfix from prefix form artificial (not-used) int argument is used const Complex operator++(int) { // postfix form: fetch and incr. Complex oldValue = *this; ++(*this); return oldValue; } always dene both operators otherwise old compilers use operator++() for both forms! Do the same for -, *, /, ...
More on Classes
Friend Functions Motivation
What if there is no Complex::real() and Complex::imag()? Alternative: use Complex::re and Complex::im Problem data members are (properly) hidden in private: our function is now global no access! Solution: declare our global function to be a friend How do I apply for friendship?
Programming in C++
Page 143
More on Classes
Remain global functions (or member function in other class)
Friend Functions
Have access to members in private: (and protected:) of friend class Declared "friend" in class (e.g., in Complex) friend const Complex operator+(const Complex&, const Complex&); usually all friends together at beginning "friend class foo;" within "class bar" definition befriends all foos member functions (but not foos friends) to bar Opposite is not true "friend" is not transitive! foo friend-of bar bar friend-of zap =| foo friend-of zap And the second reason for a non-member function...
Programming in C++
Page 144
More on Classes
Proper Pretty-Printing
Goal: print objects to appear in a natural format in an easy-to-use fashion Appearance: depends on object Complex: parenthesized, comma-separated list: (-4.3, 94.3i) String: just the pointer field (str) Ease-of-use: can we get something like: cout << "this is c3: " << c3 << endl; cout << " and s2: " << s2 << endl; Lets try a member function // no c_str()
Programming in C++
Page 145
More on Classes
First try: here is the prototype (i.e., declaration)
Complex::operator<<()
ostream& Complex::operator<<(ostream& output); Recall: as a member function, Complex object invokes (calls) the function Therefore: function invocation c3 << cout; // most unnatural!
Again we want object to be an argument (and cout the invoker) Therefore, make operator<<() global for Complex objects ostream& operator<<(ostream& output, const Complex& rhs) { return output << "(" << rhs.real() << "," << rhs.imag() << "i)"; } Again, if no Complex::real() and Complex::imag() need to make this a friend So, in summary...
More on Classes
Algorithm for Function Type Decision
In general: keep functions as members if possible Reason for non-member function do not want object to invoke, rather be an argument Reason for global function to be a friend access to hidden data For defining function func for objects of class foo if ( (func needs type conversion on left most argument) || (func is operator>> || operator<<) ) { make func global; if (func needs access to non-public members of foo) make func a friend of foo; } else make func a member; And why is it so important to hide the data?
Programming in C++
Page 147
More on Classes
Reasons for Data Out of public:
Client access only through library-programmer-supplied member functions: Simplicity: client needs only know member functions, and not data implementation details Uniformity: client always accesses members (object) via function Complex::real(), and not Complex::re Protection: to disallow client access (none, reading, writing, both) writing to String::str without proper allocation keeping data members in sync (e.g., a String::len data member for speed optimization) Correctness: only correctness of the interface functions need to be proven Forward compatibility: future class library changes localized to member functions will not need to change client code (as long we change the interface) errors("well, not in your code, of course") data member name changes (Complex::re Complex::_re) Algorithm changes Underlying data structure changes (Stack<vector> Stack<linked_list>)
More on Classes
e.g., Addition: c6 = c1 + c8;
const Complex operator+(const Complex& lhs, const Complex& rhs) { return Complex(lhs) += rhs; } Why return const object? disallow expressions like c6 = (c1 + c8)++; c6++++; Why call constructor? result of addition is new Complex object; very unlikely that this already exists and it is const And why return by value (and not by reference)? //first wrong way with allocating object on the stack const Complex& operator+(const Complex& lhs, const Complex& rhs) { Complex temp(lhs); temp += rhs; return temp; } temp is deallocated before leaving function scope, so returned reference is undefined!
More on Classes
//second wrong way with allocating object on the heap const Complex& operator+(const Complex& lhs, const Complex& rhs) { Complex *result = new Complex(lhs); result += rhs; return *result; } new problem: who will call delete for the return object? memory leak! Even if caller would be willing to take the address of the functions result and call delete on it (astronomically unlikely), complicated expressions yield unnamed temporaries that programmers would never be able to get at. Example: Complex w, x, y, z; w = x + y + z; // how to get at the result of +s?
Dont try to return a reference when you must return an object!
Programming in C++
Page 150
More on Classes
Optimized String Concatenation Operator
String concatenation operator String::operator+() very inefficient! add private helper constructor (dummy argument necessary for distinction) class String { ... private: String(const char *s, bool) { str = s; } }; use new constructor for avoiding extra copying in temporary result variable const String String::operator+(const String& rhs) { char *r = new char [length() + rhs.length() + 1]; assert(r != 0); strcpy(r, str); strcat(r, rhs.str); return String(r, true); }
More on Classes
Operators that CAN be overloaded: Operators(@) + - * & ! ~ ++ -+ - * / % ^ & | < > == != <= >= << >> && || , += -= *= /= %= ^= &= |= <<= >>= = [] () -> ->* ++ -new delete new[] delete[] Expression @a a@b a@b a=b a[b] a(b, ...) a@b a@
Summary Operator Overloading

As member function (a).operator@() (a).operator@(b) (a).operator@(b) (a).operator=(b) (a).operator[](b) (a).operator()(b, ...) (a.operator@())@b (a).operator@(0) operator@(a, 0) As global function operator@(a) operator@(a, b) operator@(a, b)
see extra slides && || , and global @= operators ?: sizeof throw typeid
Page 152
Operators that SHOULD NOT be overloaded: Operators that CANNOT be overloaded:

Programming in C++
.* ::
More on Classes
Conversions
Besides the usual implicit conversions (intdouble, charint, ...), C++ compilers perform implicit conversions using the following member functions: single (non-default) argument constructors with argument type class type to class type from another type: classname::classname(anothertype) {} void foo(const String& s); foo("I am not a String"); implicit type conversion operators from class type to another type: classname::operator anothertype () {} Complex::operator String() const { // no return type!!! char *s = new char[32]; sprintf(s, "(%f,%fi)", real(), imag()); String res(s); delete [] s; return res; } Complex cx(1.2,3.4); foo(cx);
// calls String::String(const char*)
More on Classes
Guideline: Exceptions: class U source not available U is built-in C type Problem: unwanted conversions / ambiguities likely define explicit conversion function, e.g., toType() String Complex::toString() const; define conversion constructor explicit use conversion operators sparingly!
Conversions
if it is necessary to convert a T into some other class U, the conversion should be handled by class U (through conversion constructor)
(recent addition to C++ Standard)
explicit Complex::Complex(double, double);
Another example: we can now re-write String::c_str() as conversion function: String::operator const char *() { return (const char *)str; }
Programming in C++
Page 154
More on Classes
Con/Destructors and the Free Store
Often con/destructors call new / delete (e.g., for String) Opposite is true as well: for classes, new / delete call con/destructors of the class // allocates memory and calls default constructor String *sp1 = new String; // allocates memory and calls appropriate constructor String *sp2 = new String("hello"); // allocates memory for 10 strings and // calls default constructor on each of them String *sp3 = new String[10]; // call destructor as well as deallocate memory delete sp1; delete sp2; delete [] sp3; // call destructor for every element in array Additional benefits over Cs malloc() and free()
Programming in C++
Page 155
More on Classes
Passing Objects by Reference
Passing an object by value (default), to or from a function, invokes copy constructor. And a constructor call will be followed by a destructor invocation class Coord { ... double x, y, z; }; class Triangle { ... Coord v1, v2, v3; }; Triangle return_triangle (Triangle t) { return t; } Eight (copy) constructors and eight destructors called Solution: pass by reference (0 additional invocations) Triangle& return_triangle (const Triangle& t) { return t; } If possible, pass parameters by const reference to enable processing of const objects automatic parameter conversions (non-const would change generated temporary only) Recall: do not return references to local objects object allocated in function from free store when new object is needed, return it by value
More on Classes
class Empty {};
Default Member Functions
is actually (some member functions are automatically generated by the compiler if necessary): class Empty { public: Empty() {} // constructor (only if there is no other ctor) ~Empty() {} // only in derived classes if base class has dtor Empty(const Empty& rhs) { // copy constructor foreach non-static member m: m(rhs.m); } Empty& operator=(const Empty& rhs) { // assignment operator foreach non-static member m: m = rhs.m; } Empty* operator&() { return this; } // address-of operators const Empty* operator&() const { return this; } }; What if you do not want to allow the use of this functions (e.g., assignment)? declare them private and do not define them! private: Empty& operator=(const Empty& rhs);
More on Classes
Constructor Member Initialization Lists
class NamedData { private: String name; void *data; public: NamedData(const String& initName, void *dataPtr); }; Version Assignment: uses String::String() + String::operator=() NamedData::NamedData(const String& initName, void *dataPtr) { name = initName; data = dataPtr; } Version Initialization: uses String::String(const String &) NamedData::NamedData(const String& initName, void *dataPtr) : name(initName), data(dataPtr) {} Rule: Prefer initialization to assignment in constructors Also, initialization form must be used for reference or const members! Note, initializations done in order of definition in class, not in order of the initialization list
Programming in C++
Page 158
More on Classes
Approach 1: member mem / argument mem access function getmem() / setmem() class Point { private: int x, y; public: Point(int x=0, int y=0) : x(x), y(y) {} void setx(int x) {Point::x=x;} void sety(int y) {this->y=y; } int getx() { return x; } int gety() { return y; } }; Approach 3: ??? Do it consistently!
Naming of Members
Approach 2: member mem_ / argument mem access function mem() overloading class Point { private: int x_, y_; public: Point(int x=0, int y=0) : x_(x), y_(y) {} void x(int x) { x_=x; } void y(int y) { y_=y; } int x() { return x_; } int y() { return y_; } };
Page 159
More on Classes
What if one wants a global variable for a class, e.g.,
Static Data Members
num_numbers for Complex (probably in/decremented in con/destructors) max_length for String (probably set once at beginning of main()) How does one associate it with the class? And making sure to only have one copy? otherwise wasteful and error prone static data members (also called "class variables") New (third) type of static Declaration: in class definition (in .h) static int num_numbers; Definition: (only once) needed elsewhere (in .cpp, not in .h) int Complex::num_numbers = 0; Is just a global variable (i.e., could be accessed without any class instance) But has protection like any other data member keep it out of public:
More on Classes
Static Member Functions
Like static data members, it is possible to declare static member functions class Complex { public: static void print_num() { cout << num_numbers; } // ... }; Associated with their class as a whole Is like global function, but can be private or protected doesnt pollute global namespace Invoked any time class declaration in scope can be accessed without any class instance Complex::print_num(); this pointer not defined can only refer to static members of its class const static member functions not possible
More on Classes
class and struct
Both the keywords class and struct can be used to declare new user-defined types: C++ structs can have member functions, constructors, statics, overloaded operators, ... The only difference is the default permission: class members are by default private struct members are by default public class foo { int i; // private public: int j; // public }; Use class for defining new data types Use struct to define plain data records (especially if they must be compatible with C code) for defining small, auxiliary helper types (to express that they are no full-blown types)
struct foo { int i; // public private: int j; // private };
More on Classes
Inline Member Functions Revisited
Inline for short and sweet functions (no loops, ...) Member function definition in .h: function inline if inside class definition or declared inline .cpp: function not inline; even if declared inline in .h (no expansion definition for compilation) Recall and beware: inline is only a suggestion to the compiler! If compiler cannot inline a function copy of function in every module that #includes .h makes function static to avoid linkage problem Sometimes, you cannot set breakpoints on inline functions in debuggers make it easy to switch between inline / not inline put inline definitions in separate file .inl which is included in .h doesnt clutter up the class definition
More on Classes
foo.inl: definitions of inline functions foo.h: class foo definition
File Organization of Class Information
declarations of non-inline and global functions #include "foo.inl" (in normal case) foo.cpp: #include "foo.h" #include "foo.inl" (during debugging) definitions of non-inline and global functions foo.test.cpp [optional, but recommended]
#include "foo.h" contains main() with code which tests all the functionality of foo
More On Classes
#ifndef COMPLEX_H #define COMPLEX_H
File Organization: Complex.h
class Complex { public: Complex(double r = 0.0, double i = 0.0); Complex(const Complex& rhs); ~Complex(void); double real(void); double imag(void); void real(double r); void imag(double i); Complex& operator=(const Complex& rhs); bool operator==(const Complex& rhs); // ... }; #ifndef NO_INLINE # include "Complex.inl" #endif #endif
More On Classes
#ifndef COMPLEX_INL #define COMPLEX_INL
File Organization: Complex.inl
inline Complex::Complex(double r, double i) {re = r; im = i;} inline Complex::Complex(const Complex& rhs) { re = rhs.re; im = rhs.im; } inline Complex::~Complex(void) {} inline double Complex::real(void) {return re;} inline double Complex::imag(void) {return im;} inline void Complex::real(double r) {re = r;} inline void Complex::imag(double i) {im = i;}
#endif
Programming in C++
Page 166
More On Classes
#include "Complex.h" #ifdef NO_INLINE # define inline # include "Complex.inl" #endif
File Organization: Complex.cpp
bool Complex::operator==(const Complex& rhs) { return ((real()==rhs.real()) && (imag()==rhs.imag())); } const Complex Complex::operator+(const Complex& rhs) { return Complex(real()+rhs.real(), imag()+rhs.imag()); } Complex& operator=(const Complex& rhs) { if (this == &rhs) return *this; re = rhs.re; im = rhs.im; return *this; } Normal compiling: CC -c Complex.cpp Compiling for debugging: CC -c -g -DNO_INLINE Complex.cpp
More on Classes
To create an object on the heap, use the new operator new operator is built into the language cannot be overloaded if invoked, 1.) allocates memory for the object using operator new 2.) calls constructor of the object operator new can be used to allocate raw memory void *raw_mem = operator new(50*sizeof(char)); can be overloaded never overload global operator new should only be done on a per class basis (e.g., for efficiency) void *operator new(size_t); Same rules apply to delete
new / delete
Page 168
More on Classes
Example:
Overloading new / delete
Overloading operator new and delete on per class basis
class Complex { private: union { // private data used either for double re, im; // - old data members Complex *next; // - pointer in freelist }; static Complex* headOfFreelist; // class wide freelist static const int BSIZ = 256; // allocation block size public: // overloaded new / delete declarations static void *operator new(size_t size); static void operator delete(void *deadobj, size_t size); // ... }; Complex* Complex::headOfFreelist = 0; const int Complex::BSIZ;
More on Classes
Operator new
void *Complex::operator new(size_t size) { // use global new if called from derived class if (size != sizeof(Complex)) return ::operator new(size); Complex *p = headOfFreelist; // if p is valid, return next element from freelist if (p) { headOfFreelist = p->next; } else { // allocate next block Complex *newBlk = ::operator new(BSIZ * sizeof(Complex)); if (newBlk == 0) return 0; // link memory chunks together for free list for (int i=1; i<BSIZ-1; ++i) newBlk[i].next = &newBlk[i+1]; newBlk[BSIZ-1].next = 0; // return first block; point freelist to second p = newBlk; headOfFreelist = &newBlk[1]; } return p; }
More on Classes
Operator delete
void Complex::operator delete(void* deadObj, size_t size) { // allow null pointers if (deadObj == 0) return; // use global delete if called from derived class if (size != sizeof(Complex)) { ::operator delete(deadObj); return; } // add to front of freelist Complex* dead = (Complex *) deadObj; dead->next = headOfFreelist; headOfFreelist = dead; }
Programming in C++
Page 171
More on Classes
Declaration vs. Definition
A declaration tells compilers about the name and type of an object, function, class, or template, but nothing more. These are declarations: extern int x; int numDigits(int number); class String; // object declaration // function declaration // class declaration
A definition provides compilers with further details. For an object, the definition is where compilers allocate memory for the object. For a function or a function template, the definition provides the code body. For a class or a class template, the definition lists the members of the class or template: int x; int numDigits(int number) { ... } class Clock { public: ... };
Programming in C++
// object definition // function definition
// class definition
Page 172
More on Classes
Regular pointers int i; int *ptr = &i; *ptr = 5; Pointer to class members class A { public: int i; void foo(int i) {...} }; int A::*m_ptr = &A::i; A a, *a_ptr = new A; a.*m_ptr = 5; a_ptr->*m_ptr = 5;
Pointer to Class Members

void foo(int i) {...} void (* f_ptr)(int) = &foo; (*f_ptr)(7);
void (A::* mf_ptr)(int) = &A::foo;
(a.*mf_ptr)(7); (a_ptr->*mf_ptr)(7);
Programming in C++
Page 173
More on Classes
Summary Typical Class Members
For a class Foo we typically need the following members: Default constructor (only if reasonable default exists!): Foo(void); or Foo(type = default); (Conversion) constructors: Foo(builtin_type); or Foo(const another_type&);
Equality and in-equality operators (<, >, <=, >= too if Foo has total order) global functions if conversion on left-most argument is needed bool operator==(const Foo&) const; bool operator!=(const Foo&) const; Access functions to class members: builtin_type getmem1() const; const builtin_type* getmem2() const; const another_type& getmem3() const; Application specific functions members Global Input and Output operators: ostream& operator<<(ostream&, const Foo&); istream& operator>>(istream&, Foo&);
More on Classes
Copy constructor: Assignment operator (self-test!) Destructor:
Summary Typical Class Members

Foo(const Foo&); Foo& operator=(const Foo&); ~Foo();
If class Foo has pointer data members, we also need:
For mathematical classes we also define (the same for -, *, /): const Foo& Foo::operator+=(const Foo&) { /*...*/ } const Foo operator+(const Foo& lhs, const Foo& rhs) { return Foo(lhs) += rhs; } const Foo& Foo::operator++() { *this += 1; return *this; } const Foo Foo::operator++(int) { Foo old(*this); ++(*this); return old; }
Programming in C++
Page 175
Programming in C++
Page 176
Programming in C++
More Class Examples
Programming in C++
Page 177
More Class Examples

#include <stdio.h> struct RE { int h_, w_; }; typedef struct RE Rectangle; void re_set(Rectangle* r, int h, int w) { r->h_ = h; r->w_ = w; } int re_height(Rectangle r) { return r.h_; } int re_width(Rectangle r) { return r.w_; } int main() { Rectangle r; re_set(&r, 5, 8); printf("%d\n", re_height(r)); }
Programming in C++
Rectangle (C to C++)
#include <iostream> using namespace std; struct Rectangle { int h_, w_; };
void re_set(Rectangle& r, int h, int w) { r.h_ = h; r.w_ = w; } int re_height(const Rectangle& r) { return r.h_; } int re_width(const Rectangle& r) { return r.w_; } int main() { Rectangle r; re_set(r, 5, 8); cout << re_height(r) << endl; }
Page 178
More Class Examples

#include <iostream> using namespace std; struct Rectangle { int h_, w_; }; void re_set(Rectangle& r, int h, int w) { r.h_ = h; r.w_ = w; } int re_height(const Rectangle& r) { return r.h_; } int re_width(const Rectangle& r) { return r.w_; } }; int main() { Rectangle r; re_set(r, 5, 8); cout << re_height(r) << endl; }
Programming in C++
Rectangle (Simple "Class")

#include <iostream> using namespace std; struct Rectangle { int h_, w_; void set(int h, int w) { this->h_ = h; this->w_ = w; } int height() const { return this->h_; } int width() const { return this->w_; }
int main() { Rectangle r; r.set(5, 8); cout << r.height() << endl; }
Page 179
More Class Examples

#include <iostream> using namespace std; struct Rectangle { int h_, w_; void set(int h, int w) { this->h_ = h; this->w_ = w; } int height() const { return this->h_; } int width() const { return this->w_; } }; int main() { Rectangle r; r.set(5, 8); cout << r.height() << endl; }
Programming in C++
Rectangle (this Not Necessary)

#include <iostream> using namespace std; struct Rectangle { int h_, w_; void set(int h, int w) { h_ = h; w_ = w; } int height() const { return h_; } int width() const { return w_; } }; int main() { Rectangle r; r.set(5, 8); cout << r.height() << endl; }
Page 180
More Class Examples

#include <iostream> using namesapce std; struct Rectangle { int h_, w_; void set(int h, int w) { h_ = h; w_ = w; } int height() const { return h_; } int width() const { return w_; } }; int main() { Rectangle r; r.set(5, 8); cout << r.height() << endl; }
Programming in C++
Rectangle ("real" Class)

#include <iostream> using namespace std; class Rectangle { private: int h_, w_; public: Rectangle(int h, int w) { h_ = h; w_ = w; } int height() const { return h_; } int width() const { return w_; } }; int main() { Rectangle r(5, 8); cout << r.height() << endl; }
Page 181
More Class Examples

#include <iostream> using namespace std; class Rectangle { private: int h_, w_; public: Rectangle(int h, int w) { h_ = h; w_ = w; } int height() const { return h_; } int width() const { return w_; } };
Rectangle (Outlined Methods)

#include <iostream> using namespace std; class Rectangle { private: int h_, w_; public: Rectangle(int h, int w) : h_(h), w_(w) {} int height() const; int width() const; }; int Rectangle::height() const { return h_; } int Rectangle::width() const { return w_; } int main() { Rectangle r(5, 8); cout << r.height() << endl; }
Page 182
int main() { Rectangle r(5, 8); cout << r.height() << endl; }
Programming in C++
More Class Examples

#include <stdio.h> struct Complex { double re, im; };
Complex (Simple C)
void cplx_print(struct Complex c) { printf("(%g,%gi)", c.re, c.im); }
int main() {
/* calculate r=(c1+c2)*c3 */ struct Complex c1, c2, c3, r, t; c1.re = 1; c1.im = 1; c2.re = 2; c2.im = 2; c3.re = 3; c3.im = 3; add(&t, c1, c2); mult(&r, t, c3); printf("r = "); cplx_print(r); printf("\n"); }
void add(struct Complex *res, struct Complex c1, struct Complex c2) { res->re = c1.re+c2.re; res->im = c1.im+c2.im; } void mult(struct Complex *res, struct Complex c1, struct Complex c2) { res->re = c1.re*c2.re-c1.im*c2.im; res->im = c1.re*c2.im+c1.im*c2.re; }
Programming in C++
Page 183
More Class Examples

#include <stdio.h> typedef struct { double re, im; } Complex; void cplx_init(Complex *c, double r, double i) { c->re = r; c->im = i; }
Complex (Better C)
double cplx_real(Complex *c) { return c->re; } double cplx_imag(Complex *c) { return c->im; } void cplx_print(Complex *c) { printf("(%g,%gi)", c->re, c->im); } int main() { /* calculate r=(c1+c2)*c3 */ Complex c1, c2, c3, r, t; cplx_init(&c1, 1, 1); cplx_init(&c2, 2, 2); cplx_init(&c3, 3, 3); cplx_add(&t, &c1, &c2); cplx_mult(&r, &t, &c3); printf("r = "); cplx_print(&r); printf("\n"); }
void cplx_add(Complex *res, Complex *c1, Complex *c2) { cplx_init(res, c1->re+c2->re, c1->im+c2->im); } void cplx_mult(Complex *res, Complex *c1, Complex *c2) { cplx_init(res, c1->re*c2->re - c1->im*c2->im, c1->re*c2->im + c1->im*c2->re); }
Programming in C++
Page 184
More Class Examples

#include <stdio.h> struct Complex { double re, im; }; void cplx_init(Complex& c, double r, double i) { c.re = r; c.im = i; }
Complex (Simple C++)

double cplx_real(const Complex& c) { return c.re; } double cplx_imag(const Complex& c) { return c.im; } void cplx_print(const Complex& c) { printf("(%g,%gi)", c.re, c.im); } int main() { // calculate r=(c1+c2)*c3 Complex c1, c2, c3, r, t; cplx_init(c1, 1, 1); cplx_init(c2, 2, 2); cplx_init(c3, 3, 3); cplx_add(t, c1, c2); cplx_mult(r, t, c3); printf("r = "); cplx_print(r); printf("\n"); }
void cplx_add(Complex& res, const Complex& c1, const Complex& c2) { cplx_init(res, c1.re+c2.re, c1.im+c2.im); } void cplx_mult(Complex& res, const Complex& c1, const Complex& c2) { cplx_init(res, c1.re*c2.re - c1.im*c2.im, c1.re*c2.im + c1.im*c2.re); }
Programming in C++
Page 185
More Class Examples

#include <stdio.h> struct Complex { double re, im; }; void cplx_init(Complex& c, double r, double i) { c.re = r; c.im = i; }
Complex (Operator Overloading)

double cplx_real(const Complex& c) { return c.re; } double cplx_imag(const Complex& c) { return c.im; } void cplx_print(const Complex& c) { printf("(%g,%gi)", c.re, c.im); }
Complex operator+(const Complex& c1, const Complex& c2) { int main() { Complex res; // calculate r=(c1+c2)*c3 cplx_init(res, c1.re+c2.re, Complex c1, c2, c3, r; c1.im+c2.im); cplx_init(c1, 1, 1); return res; cplx_init(c2, 2, 2); } cplx_init(c3, 3, 3); r = (c1 + c2) * c3; Complex operator*(const Complex& c1, printf("r = "); const Complex& c2) { cplx_print(r); Complex res; cplx_init(res, printf("\n"); c1.re*c2.re - c1.im*c2.im, } c1.re*c2.im + c1.im*c2.re); return res; }
Page 186
More Class Examples

#include <iostream> using namespace std; struct Complex { double re, im; };
Complex (Declartions, IOStreams)

double cplx_real(const Complex& c) { return c.re; } double cplx_imag(const Complex& c) { return c.im; }
void cplx_init(Complex& c, double r, double i) { c.re = r; c.im = i; }
ostream& operator<<(ostream& ostr, const Complex& c) { Complex operator+(const Complex& c1, return const Complex& c2) { ostr << "(" << c.re Complex res; << "," << c.im << "i)"; cplx_init(res, c1.re+c2.re, } c1.im+c2.im); return res; int main() { } // calculate r=(c1+c2)*c3 Complex c1; cplx_init(c1, 1, 1); Complex operator*(const Complex& c1, Complex c2; cplx_init(c2, 2, 2); const Complex& c2) { Complex c3; cplx_init(c3, 3, 3); Complex res; cplx_init(res, Complex r = (c1 + c2) * c3; c1.re*c2.re - c1.im*c2.im, cout << "r = " << r << endl; c1.re*c2.im + c1.im*c2.re); } return res; }
More Class Examples

#include <iostream> using namespace std; struct Complex { double re, im; void init(double r, double i) { this->re = r; this->im = i; }
Complex (Simple "Class")

double real() const { return this->re; } double imag() const { return this->im; } };
ostream& Complex operator+(const Complex& c2) const { operator<<(ostream& ostr, const Complex& c) { Complex res; return res.init(this->re+c2.re, ostr << "(" << c.re this->im+c2.im); << "," << c.im << "i)"; return res; } } int main() { Complex // calculate r=(c1+c2)*c3 operator*(const Complex& c2) const { Complex c1; c1.init(1, 1); Complex res; Complex c2; c2.init(2, 2); res.init( Complex c3; c3.init(3, 3); this->re*c2.re-this->im*c2.im, Complex r = (c1 + c2) * c3; this->re*c2.im+this->im*c2.re); cout << "r = " << r << endl; return res; } }
More Class Examples

#include <iostream> using namespace std; struct Complex { double re, im; void init(double r, double i) { re = r; im = i; }
Complex (this Not Necessary)

double real() const { return re; } double imag() const { return im; } };
ostream& Complex operator+(const Complex& c2) const { operator<<(ostream& ostr, const Complex& c) { Complex res; return res.init(re+c2.re, im+c2.im); ostr << "(" << c.re return res; << "," << c.im << "i)"; } } Complex operator*(const Complex& c2) const { int main() { // calculate r=(c1+c2)*c3 Complex res; Complex c1; c1.init(1, 1); res.init(re*c2.re - im*c2.im, Complex c2; c2.init(2, 2); re*c2.im + im*c2.re); Complex c3; c3.init(3, 3); return res; Complex r = (c1 + c2) * c3; } cout << "r = " << r << endl; }
More Class Examples

#include <iostream> using namespace std; class Complex { private: double re, im; public: void init(double r, double i) { re = r; im = i; } };
Complex (Access Control)

double real() const { return re; } double imag() const { return im; }
ostream& operator<<(ostream& ostr, const Complex& c) { Complex return operator+(const Complex& c2) const { ostr << "(" << c.real() Complex res; << "," << c.imag() << "i)"; res.init(re+c2.re, im+c2.im); } return res; } int main() { // calculate r=(c1+c2)*c3 Complex Complex c1; c1.init(1, 1); operator*(const Complex& c2) const { Complex c2; c2.init(2, 2); Complex res; Complex c3; c3.init(3, 3); res.init(re*c2.re - im*c2.im, Complex r = (c1 + c2) * c3; re*c2.im + im*c2.re); cout << "r = " << r << endl; return res; } }
Programming in C++
Page 190
More Class Examples

#include <iostream> using namespace std; class Complex { private: double re, im; public: Complex(double r, double i) { re = r; im = i; } };
Complex (Constructor)
ostream& operator<<(ostream& ostr, Complex const Complex& c) { operator+(const Complex& c2) const { return Complex res(re+c2.re, ostr << "(" << c.real() im+c2.im); << "," << c.imag() << "i)"; return res; } } int main() { Complex operator*(const Complex& c2) const { Complex res(re*c2.re-im*c2.im, re*c2.im+im*c2.re); return res; } } // calculate r=(c1+c2)*c3 Complex c1(1, 1); Complex c2(2, 2); Complex c3(3, 3); Complex r = (c1 + c2) * c3; cout << "r = " << r << endl;
Programming in C++
Page 191
More Class Examples

#include <iostream> using namespace std; class Complex { private: double re, im; public: Complex(double r = 0.0, double i = 0.0) { re = r; im = i; } };
Complex (Final Tweaks)

ostream& operator<<(ostream& ostr, const Complex& c) { return const Complex ostr << "(" << c.real() operator+(const Complex& c2) const { << "," << c.imag() << "i)"; return Complex(re+c2.re, } im+c2.im); int main() { } // calculate r=(c1+c2)*c3 const Complex Complex c1(1, 1); operator*(const Complex& c2) const { Complex c2(2, 2); return Complex c3(3, 3); Complex(re*c2.re - im*c2.im, Complex r = (c1 + c2) * c3; re*c2.im+im*c2.re); cout << "r = " << r << endl; } }
Programming in C++
More Class Examples

#ifndef FSTACK_H #define FSTACK_H
FStack Class Interface (.h)
class FStack { public: FStack(int sz = FStack_def_size); FStack(const FStack& src); ~FStack(); FStack& operator=(const FStack& src); void push(float val); float pop(); bool empty(); private: static const int FStack_def_size = 7; float* vals; int top, size; void init(int tp, int sz, float* vs); }; #endif
More Class Examples
FStack Class Implementation (.cpp)
Default constructor, helper function and standard member functions FStack::FStack(int sz) { init(0, sz, 0); } void FStack::init(int tp, int sz, float* vs) { top = tp; size = sz; vals = new float[size]; assert (vals != 0); for (int i=0; i<top; ++i) vals[i] = vs[i]; } void FStack::push(float val) { assert (top <= size); vals[top++] = val; } float FStack::pop() { assert (top > 0); return vals[--top]; } bool FStack::empty() { return (top == 0); }
More Class Examples

FStack has pointer data member
FStack Class Implementation (.cpp)
need copy constructor, destructor, and assignment operator FStack::FStack(const FStack& src) { init(src.top, src.size, src.vals); } FStack::~FStack() { delete [] vals; } assignment operator: dont forget self test, deep copy, and to return *this! FStack& FStack::operator=(const FStack& src) { if ( this != &src ) { delete [] vals; init(src.top, src.size, src.vals); } return *this; } Dont forget to define static data members! const int FStack::FStack_def_size;
Programming in C++
Page 195
More Class Examples

#ifndef EMPLOYEE_H #define EMPLOYEE_H #include "String.h"
Employee Class Interface (.h)
class Employee { public: Employee(const String& name, int id); String name() const; int ident() const; const Employee* manager() const; void setManager(const Employee* mgr); bool isDirector() const; private: Employee& operator=(const Employee&); Employee(const Employee&); String ename; int eid; const Employee* emgr; }; #endif
More Class Examples
Employee Class Implementation (.cpp)
Employee has pointer data member: why no copy constructor, destructor? Pointer used as pointer / link / reference (not for implementation of dynamic storage)! initialize to 0 or address of other object make copy constructor and assignment operator private if it makes sense Constructor: use member initialization lists for efficiency! Employee::Employee(const String& name, int id) : ename(name), eid(id), emgr(0) {} Access functions: const String Employee::name() const { return ename; } int Employee::ident() const { return eid; } const Employee* Employee::manager() const { return emgr; } Other members: void Employee::setManager(const Employee* mgr) { emgr = mgr; } bool Employee::isDirector() const { return (emgr == 0); }
Programming in C++
Page 197
More Class Examples

#ifndef RATIONAL_H #define RATIONAL_H #include <iostream> using namespace std; class Rational {
Rational Class Definition (.h)
Allow multiple inclusion of class header file; Include necessary system headers
private part: class specific data + any necessary helper functions private: long num; long den; // numerator // denominator (keep > 0!) // helper function for normalization
long gcd(long, long); public:
Define standard member functions: constructors Rational() : num(0), den(1) {} Rational(long n, long d = 1); // Rational(const Rational& rhs) : num(rhs.num),den(rhs.den){}
More Class Examples

// ~Rational(void) {}

// compiler generated // compiler gen.
Standard member functions: destructor, assignment operators
// Rational& operator=(const Rational& rhs); Rational& operator=(long rhs); Access functions: const + typically inline! long numerator(void) const { return num; } long denominator(void) const { return den; } Unary operators: const + return value!
Rational operator+(void) const { return *this; } Rational operator-(void) const { return Rational(-num, den); } Rational invert(void) const { return Rational(den, num); } Binary shortcut operators: not const + return const reference + take const reference! const const const const
Programming in C++
Rational& Rational& Rational& Rational&
operator+=(const operator-=(const operator*=(const operator/=(const
Rational& Rational& Rational& Rational&
rhs); rhs); rhs); rhs);

Page 199
More Class Examples

const const const const Rational& Rational& Rational& Rational& operator+=(long operator-=(long operator*=(long operator/=(long

rhs); rhs); rhs); rhs);
Binary shortcut operators for mixed mode arithmetic
Increment / decrement iterators: not const + return const const const const const Rational& Rational Rational& Rational operator++(); operator++(int); operator--(); operator--(int);
Conversion operator: const + no return type! // -- better implemented as explicit conversion // -- function toDouble (see below) // operator double(void) const { return double(num)/den; } };
Programming in C++
Page 200
More Class Examples

const const const const Rational Rational Rational Rational operator+(const operator-(const operator*(const operator/(const

Rational& Rational& Rational& Rational& l, l, l, l, const const const const Rational& Rational& Rational& Rational& r); r); r); r);
Binary operators: global to get conversion on both arguments + return const value!
Boolean operators: global to get conversion on both arguments + take const reference! bool bool bool bool bool bool operator==(const Rational& lhs, const Rational& rhs); operator!=(const Rational& lhs, const Rational& rhs); operator<=(const Rational& lhs, const Rational& rhs); operator>=(const Rational& lhs, const Rational& rhs); operator<(const Rational& lhs, const Rational& rhs); operator>(const Rational& lhs, const Rational& rhs);
Output operator: global + take const reference! ostream& operator<< (ostream& s, const Rational& r); Other global functions: take const reference Rational rabs(const Rational& rhs);
More Class Examples
Multi-line inline function definitions (should really be in Rational.inl) Assignment operators (no selftest as there are no pointer members and probably no speed improvement) // compiler generated: // inline Rational& Rational::operator=(const Rational& rhs) { // num = rhs.num; den = rhs.den; // return *this; // } inline Rational& Rational::operator=(long rhs) { num = rhs; den = 1; return *this; } Explicit conversion function Rational double: take const reference inline double toDouble (const Rational& r) { return double(r.numerator())/r.denominator(); }
More Class Examples
Explicit conversion functions Rational long: take const reference inline long trunc(const Rational& r) { return r.numerator() / r.denominator(); } inline long floor(const Rational& r) { long q = r.numerator() / r.denominator(); return (r.numerator() < 0 && r.denominator() != 1) ? --q : q; } inline long ceil(const Rational& r) { long q = r.numerator() / r.denominator(); return (r.numerator() >= 0 && r.denominator() != 1) ? ++q : q; } Explicit conversion function double Rational Rational toRational(double x, int iterations = 5); Dontt forget this! #endif
Programming in C++
;-)
// RATIONAL_H
More Class Examples

Greatest common divisor: euclids algorithm keep class Rational local
Rational Helper Function (.cpp)
long Rational::gcd(long u, long v) { long a = labs(u), b = labs(v); long tmp; if (b > a) { tmp = a; a = b; b = tmp; } for(;;) { if (b == 0L) return a; else if (b == 1L) return b; else { tmp = b; b = a % b; a = tmp; } } }
More Class Examples

Put object in welldefined state #include <stdlib.h>
Rational Constructor (.cpp)
Rational::Rational(long n, long d) { // default values in header! if (d == 0L) { cerr << Division by Zero << endl; exit(1); } // always keep sign in numerator if (d < 0L) { n = -n; d = -d; } if (n == 0L) { num = 0L; den = 1L; } else { // always keep normalized form long g = gcd(n, d); num = n/g; den = d/g; } }
Programming in C++
Page 205
More Class Examples

Start with operator+=() To keep operators consistent More efficient this way Take const reference + return const reference! Avoid overflow!
Rational Addition (.cpp)
const Rational& Rational::operator+=(const Rational& rhs) { long g1 = gcd(den, rhs.den); if (g1 == 1L) { // 61% probability! num = num*rhs.den + den*rhs.num; den = den*rhs.den; } else { long t = num * (rhs.den/g1) + (den/g1)*rhs.num; long g2 = gcd(t, g1); num = t/g2; den = (den/g1) * (rhs.den/g2); } return *this; }
More Class Examples

Binary shortcut operators for mixed mode arithmetic
Rational Addition (.cpp)
g1 == 1 and rhs.den == 1 always: simplifies considerably! const Rational& Rational::operator+=(long rhs) { num = num + den*rhs; return *this; } Binary addition operator: define out of operator+=() global to get conversion on both arguments Take const references return const value! const Rational operator+(const Rational& l, const Rational& r) { return Rational(l) += r; }
Programming in C++
Page 207
More Class Examples
Rational Substraction (+ -) (.cpp)
const Rational& Rational::operator-=(const Rational& rhs) { long g1 = gcd(den, rhs.den); if (g1 == 1L) { // 61% probability! num = num*rhs.den - den*rhs.num; den = den*rhs.den; } else { long t = num * (rhs.den/g1) - (den/g1)*rhs.num; long g2 = gcd(t, g1); num = t/g2; den = (den/g1) * (rhs.den/g2); } return *this; } const Rational& Rational::operator-=(long rhs) { num = num - den*rhs; return *this; } const Rational operator-(const Rational& l, const Rational& r) { return Rational(l) -= r; }
More Class Examples
Rational Multiplication (.cpp)
Apply the same guidelines to multiplication operators const Rational& Rational::operator*=(const Rational& rhs) { long g1 = gcd(num, rhs.den); long g2 = gcd(den, rhs.num); num = (num/g1) * (rhs.num/g2); den = (den/g2) * (rhs.den/g1); return *this; } const Rational& Rational::operator*=(long rhs) { long g = gcd(den, rhs); num *= rhs/g; den /= g; return *this; } const Rational operator*(const Rational& l, const Rational& r) { return Rational(l) *= r; }
More Class Examples

Apply the same guidelines to division operators but do not forget special case of division by zero!
Rational Division (.cpp)
const Rational& Rational::operator/=(const Rational& rhs) { if (rhs == 0) { cerr << Division by Zero << endl; exit(1); } long g1 = gcd(num, rhs.num); long g2 = gcd(den, rhs.den); num = (num/g1) * (rhs.den/g2); den = (den/g2) * (rhs.num/g1); if (den < 0L) { num = -num; den = -den; } return *this; }
Programming in C++
Page 210
More Class Examples
Rational Division (.cpp)
const Rational& Rational::operator/=(long rhs) { if (rhs == 0L) { cerr << Division by Zero << endl; exit(1); } long g = gcd(num, rhs); num /= g; den *= rhs/g; if (den < 0L) { num = -num; den = -den; } return *this; } const Rational operator/(const Rational& l, const Rational& r) { return Rational(l) /= r; }
Programming in C++
Page 211
More Class Examples
Rational Increment/Decrement (.cpp)
Prefix operators: define out of binary shortcut operator + return const reference const Rational& Rational::operator++() { return (*this += 1); } const Rational& Rational::operator--() { return (*this -= 1); } Postfix operators: define out of prefix operators + return const value const Rational Rational::operator++(int) { Rational oldVal = *this; ++(*this); return oldVal; } const Rational Rational::operator--(int) { Rational oldVal = *this; --(*this); return oldVal; }
More Class Examples

Boolean operators
Rational Boolean Operators (.cpp)
global to get conversion on both arguments Take const references return type bool bool operator==(const Rational& lhs, const Rational& rhs) { return (lhs.numerator() == rhs.numerator() && lhs.denominator() == rhs.denominator()); } bool operator!=(const Rational& lhs, const Rational& rhs) { return (lhs.numerator() != rhs.numerator() || lhs.denominator() != rhs.denominator()); }
Programming in C++
Page 213
More Class Examples

In a sense, this is a cheat :-) but simple and efficient implementation
Rational Boolean Operators (.cpp)
bool operator<(const Rational& lhs, const Rational& rhs) { return (toDouble(lhs) < toDouble(rhs)); } bool operator>(const Rational& lhs, const Rational& rhs) { return (toDouble(lhs) > toDouble(rhs)); } Define <= and >= out of < and == or > and == repectively bool operator<=(const Rational& lhs, const Rational& rhs) { return ((lhs < rhs) || (lhs == rhs)); } bool operator>=(const Rational& lhs, const Rational& rhs) { return ((lhs > rhs) || (lhs == rhs)); }
More Class Examples
Rational Global Functions (.cpp)
Example of related global function: take const reference + return value! Could overload abs, but named rabs in consistency with abs, labs, and fabs Rational rabs(const Rational& r) { if (r.numerator() < 0) return -r; else return r; } Output operator: take const reference + take/return reference to ostream ostream& operator<< (ostream& s, const Rational& r) { if (r.denominator() == 1L) s << r.numerator(); else { s << r.numerator(); s << "/"; s << r.denominator(); } return s; }
Programming in C++
Page 215
More Class Examples

Uses method of continued fractions:
toRational Conversion (.cpp)
Explicit conversion function double Rational repeatedly replace fractional part of number to convert x with Example:
1 1 1 1 0.12765 = ------------------------ = ------------------------------- = ------------------------------------- = ------------------------------------7.8333686 1 1 1 7 + --------------------7 + ---------------------------7 + --------------------------1.199949 1 1 1 + -----------------1 + ----------------5.00126 1 5 + -------787 1 --------1x
1/787 is very small, so approximate it with 0, then simplify:

1 1 1 1 1 6 ------------------------------ = --------------------- = ---------------- = ----------- = ---------- = ----1 1 1 5 47 47 ----7 + --------------------7 + ----------7 + ------7 + -1 1 6 6 6 1 + ----------1 + --5+0 5 5
Only Problem left: how to implement the termination rule?
Programming in C++
Page 216
More Class Examples
Recursive implementation of method of continued fractions static Rational toRational(double x, double limit, int iterations) { double intpart; double fractpart = modf(x, &intpart); double d = 1.0 / fractpart; long left = long(intpart); if ( d > limit || iterations == 0 ) { // approximation good enough, stop recursion return Rational(left); } else { // remember left part and add inverted approximation // of fractional part return Rational(left) + toRational(d, limit * 0.1, --iterations).invert(); } }
Programming in C++
Page 217
More Class Examples
Wrap internal recursive function for general usage: Rational toRational(double x, int iterations) { if ( x == 0.0 || x < numeric_limits<long>::min() || x > numeric_limits<long>::max() ) { // x==0 or x too small or too large to represent in a long return Rational(0,1); } else { // setup recursive call // take care of negative numbers! int sign = x < 0.0 ? -1 : 1; return sign * toRational(sign * x, 1.0e12, iterations); } }
Programming in C++
Page 218
More Class Examples
Example Usage: Harmonic Numbers
Harmonic Number defined as Hn = 1/1 + 1/2 + 1/3 + ... + 1/n Rational harmonic(int n) { Rational r = 1; for (int i=2; i<=n; ++i) r += Rational(1,i); return r; } Approximate Eulers constant =0.5772156 out of Hn = log n + + (1/2n) (1/12n2) + O(1/4n4) int main() { cout << n\tEuler Approx.\tHarmonic(n) << endl; cout << ======================================== << endl; for (int n=1; n<25; ++n) { Rational r = harmonic(n); double g = toDouble(r) - log(n); g -= (1.0/(2*n)) * (1.0 - (1.0/(6*n))); cout << n << \t << g << \t << r << endl; } }
Programming in C++
Page 219
More Class Examples

n Euler Approx. Harmonic(n) ======================================== 1 0.58333333 1 2 0.57768615 3/2 3 0.57731364 11/6 4 0.57724731 25/12 5 0.57722875 137/60 6 0.57722201 49/20 7 0.5772191 363/140 8 0.57721768 761/280 9 0.57721693 7129/2520 10 0.57721649 7381/2520 11 0.57721623 83711/27720 12 0.57721607 86021/27720 13 0.57721596 1145993/360360 14 0.57721588 1171733/360360 15 0.57721583 1195757/360360 ... 23 0.57721569 444316699/118982864 24 0.57721569 1347822955/356948592
Harmonic Output
Page 220
More Class Examples

n1
Example Usage: Bernoulli Numbers

n + 1 B ( n + 1 ) B n = k k = 0 k
Bernoulli Numbers defined as
and
B0 = 1
great importance for the construction of asymptotic series Rational bernoulli(int n) { if (n < 0) { cerr << index out of range << endl; exit(1); } else if (n == 0) return 1; else if (n == 1) return Rational(-1,2); if (n % 2) return 0; Rational r = 0; for (int k=0; k<n; ++k) { r -= binomial(n+1, k) * bernoulli(k); } r /= n+1; return r; } need routine for binomial coefficients
Programming in C++
Page 221
More Class Examples

Use equation
n = [ ( n k + 1 ) k ] n k 1 k
Bernoulli Numbers
and use binomials in the form of rationals
Rational binomial(int n, int k) { if (n < 0) { cerr << 1st out of range << endl; exit(1); } if (k < 0 || k > n) { cerr << 2nd out of range << endl; exit(1); } if (k > n-k) k = n-k; if (k == 0) return 1; return Rational(n-k+1, k) * binomial(n, k-1); } Tabulate Bernoulli numbers from 0 to 23 (for all but n=1 the odd numbers are zero) int main() { cout << endl << n\tBernoulli(n) << endl; cout << ======================================== << endl; Rational b; for (int n=0; n<23; ++n) { if ((b=bernoulli(n)) != 0) cout << n << \t << b << endl; } }
More Class Examples

n Bernoulli(n) ======================================== 0 1 1 -1/2 2 1/6 4 -1/30 6 1/42 8 -1/30 10 5/66 12 -691/2730 14 7/6 16 -3617/510 18 43867/798 20 -174611/330 22 854513/138
Bernoulli Output
Programming in C++
Page 223
More Class Examples
Reference Counting
Reference Counting := instead of deep copy (for assignment or copy initialization) do shallow copy but count how many objects share the data use if objects are often copied (through assignment or parameter passing!) and copying is expensive because objects are large / complex Example: String s1 = "foo bar", s2 = s1;
str s1
f o o b a r \0
rep s1 str rc=2 f o o b a r \0
str s2
f o o b a r \0 "without reference count"
rep s2 "with reference count"
Programming in C++
Page 224
More Class Examples

Reference Counting is special case of handle/body class idiom Handle class := user visible class Body class := Helper class for data representation handle class is friend of body class all members of body class are private contains (typically) only ctor/dtor and necessary data members
The Body Class
class StringRep { friend class String; private: StringRep(const char *s = 0) { set_str(s); } // constructor ~StringRep(void) { delete [] str; } // destructor void set_str(const char *); // auxiliary help function char *str; // pointer to string value int rc; // reference counter };
More Class Examples

Handle class String implements extra intelligence to do the reference counting forwards / uses the body class StringRep Private data now pointer to body class StringRep class String { private: StringRep *rep;
The Handle Class
Default constructor allocates StringRep object and sets reference count to 1 public: String(const char *s = 0) { rep = new StringRep(s); rep->rc = 1; } Copy constructor just copies StringRep object and increments reference count String(const String& rhs) { rep = rhs.rep; rep->rc++; }
More Class Examples

Destructor deletes StringRep object if it is no longer referenced
The Handle Class
~String(void) { if (--rep->rc <= 0) delete rep; } Access functions "forward" operation to StringRep object const char *c_str(void) { return (const char *) rep->str; } int length(void) const { return strlen(rep->str); } Other member functions ... // assignment operators String& operator=(const char *rhs); String& operator=(const String& rhs); // equality test operator bool operator==(const String& rhs); // concatenation operator const String operator+(const String& rhs); };
Programming in C++
Page 227
More Class Examples

String assignment operator deletes old StringRep object if no longer referenced
Assignment Operators
just copies StringRep object and increments reference count in addition to the usual self-test and returning a reference for daisy-chaining String& String::operator=(const String& rhs) { if (rep == rhs.rep) // includes (this == &rhs)! return *this; if (--rep->rc <= 0) delete rep; rep = rhs.rep; rhs.rep->rc++; return *this; } (char *) to String Assignment String& String::operator=(const char *rhs) { if (--rep->rc <= 0) delete rep; rep = new StringRep(rhs); rep->rc = 1; return *this; }
More Class Examples
Equality test operator compares pointers first for speed "forwards" operation to StringRep object bool String::operator==(const String& rhs) { if (rep == rhs.rep) // time saver return true; return !strcmp(rep->str, rhs.rep->str); }
Programming in C++
Page 229
More Class Examples

(Inefficient) String concatenation operator
Concatenation Operator
new dynamically generated character string is copied again in StringRep constructor could be avoided by providing additional StringRep constructor that either takes two character strings as parameters or doesnt copy its argument const String String::operator+(const String& rhs) { // construct new value char *buf = new char [length() + rhs.length() +1]; assert(buf != 0); strcpy(buf, rep->str); strcpy(buf + length(), rhs.rep->str); // construct result String and StringRep objects String result(buf); delete [] buf; return result; }
Programming in C++
Advanced I/O
Programming in C++
Page 231
Advanced I/O
C++ introduces a new concept for handling I/O: streams include the C++ header file <iostream> instead of <stdio.h> IOstreams are part of the standard C++ library using namespace std; each stream has some source or sink which can be standard input standard output a file an array of characters Advantages of C++ stream I/O type safety runtime efficiency extensibility
Basics
Page 232
Advanced I/O
Streams used for output are objects of this class The insertion operator<<() writes data to an ostream put() member function writes one char to an ostream ostream& put(char); write() member function writes chars to an ostream ostream& write(const char *buf, int nchars); Predefined ostream cout connected to standard output cerr and clog connected to standard error
The ostream Class
Hint: use parenthesis to guarantee order of action when printing expressions cout << a + b; cout << (a + b); cout << (a & b); cout << a & b;
Programming in C++
// OK: + has higher precedence // than << // << has higher precedence than & // probably error: (cout << a) & b
Advanced I/O
Buffered Output
Output to ostream objects is buffered by default (like C stdio). Generally, buffers flush only when: Full Program terminates flush() function A flush manipulator is inserted into the stream (explained in a second) Predefined ostream cout and clog is buffered cerr is unit-buffered (i.e., its buffer is flushed after every insertion operation) cout is also flushed whenever cin or cerr streams are accessed
Programming in C++
Page 234
Advanced I/O
Overloading operator<<()
Recall: operator<<() can be overloaded to allow writing of user-defined types takes ostream& as its first argument returns the same ostream to allow daisy-chaining cout << somevalue << anothervalue; Typical definition ostream& operator<<(ostream& ostr, const T& val) { // write components of T return ostr; } Example: Complex::operator<<() ostream& operator<<(ostream& ostr, const Complex& rhs) { return ostr << "(" << rhs.real() << "," << rhs.imag() << "i)"; }
Advanced I/O
Streams used for input are objects of this class The extraction operator>>() reads data from an istream get() member function reads one char from an istream int get();
The istream Class
getline() and read() member functions read chars from an istream istream& getline(char *buf, int nchars, char delim=\n); istream& read(char *buf, int nchars); Predefined cin connected to standard input In general, leading whitespace characters (spaces, newlines, tabs, form-feeds, ...) are ignored istream can be tested whether extraction was successful if ( cin >> somevalue ) { // reading somevalue OK ... }
Programming in C++
Page 236
Advanced I/O
Overloading operator>>()
Recall: operator>>() can be overloaded to allow reading of user-defined types takes istream& as its first argument converts characters from istream, stores them in second argument returns the same istream to allow daisy-chaining cin >> somevalue >> anothervalue; Typical definition istream& operator>>(istream& istr, T& val) { // read components of T // check validity !!! return istr; } Checking validity of istream and input characters is non-trivial! "robust" operator>>() for compound types hard to write
Advanced I/O
Some useful iostream functionality for implementing operator>>() Reading arbitrary text: string extractor (skips leading whitespace, reads until next whitespace) string buffer; cin >> buffer; If string not available, use the (char *) extractor char buffer[80]; cin >> setw(80) >> buffer; Reading any single character (e.g., if skipping leading whitespace is a problem) int c2; c2 = cin.get(); Peeking at input (look at next character without extracting it) if (cin.peek() != ch) ... Pushing back a character into the stream cin.putback(ch); Ignore the next count characters or until delimiter delim is read (whatever comes first) cin.ignore(count, delim);
Programming in C++
Page 238
Advanced I/O
Conventions for implementing operator>>()
After calling operator>>(), istream should "point" to the first illegal character In case of format errors, set ios_base::failbit and do not change output parameter Example: Rational::operator>>() accepted formats: # and #/# where # is integer number istream& operator>> (istream& istr, Rational& r) { long n = 0, d = 1; istr >> n; if ( istr.peek() == '/' ) { istr.ignore(1); istr >> d; } if ( istr ) r = Rational(n,d); return istr; }
Programming in C++
Page 239
Advanced I/O
Example: Complex::operator>>() accepted formats: #, (#), (#,#), and (#,#i) where # is floating-point number istream& operator>>(istream& istr, Complex& rhs) { double re = 0.0, im = 0.0; char c = 0; istr >> c; if (c == '(') { istr >> re >> c; if (c == ',') istr >> im >> c; if (c == 'i') istr >> c; if (c != ')') istr.clear(ios_base::failbit); } else { istr.putback(c); istr >> re; } if (istr) rhs = Complex(re, im); return istr; } still not complete: doesnt handle #i, (#i), ...
// set state
Advanced I/O
Use "#include <fstream>" Instantiate object of correct stream class ifstream ofstream fstream Read-only files Write-only files Read/Write files
File I/O
Associate stream object with external file name by using open() function or initializer list Typical usage ifstream foofile("foo"); ofstream foofile("foo"); // open existing file "foo" readonly
// create new file "foo" for writing // overwrite if already existing if (!foofile) cerr << "unable to open file foo" << endl;
use normal stream operations to read from and write to file foofile << somevalue << anothervalue << endl;
Advanced I/O
File open Modes
Set file open mode by using optional second argument ios_base::in ios_base::out ios_base::ate ios_base::app ios_base::trunc ios_base::binary open for reading open for writing start position at end of le append mode: all additions at end of le delete old le contents at open open file in binary mode
The mode is constructed by or-ing the predefined values // append to file foo ofstream foofile("foo", ios_base::out|ios_base::app);
Programming in C++
Page 242
Advanced I/O
ios_base Flag combination binary in + + + + + + + + + + + + + + + + + + + + + + + + + + + + out trunc app
File open Modes
Comparison open mode flags with stdio equivalents (ignoring ios_base::ate) stdio equivalent "r" "w" "w" "a" "r+" "w+" "rb" "wb" "wb" "ab" "r+b" "w+b" Only the combination of ags shown in the table are allowed!
Programming in C++
Page 243
Advanced I/O
File I/O
Declaring istream without connecting to a filename and opening the file later with open() (also has optional 2nd argument for file open mode) ofstream outfile; outfile.open("foo");
Closing files fstream destructor closes file automatically manually by using close() ifstream infile; for (char** f=&argv[1]; *f; ++f) { infile.open(*f, ios_base::in); ... infile.close(); infile.clear(); }
Programming in C++
Page 244
Advanced I/O
Complicated way to calculate harmonic number H100 #include <fstream> using namespace std; #include <stdlib.h>
File I/O Example
int main(int, char**) { ofstream out("iotest.out"); if (!out) { cerr << "error opening 'iotest.out'" << endl; exit(1); } for (int n=1; n<=100; ++n) out << (1.0/n) << endl; double d, sum = 0.0; ifstream in("iotest.out"); if (!in) { cerr << "error opening 'iotest.out'" << endl; exit(1); } while (in >> d) sum += d; cout << "sum: " << sum << endl; }
Advanced I/O
Format flags describe the streams current format state Flag skipws left / right internal dec / oct / hex fixed scientific 0 showbase showpos showpoint uppercase unitbuf stdio boolalpha Flag Group Description
Format Control
skip leading whitespace on input adjustfield left / right justification padding after sign or base basefield floatfield decimal / octal / hexadecimal conversion fixed point notation exponential notation general format (default) show base indicator on output (int) show + sign if positive always show decimal point (float) uppercase hex/exponent output flush all streams after insertion synchronize with C stdio (non-std!) insert/extract booleans as text (new!)
All constants are part of class ios_base, e.g., ios_base::showpos

-Advanced I/O
Stream class member functions to get format flags fmtflags flags()
Format Control
to set format flags (flags combined by using "|" operator): flags = f fmtflags flags(long f) to set or unset additional flags: flags |= f or flags &= ~f fmtflags setf(fmtflags f) fmtflags unsetf(fmtflags f) fmtflags setf(fmtflags f, fmtflags field) to set minimum field width (Only for next value!) int width(int) to set number of significant digits int precision(int) to fill character (default: space) char fill(char) or alternatively: Stream class manipulators (inserted in stream instead of values)
return old values
Advanced I/O
Format Control Example
inline void ifmt(ostream& s, int w, ios_base::fmtflags b) {s.width(w); s.setf(b,ios_base::basefield);} inline void ffmt(ostream& s, ios_base::fmtflags f) {s.setf(f,ios_base::floatfield);} int i = 12345; double d = 3.1415; cout.fill('.'); cout.setf(ios_base::showbase); ifmt(cout,10,ios_base::dec); cout ifmt(cout,10,ios_base::oct); cout ifmt(cout,10,ios_base::hex); cout cout << endl; cout.precision(3); ffmt(cout,ios_base::fmtflags(0)); ffmt(cout,ios_base::scientific); ffmt(cout,ios_base::fixed); prints: .....12345....030071....0x3039 3.14
Programming in C++
<< i; << i; << i;
// "%#10d" // "%#10o" // "%#10x"
cout << d << " "; cout << d << " "; cout << d << endl;
// "%.3g" // "%.3e" // "%.3f"
3.142e+00
3.142
Advanced I/O
Predefined manipulators: istream istr; ostream ostr; Description
Predefined Manipulators
Predefined Manipulator ostr << dec, istr >> dec ostr << oct, istr >> oct ostr << hex, istr >> hex ostr << endl ostr << ends ostr << flush istr >> ws
makes the integer conversion base 10 makes the integer conversion base 8 makes the integer conversion base 16 inserts a newline character (\n) and calls ostream::flush() inserts a null character (\0). useful when dealing with strstream calls ostream::flush() extracts whitespace characters (skips whitespace) until a non-white character is found
Also: [no]boolalpha, [no]showbase, [no]skipws, [no]showpoint, [no]showpos, [no]uppercase, scientific, fixed, left, right, internal
Advanced I/O
long f; int n; char c; istream istr; ostream ostr; Predefined Manipulator ostr << setbase(n) istr >> setbase(n) ostr << setw(n), istr >> setw(n) ostr << resetiosflags(f) istr >> resetiosflags(f) ostr << setioflags(f), istr >> setioflags(f) ostr << setfill(c), istr >> setfill(c) ostr << setprecision(n), istr >> setprecision(n)
Additional Manipulators
Additional manipulators (those with arguments) defined in "<iomanip>"
Description set the integer conversion base to n sets the minimal field width to n Only for next value! clears the flags bitvector according to the bits set in f sets the flags bitvector according to the bits set in f sets the fill character to c (for padding a field) sets the floating-point precision to n digits
Programming in C++
Page 250
Advanced I/O
A plain manipulator is a function that takes a reference to a stream operates on it in some way returns its argument Example: a tab manipulator ostream& tab(ostream& ostr) { return ostr << \t; } ... cout << x << tab << y << endl; This is just a simple example; for tabs better use const char tab = \t; ... cout << x << tab << y << endl;
Defining a Plain Manipulator
Programming in C++
Page 251
Advanced I/O
Defining a Plain Manipulator
A more complex example: switch floating-point format
#include <iostream> #include <iomanip> using namespace std;
ostream& general(ostream& ostr) { ostr.setf(ios_base::fmtflags(0), ios_base::floatfield); return ostr; }
int main() { double pi = 3.1415; cout << scientific << pi << endl; cout << general << pi << endl; }
Programming in C++
Page 252
Advanced I/O
#include <iostream> #include <iomanip> using namespace std; // define manipulator general here
Format Manipulators Example
int main(int, char**) { int i = 12345; double d = 3.1415; cout cout cout cout cout cout cout cout } prints: _____12345____030071____0x3039 3.14
Programming in C++
<< << << << << << << <<
setfill('_') << showbase; setw(10) << dec << i; setw(10) << oct << i; setw(10) << hex << i << endl; setprecision(3); general << d << " "; scientific << d << " "; fixed << d << endl;
// "%#10d" // "%#10o" // "%#10x" // "%.3g" // "%.3e" // "%.3f"
3.142e+00
3.142
Advanced I/O
Usage outfile.write((char *) &x, sizeof(x)); infile.read ((char *) &x, sizeof(x)); Be careful if type of x is a class with pointer fields virtual member functions which requires non-trivial constructor actions restrict usage to input/output of built-in types
Binary I/O
Example: binary read and write of double: double d; outfile.write((char *) &d, sizeof(double)); infile.read ((char *) &d, sizeof(double)); // or: sizeof(d)
Programming in C++
Page 254
Advanced I/O
Source or sink are C++ standard library strings (string) C++ equivalent to sscanf and sprintf Use #include <sstream> Has classes ostringstream, istringstream, and stringstream sstream member function str() returns constructed string Example #include <sstream> #include <string> using namespace std; ostringstream os; int i = 15, j, k; os <> i >> j >> k;
String I/O
Page 255
Advanced I/O
use ostringstream for temporary buffering! Example: Complex::operator<<() #include <sstream> using namespace std;
Problem: operator<<() for compound types does not obey width stream attribute
ostream& operator<<(ostream& ostr, const Complex& rhs) { ostringstream buf; buf.flags(ostr.flags()); // copy stream flags buf.precision(ostr.precision()); // copy precision buf << "(" << rhs.real() << "," << rhs.imag() << "i)"; ostr << buf.str(); return ostr; }
Programming in C++
Page 256
Advanced I/O
Another example: Rational::operator<<() #include <sstream> using namespace std;
ostream& operator<< (ostream& ostr, const Rational& r) { if (r.denominator() == 1L) ostr << r.numerator(); else { ostringstream buf; buf.flags(ostr.flags()); buf.fill(ostr.fill());
// copy stream flags // copy fill character
buf << r.numerator() << "/" << r.denominator(); ostr << buf.str(); } return ostr; }
Programming in C++
Page 257
Advanced I/O
The get Pointer Identifies the current extraction point from an input stream Advances automatically when stream data is extracted Can be explicitly re-positioned using the seekg() function:
Random File Access
istream& seekg(streamoff nbytes, seekdir base); Current value is returned by the tellg() function: streampos tellg(); The put Pointer Identifies the current insertion point into an output stream Advances automatically when stream data is inserted Can be explicitly re-positioned using the seekp() function: ostream& seekp(streamoff nbytes, seekdir base); Current value is returned by the tellp() function: streampos tellp(); Base Position Specification base can be ios_base::beg (beginning of file), cur (current position), end (EOF)
Advanced I/O
eofbit: EOF on input
Stream (Error) State Handling
Stream State is represented internally for each stream by the flags failbit: format errors (e.g., number begins with letter) badbit: no space left on device or read from ostream or write on istream Use stream class methods to determine current stream state stream state function int good() const int eof() const int fail() const int bad() const int operator! () const operator void*() const Description no state flag set? eofbit set? failbit or badbit set? badbit set? like fail() return 0 if failbit or badbit set otherwise this
Check stream state after any stream operation that might produce error (especially input) There are also methods for clearing or setting stream state (rdstate, clear, setstate)
Advanced I/O
Books on C++ iostreams Josuttis, The C++ Standard Library A Tutorial and Reference, Addison-Wesley, 1999, ISBN 0-201-37926-0. Most up-to-date and complete book on whole C++ standard library (including iostream, string, complex, ...) Covers also more advanced topics like streambufs and internationalization
Books
Langer and Kreft, IOStreams and Locales: Advanced Programmer's Guide and Reference, Addison-Wesley, Januar 2000, ISBN 0-201-18395-1. Everything you want and do not want to know about iostreams
General C++ Books (but cover iostreams quite well) Stroustrup, The C++ Programming Language, Third Edition Lippman and Lajoie, C++ Primer, Third Edition
Programming in C++
Page 260
Programming in C++
Array Redesign
Programming in C++
Page 261
Array Redesign
The problems of C and C++ built-in arrays The size must be a constant sometimes hard to decide on in advance certainly not changed later The array does not carry around its own size when passing arrays, size has to explicitly passed, too Cannot assign: array1 = array2; No range checking: cout << array1[-3]; // error!
Motivation
// compiles! bad! // often no runtime error message
Want what arrays can do, plus more...

Array Redesign
Default constructor const int def_farray_size = 7;
FArray Con/Destructors
// outside class definition // in public: section // note: len not const!
FArray(int def_size = def_farray_size); int len = 23; FArray fa1(len); Allocate additional memory for the array safely Zero out or initialize the array Copy constructor FArray(const FArray&); FArray fa2(fa1), fa3 = fa2; Prototype to initialize with "normal" array FArray(const float *, int); // called by // called by
float normal_c_array[22] = { -4.3, 5.7, /*...*/, 84.23 }; FArray fa4(normal_c_array, 22); Destructor: primarily to deallocate free store memory ~FArray(void);
Array Redesign
Assignment operator
FArray Other Member functions
FArray& operator=(const FArray&); fa1 = fa4; Array index operator (name: operator[]()) float& operator[](int); fa4[2] = fa3[5];
// called by
// called twice by // fa4.operator[](2) = fa3.operator[](5)
Return value: a reference to a float to allow usage on lhs of assignments const Array index operator const float& operator[](int) const; to allow indexing constant FArrays Note: overloading based on return type is not allowed, but it is on constness of function Getting size of an FArray int size(void) const; // called by cout << "size of fa2: " << fa2.size() << endl;
Array Redesign
What should internal representation look like? private: float *fa; int sz;
Information to be stored
// pointer to memory holding values // size of array
private: so access only allowed to member functions What have we paid? Eight extra bytes What have we gained? extra four bytes: FArray can be assigned and reassigned another four bytes: retain size information What do we have so far?
Programming in C++
Page 265
Array Redesign
const int def_farray_size = 7; class FArray {
FArray Definition (farray.h)
// float array
public: // constructors and destructor FArray(int def_size = def_farray_size); FArray(const FArray&); FArray(const float *, int); ~FArray(void); // other member functions FArray& operator=(const FArray&); float& operator[](int); const float& operator[](int) const; int size(void) const; private: float *fa; int sz; };
// pointer to memory holding values // size of array
Array Redesign
A Helper Function for Constructors
Motivation: all three constructors do similar things For assistance in defining other constructors (and assignment operators) Therefore, declared in private: section of FArray definition: private: void init(const float *, int); Arguments optionally take an float array for initialization target array size Responsibilities Free store allocate memory for new array Check for success Optionally initialize
Programming in C++
Page 267
Array Redesign
#include <assert.h>
FArray::init() Definition
void FArray::init(const float *array, int size) { // check vality assert(size >= 0); // initialize all class data members sz = size; fa = new float [size]; assert(fa != 0); // quit if new() failed // initialize array values if specified for (int index=0; index<size; index++) { // did we receive an initialization array? fa[index] = (array != (float *)0) ? array[index] : 0.0; } } FArray:: scope otherwise init() would be global
Array Redesign
class FArray {
FArray Constructor Definitions
public: FArray(int def_size = def_farray_size) { init((const float *) 0, def_size); } FArray(const FArray& rhs) { init(rhs.fa, rhs.sz); } FArray(const float *array, int size) { init(array, size); } // ... }; Make constructor definitions (implicitly) inline for speed Note: init() itself cannot be inline as it includes a loop
Array Redesign
FArray Destructor Definition
Recall: constructors called just after allocation of memory for data members, i.e., fa and sz Symmetrically, destructors called just before deallocation of data members no need to reset the data members (fa and sz) Aside from these bytes, what else needs to be done? freeing up memory of free store allocated array class FArray { public: // constructors here ~FArray(void) { delete [] fa; } // ... } Note: also made inline for speed
// note [] !
Array Redesign
FArray::operator=() Definition
FArray& rhs) { self-test free up current memory copy rhs to lhs ref returned for daisy-chaining
FArray& FArray::operator=(const if (this != &rhs) { // delete [] fa; // init(rhs.fa, rhs.sz); // } return *this; // }
Recall: this contains the address of calling object, e.g., fa4 = fa1; // in FArray::operator=(), this == &fa4 If self-test is true, return early (as with String) safe time (nothing to do) avoid catastrophic self-assignment FArray &fa5 = fa3, *pfa = &fa2; //...later fa3 = fa5; *pfa = fa2;
Programming in C++
// or viceversa // ditto
Dr. Aaron Naiman, Jerusalem College of Technology Page 271
Array Redesign
operator[]() and size() Definitions
float& operator[](int index) { return fa[index]; } const float& operator[](int index) const { return fa[index]; } int size (void) const { return sz; }
Recall: operator[]() returns a reference to allow for, e.g., fa3[4]--; fa2[7] = fa5[2]; Inlining: operator=(): probably not operator[]() and size(): yes
Programming in C++
Page 272
Array Redesign
#include <iostream> using namespace std; #include "farray.h" void remove_hot(FArray&); int main(int, char**) {
Using FArray Class
// for compiler: I know that main has // arguments, but I dont use them
const int num_days = 6; float temperature[num_days] = { 23.1, 28.5, 21.3, 33.2, 35.5, 27.5 };// probably read in FArray all_temp(temperature, num_days), not_too_hot = all_temp; remove_hot(not_too_hot); cout << "Temperature of nice days: "; for (int day=0; day<not_too_hot.size(); day++) cout << " " << not_too_hot[day]; cout << endl; }
Array Redesign
void remove_hot(FArray& day_temp) { const float too_hot = 30.0; int num_nice = 0; int day;
remove_hot() Definition
for (day=0; day<day_temp.size(); day++) { if (day_temp[day] < too_hot) num_nice++; } FArray dummy(num_nice); // works for num_nice==0 too: // creates empty array!
num_nice = 0; for (day=0; day<day_temp.size(); day++) { if (day_temp[day] < too_hot) dummy[num_nice++] = day_temp[day]; } day_temp = dummy; }
Programming in C++
Page 274
Array Redesign
Use FArray for dynamic storage
FStack Example
class FStack { public: FStack(int size = FStack_def_size) : vals(size), top(0) {} void push(float val) { assert(top <= vals.size()); } float pop() { assert(top > 0); vals[top++] = val; return vals[--top]; }
bool empty() { return (top == 0); } private: static const int FStack_def_size = 7; FArray vals; int top; }; const int FStack::FStack_def_size; definition of copy constructor, assignment operator, and destructor no longer necessary! size member no longer necessary!
Programming in C++
Page 276
Programming in C++
Templates
Programming in C++
Page 277
Class Templates
FArray fine for float, but what about int, short, char, double, etc. ? Solution: use class templates, as with function templates class templates describe a set of related classes much like classes describe a set of related objects
Motivation
Class definitions are generated (instantiated) by the compiler on the fly when needed: Array<int> ia6(16); Array<char> ca1; // generates code for array of int // generates code for array of char
doesnt save code compared to manual copying but saves programming time and is less error-prone! Some people might prefer more "natural" type names: typedef Array<float> FArray; FArray fa6(16); Note: use only when the type of the objects does not affect the implementation! What does it look like?
Class Templates
const int def_array_size = 7; template<typename T> // historically:
array.h
<class T>
class Array { // name of class, ctors, dtor: Array public: // otherwise: Array<T> Array(int def_size = def_array_size) { init((const T *) 0, def_size); } Array(const Array<T>& rhs) { init(rhs.a, rhs.sz); } Array(const T* ay, int size) { init(ay, size); } ~Array(void) { delete [] a; } Array<T>& operator=(const Array<T>&); T& operator[](int index) { return a[index]; } const T& operator[](int index) const { return a[index]; } int size(void) const { return sz; } private: T *a; int sz; void init(const T*, int); };
Class Templates
Member Definition outside of Class Definition
Definition of member functions outside the template class definition also requires the template<...> specification template<typename T> class Array { public: Array(int def_size = def_array_size); //... }; template<typename T> Array<T>::Array(int def_size) { init((const T *) 0, def_size); } Problem: Template member function definitions need to be known to the compiler cannot compiled away in separate .cpp file Solution: put everything in header file #include corresponding .cpp file at the end of header file (recommended)
Class Templates
We can finally write down a general implementation of our stack example: template<typename T> class Stack { public: Stack(int size = def_size) : vals(size), top(0) {} void push(const T& val) { assert(top <= vals.size()); vals[top++] = val; } T pop() { assert(top > 0); } return vals[--top];
stack.h
bool empty() { return (top == 0); } private: static const int def_size = 7; Array<T> vals; int top; }; template<typename T> const int Stack<T>::def_size;
Class Templates
General Remarks
Main usage of class templates: container types Array<T> queue<T> list<T> set<T> stack<T> deque<T> map<K,T> ...
But also useful for specifying base type size or precision Complex<T> Rational<T> String<T> ... T = float | double | long double T = short | int | long | long long T = char | wchar_t | unicode | ...
Programming in C++
Page 282
Class Templates
Constraints on Template Arguments
C++ provides no direct support for specifying constraints on template arguments e.g., template argument to Rational<T> must be integer-like type Best solution so far: Write well-documented, special constraint template classes of the following form: template<class T> struct Is_integer_like { static void constraints(T a) { T b(0), c(1); b=a%c; a<b; ... } Is_integer_like() { void(*p)(T) = constraints; } }; Constraints can be checked (inside template source code, e.g., constructor) by instantiating a temporary constraint template class object: Is_integer_like<T>(); Constraints can use full expressiveness of C++ No code is generated for a constraint using current compilers Current compilers give acceptable error messages, including the word constraints (to give the reader a clue), the name of the constraints, and the specific error that caused the failure (e.g. expression must have integral or enum type)
Function Templates
Define a family of related functions Function template argument list is used to specify different functions in family
Definition
Normally, each function template argument must be used as a type of some function argument in the function argument list Different functions in the family have different function signatures (argument list profiles) template<typename TYPE> inline void swap(TYPE& v1, TYPE& v2) { TYPE tmp; tmp = v1; v1 = v2; v2 = tmp; } double x, y; int i, j; swap(x, y); swap(i, j); swap(x, i); // compiler generates double version automatically // again for int // error! good!
Programming in C++
Page 284
Function Templates
...Macros
versus...
Function templates are easier to read because they look just like regular function definitions Function template instantiation is less prone to context-related errors than macro expansion Diagnostics for errors in template functions are better than for errors in macros Function templates have scope (e.g., they can be part of a namespace or class) Pointers to function template specializations are possible Function templates can be overloaded or specialized Function templates can be recursive
...Overloaded Functions Use overloaded functions when behaviour of function differs depending on type of function argument(s) Use function template when behaviour of function does not depend on type of function argument(s)
Programming in C++
Page 285
Function Templates
Example: Defining Math Operators
Operators +, *, and prefix and postfix ++ can be defined out of += and *= use function templates template<class T> const T operator*(const T& lhs, const T& rhs) { return T(lhs) *= rhs; } template<class T> const T operator+(const T& lhs, const T& rhs) { return T(lhs) += rhs; } template<class T> T& operator++(T& t) { t += T(1); return t; } template<class T> const T operator++(T& t, int) { T old(t); ++t; return old; } class Complex { /* only need operator+=, operator*=, and Complex(1) */ }; Disadvantage 1: function templates are global and might cause problems with other classes! Disadvantage 2: automatic conversion on arguments no longer works! will be fixed in Chapter Inheritance!
Advanced Templates
Template Specialization
Consider function template for a function to compute the absolute value of a number: template<typename T> inline T abs(T x) { if (x < 0) return -x; else return x; } works for any type T that supports copying, unary -, and binary < (e.g. int or double) doesnt work for complex numbers (not totally ordered, so typically no operator< defined!) Complex c1(2.3, 7.8), c2 = abs(c1); use template specialization template<> inline double abs(Complex z) { return sqrt(z.real()*z.real() + z.imag()*z.imag()); } // error!
Programming in C++
Page 287
Advanced Templates
Class templates may also be specialized:
Template Specialization
template<typename T> class Array { public: // definition of an array of any type ... }; template<> class Array<bool> { public: // definition of an array of bools => bitvector // e.g., pack 8 bits per byte }; Array<int> x(10); Array<bool> bvec(64); Specialized class has specialized implementation can have specialized or different interface
// uses Array<T> // uses Array<bool>
Advanced Templates
Template function overloading template<class T> void foo(T); template<class T> void foo(T*); template<class T> void foo(T**); int i; int *pi = &i; int **ppi = π foo(i); foo(pi); foo(ppi); // #1 // #2 // #3
Advanced Templates
// calls #1 // calls #2 // calls #3
Explicit qualification of template functions (if type cannot be deduced from supplied arguments) template<class T> inline T min(T x, T y) { return(x<y ? x : y); } int i; long l; int a = min<int>(i, l); template<class T, class U> T make(U u); Thing t = make<Thing>(1.23);
Advanced Templates
Member Templates
Problem: implicit type conversions are not inherited by template container classes! template <typename T> class Array { /*...*/ } Array<int> v1; Array<short> v2; v1 = v2; // Error! use member templates to define generic assignment operator template<typename T> class Array { // old public: Array<T>& operator=(const Array<T>&); // ... }; template<typename T> class Array { // new public: template<typename T2> Array<T>& operator=(const Array<T2>&); // ... };
Advanced Templates
Member Templates
Implementation of member templates outside class definition requires the usual prefixes: template<typename T> template<typename T2> Array<T>& Array<T>::operator=(const Array<T2>&) { // ... }
Of course, member templates can be used for other member functions as well e.g., generic constructors Member templates can implement generic member functions inside class templates "ordinary" classes
Programming in C++
Page 291
Advanced Templates
Template Parameters
Template parameters are not restricted to one type ("template<typename Type>") there can also be more than one parameter integral constants (int, bool, char, ...) pointer types and pointer to functions // Two type parameters template<typename type1, typename type2> ... // One type parameter, one integral parameter template<typename T, int N> ... // Pointer to function parameter template<double Tfunc(double)> ... // Monstrosity template<typename T, T Tfunc(T), int N, bool Flag> ... Note: template parameter may not be floating-point constants because the result could differ between platforms
Programming in C++
Page 292
Advanced Templates
Default Template Parameters
Template parameters can also have defaults (very much like function default parameters) template<int N = 10, typename T = char> class FixedArray { T data[N]; // ... }; FixedArray<100, int> a100_ints; FixedArray<256> FixedArray<> b256_char; c10_char; // like int a[100]; // char b[256]; // not: FixedArray c10_char; !
Note: onlys class templates can have default template parameters! (not function or member templates)
Programming in C++
Page 293
Templates
Final Remarks
templates := intelligent macros that support C++ naming, typing, and scope rules
Template Design write concrete example class or function first and test it possibly: use "pseudo" parameters like typedef T <concrete-type-like-int>; to write concrete example class or function will be easier to convert to template later then re-write as template(s)
Templates allow so-called Generic Programming in C++ (more later)
Programming in C++
Page 294
Programming in C++
Inheritance
Programming in C++
Page 295
Inheritance
What has FArray bought us? The size of the FArray need not be constant The FArray knows its own size FArray assignment: fa4 = fa6; Range checking: cout << fa2[-3]; // still bad! What are our options for FArray range checking? Add this capability to FArray::operator[]() Problem: this may be slow, not always desired, e.g.: for(int i=0; i<fa3.size(); i++) fa3[i]=0.0; vs. cin >> farray_index; cout << fa1[farray_index]; Define a new class safeFArray Problem: this will repeat lots of code, error prone Inheritance: Create a subclass!
Programming in C++ Dr. Aaron Naiman, Jerusalem College of Technology
Motivation
// just fine
// unsafe!
Page 296
Inheritance
Goal: a new, derived class (subclass) whose objects are both objects of the base class (superclass), and also specific, specialized objects of the base class
Basic Idea
UML: (Unified Modeling Language) base
derived
single most important rule: a derived object is-a base object, but not vice versa Inheritance is commonly used in two ways reuse mechanism a way to create a new class that strongly resembles an existing one (like safeFArray) abstraction mechanism: a tool to organize classes into hierarchies of specialization describe relationships between user-defined types
Inheritance
Suppose our triangle class
The is-a Test
class triangle { private: Coord v1, v2, v3; /*...*/ }; Possible derived classes: particular characteristic: right_triangle additional field (color): color_triangle they pass the is-a test Not possible derived classes: particular characteristic: trianglar_pipe (is-a pipe, but not a triangle) additional field (v4): rectangle they fail the is-a test Note: trianglar_pipe will probably include triangle data member (hasA)
Programming in C++
Page 298
Inheritance
Basics
Derived class inherits member functions and data members from base class in addition to its own members exceptions: constructors, destructors, operator=(), and friends are not inherited
Access rules for derived class implementation: members of base class can be accessed in can be accessed in which are base class derived class public private protected compare to: client code
Programming in C++
Page 299
Inheritance
Derived Class Definition
General form of derived class definitions: class DerivedClassName : AccessMethod BaseClassname { /* ... */ }; where AccessMethod is one of the following: public (private inherited public base class members stay public in derived class inherited public base class members become private in derived class)
does affect access rights of client code and classes which derive from derived classes specifying AccessMethod public is important as the default is private!
Note: the is-a test only applies to public inheritance!

Inheritance
Public inheritance class b { private: int prv; protected: int prt; public: int pub; void f() { // access to pub, prt, prv } }; class d: public b { private: int dprv; public: int dpub; void df() { // pub, prt, dpub, dprv, f } }; void func() { //b::pub, b::f //d::pub, d::dpub, d::f, d::df }
Programming in C++
Summary: Access Control

Private inheritance class b { private: int prv; protected: int prt; public: int pub; void f() { // access to pub, prt, prv } }; class d: private b { private: int dprv; public: int dpub; void df() { // pub, prt, dpub, dprv, f } }; void func() { //b::pub, b::f //d::pub, d::dpub, d::f, d::df }
Page 301
Inheritance
safeFArray
UML: FArray
how about our safeFArray class? #include "farray.h" class safeFArray : public FArray { public: // new constructors needed (not inherited) // destructor and operator= not inherited but default OK // override definition of operator[]() and operator[]() const }; Placed in "safefarray.h" safeFArray
Programming in C++
Page 302
Inheritance
Constructors and Destructors
Constructors for the base class are always called first, destructors for base classes last. e.g., class base { public: base() { cout << "constructing base" << endl; } ~base() { cout << "destructing base" << endl; } }; class derived : public base { public: derived(){ cout << "constructing derived" << endl; } ~derived(){ cout << "destructing derived" << endl; } }; int main(int, char **) { derived d; } will print out constructing base constructing derived destructing derived destructing base
Inheritance
safeFArray Constructors
Problem: if not otherwise specified, default constructor of base class is called for safeFArray, we always would end up with FArray(def_farray_size) Solution: use the following syntax to specify the base constructor to call: (special case of general member initialization list) class safeFArray : public FArray { public: safeFArray(int size = def_FArray_size) : FArray(size) {} safeFArray(const FArray& rhs) : FArray(rhs) {} safeFArray(const float* fa, int size) : FArray(fa, size) {} // ... }; Note: nothing else needs to be constructed copy constructor can take FArrays Note: only direct base class initialization possible
Inheritance
definition needs reworking, e.g., #include <assert.h> #include "safefarray.h"
safeFArray::operator[]()
we like and keep declaration/interface and must match return value as well, but
float& safeFArray::operator[](int index) { assert(index >= 0 && index < size()); // exit on failure return FArray::operator[](index); // reuse base implementation } const float& safeFArray::operator[](int index) const { // same as above... } both versions of operator[](), const and non-const, must be overridden if possible, reuse base function definition Placed in "safefarray.cpp" safeFArray::operator[]() replaces FArray::operator[]() !!! (unlike constructors/destructors)
Inheritance
Automatic Conversions
Rule: derived objects, pointers to derived objects, and references to derived objects are automatically converted to corresponding base objects if necessary: class base { /*...*/ }; class derived : public base { /*...*/ }; void base_func (base& b); void devd_func (derived& d); base b; derived d; base_func(b); base_func(d); devd_func(d); devd_func(b); // d is-a base // error! class car { /*...*/ }; class rv : public car { /*...*/ }; void drive (car& c); void live_in (rv& r); car c; rv r; drive(c); drive(r); live_in(r); live_in(c); // r is-a car // error!
C++ permissions follow is-a model.
Programming in C++
Page 306
Inheritance
Static Binding
if a inherited member function is overridden by a derived class and called through a pointer or reference, the type of the pointer/reference object itself determines what function gets called: class base { void foo(void); }; class derived : public base { void foo(void); }; derived d, *pd=&d, &rd2=d; base b, *pb=&b, &rb=b, &rd1=d; pb->foo(); rb.foo(); pd->foo(); rd2.foo(); pb = pd; pb->foo(); rd1.foo(); // base::foo() // derived::foo() // or: pb = &d; // base::foo()!!! class car { void park(void); }; class rv : public car { void park(void); }; rv r, *pr=&r, &rr2=r; car c, *pc=&c, &rc=c, &rr1=r; pc->park(); rc.park(); pr->park(); rr2.park(); pc = pr; pc->park(); rr1.park(); // parks car // parks rv // rv is-a car // parks rv like // a car (ouch!)
static binding, i.e., type of member function determined at compile time

Inheritance
Dynamic (or Late) Binding
if a virtual member function is overridden by a derived class and called through a pointer or reference, the type of the pointed to/referenced object determines what function gets called: class base { virtual void foo(void); }; class derived : public base { virtual void foo(void); }; derived d, *pd=&d, &rd2=d; base b, *pb=&b, &rb=b, &rd1=d; pb->foo(); rb.foo(); pd->foo(); rd2.foo(); pb = pd; pb->foo(); rd1.foo(); // base::foo() // derived::foo() // or: pb = &d; // derived::foo() // good! class car { virtual void park(void); }; class rv : public car { virtual void park(void); }; rv r, *pr=&r, &rr2=r; car c, *pc=&c, &rc=c, &rr1=r; pc->park(); rc.park(); pr->park(); rr2.park(); pc = pr; pc->park(); rr1.park(); // parks car // parks rv // rv is-a car // parks rv like // a rv (good!)
dynamic binding, i.e., type of member function determined at run time

Inheritance
Derived class by adding fields to subclass:
Virtual Functions Design Issues
Rule: Never redefine an inherited non-virtual function! likely operator=() and operator==() (at least) will change make them virtual in base class Destructor called through pointer when using new / delete static / dynamic binding rules applies base *pb; derived *pd = new derived; // ... later pb = pd; delete pb; // only calls base::~base()!!!
make destructors virtual in base class (if base has >1 virtual member function; if not, shouldnt be base class in the first place) But: virtual functions cause run-time (indirect call) and space (virtual table) overhead If function needs to be virtual another reason to use member vs. global function Virtual functions supply subclasses with default denitions
Inheritance
What if there is no (useful) default definition? class Shape { public: virtual double area(void) const = 0; // ... };
Pure Virtual Functions
// pure virtual
class Rectangle : public Shape { /* ... */ }; class Circle : public Shape { /* ... */ }; effects of 1 pure virtual function(s) Shape is an abstract base class (ABC) cannot create objects of class Shape but can build subclasses on top of Shape subclasses (Rectangle and Circle) must implement pure virtual functions (and become concrete subclasses), or inherit them, and become an ABC themselves
Inheritance
Dynamic Binding Example
Example: Dene framework for geometrical shapes like rectangles and circles. Each shape has a center (x, y) and methods to move the object and to calculate its area. UML: Shape # x: int # y: int + move() + area() + public member # protected member - private member Circle - r: int abstract member
Rectangle - h: int - w: int
Programming in C++
Page 311
Inheritance
shape.h:
class Shape { protected: int x_, y_; // center public: Shape(int x, int y) : x_(x), y_(y) {} virtual double area() const = 0; void move(int dx, int dy) { x_ += dx; y_ += dy; } }; class Rectangle : public Shape { private: int h_, w_; public: Rectangle(int x, int y, int h, int w) : Shape(x, y), h_(h), w_(w) {} virtual double area() const { return h_*w_; } }; class Circle : public Shape { private: int r_; public: Circle(int x, int y, int rad) : Shape(x, y), r_(rad) {} virtual double area() const { return r_*r_*3.1415926; } };
Programming in C++
Page 312
Inheritance
Main program: #include <iostream> using namespace std; #include "shape.h"
double area(Shape *s[], int n) { double sum = 0.0; for (int i=0; i<n; ++i) sum += s[i]->area(); return sum; } int main(int, char**) { Shape *shapes[3]; shapes[0] = new Rectangle(2,6,2,10); shapes[1] = new Circle(0,0,1); shapes[2] = new Rectangle(3,4,5,5); cout << "area: " << area(shapes, 3) << endl; for (int i=0; i<3; ++i) shapes[i]->move(10, -4); } prints:
Programming in C++
area: 48.1416
Inheritance
Dynamic Binding Example without Inheritance
class Shape { public: enum kind { REC, CIR }; Shape(int x, int y, int h, int w) : x_(x), y_(y), h_(h), w_(w), t_(REC), r_(0) {} Shape(int x, int y, int r) : x_(x), y_(y), h_(0), w_(0), t_(CIR), r_(r) {} void move(int dx, int dy) { x_ += dx; y_ += dy; } double area() { switch (t_) { case REC: return h_*w_; case CIR: return r_*r_*3.1415926; default: return 0.0; } }; private: int x_, y_, h_, w_, r_; kind t_; }; Adding new shape requires changes everywhere kind is used (dont forget one!) Recompilation of all source files necessary which depend on Shape!
Inheritance
Member Function Virtuality
Summary: for public inheritance (derived is-a base), the following rules apply: pure virtual function function interface only is inherited concrete subclasses must supply their own implementation simple (non-pure) virtual function function interface and default implementation is inherited concrete subclasses can supply their own implementation non-virtual function function interface and mandatory implementation is inherited concrete subclasses should not supply their own implementation Function virtuality is an important C++ feature But: polymorphism is not the solution to every programming problem (KISS principle!)
Inheritance
Only member functions can be virtual
Virtualizing Global Functions
Problem: how to make class related global functions (e.g., operator<<()) behave correctly for inheritance introduce public virtual helper method (e.g., print()) derived classes can redefine helper method if necessary class foo { public: virtual ostream& print(ostream& ostr) { // usual implementation of output operator here ... } ... }; ostream& operator<<(ostream& ostr, const foo& f) { return f.print(ostr); }
Programming in C++
Page 316
Inheritance
Gotcha: Slicing
class base { public: virtual void func() const { cout << "base::func" << endl; } }; class drvd : public base { public: virtual void func() const { cout << "drvd::func" << endl; } }; void gen_func(base b) { b.func(); } derived d; gen_func(d); // prints: base::func !!!
Problem: argument b of gen_func is passed by value copy constructor is invoked b is not a reference or pointer static binding copy constructor of base is invoked copies only base part (slicing) Another reason to pass class objects by reference: void gen_func(const base& b) { b.func(); }
Inheritance
Recall rules: Assign to all members Check for assignment to self Return a reference to *this
Gotcha: Assignment Operator
New rule: derived class's assignment operator must also handle base class members! class base { private: int x; public: base(int i) : x(i) {} }; class derived : public base{ private: int *y; public: derived(int i) : base(i), y(0) {} derived& operator=(const derived& rhs); };
derived& operator=(const derived& rhs) { if (this == &rhs) return *this; base::operator=(rhs); // don't forget this if (y) { *y = *(rhs.y); } else { y = new int(*(rhs.y)); } return *this; }
Inheritance
More Gotchas
Rules for overloading base class functions in derived classes: class base { class Derived: public Base { public: public: virtual void f(int) {} void f(Complex) {} virtual void f(double) {} virtual void g(int i = 10) {} void g(int i = 20) {} }; }; Base b; Derived d; Base *pb = new Derived;
A derived function with the same name but without a matching signature hides all base class functions of the same name d.f(1.0); // Derived::f(Complex) !!! use "using" declarations to bring them into scope Never change the default argument values of overridden inherited functions b.g(); d.g(); pb->g(); // Base::g(int = 10) // Derived::g(int = 20) // Derived::g(int = 10) !!!
default taken from base class function because compiler does it at compile time
Inheritance
Derived Class Templates

UML: Array T safeArray T
We had an Array<T> template; how about safeArray<T>? #include <assert.h> #include "array.h" template<class T> class safeArray : public Array<T> {
public: safeArray(int size = def_array_size) : Array<T>(size) {} safeArray(const Array<T>& rhs) : Array<T>(rhs) {} safeArray(const T* ay, int size) : Array<T>(ay, size) {} T& operator[](int index) { assert(index >= 0 && index < Array<T>::size()); return Array<T>::operator[](index); } }; Instantiation: safeArray<float> ssa(14); causes base and derived class generation Note: remove_hot() should also be re-written into a function template template<class T> void remove_hot(Array<T>& day_temp);
Inheritance
User-defined input and output operators work for all IOStreams because IOStream classes actually form inheritance hierarchy! ios
Example: IOStreams
istream
ostream
ifstream
istrstream
iostream
ofstream
ostrstream
fstream
strstream
Programming in C++
Page 321
Inheritance
Example: Arrays with Arbitrary Bounds
Allow arrays with arbitrary bounds (not just 0 to n-1): template<class T> // boundarray.h class boundArray : public safeArray<T> { public: boundArray(int lowIdx, int highIdx) : safeArray<T>(highIdx-lowIdx+1), low(lowIdx) {} boundArray(const boundArray<T>& rhs) : safeArray<T>(rhs), low(rhs.low) {} boundArray(int lowIdx, int highIdx, const T* ay) : safeArray<T>(ay, highIdx-lowIdx+1), low(lowIdx) {} boundArray<T>& operator=(const boundArray<T>& rhs); T& operator[](int index); const T& operator[](int index) const; int lowerBound() const { return low; } int upperBound() const { return low+safeArray<T>::size()-1; } private: int low; };
Inheritance
Example: Arrays with Arbitrary Bounds

// boundarray.cpp
template<class T> boundArray<T>& boundArray<T>::operator=(const boundArray<T>& rhs) { if (this == &rhs) return *this; safeArray<T>::operator=(rhs); low = rhs.low; return *this; } template<class T> T& boundArray<T>::operator[](int index) { return safeArray<T>::operator[](index - low); } template<class T> const T& boundArray<T>::operator[](int index) const { return safeArray<T>::operator[](index - low); }
Programming in C++
Page 323
Inheritance
template<class T> class Ring { public:

// incomplete
Better solution for automatically defining mathematical operators:
// inline friend: defines global function within class friend const T operator*(const T& lhs, const T& rhs) { return T(lhs) *= rhs; } friend const T operator+(const T& lhs, const T& rhs) { return T(lhs) += rhs; } T& operator++() { return ((T&)*this) += T(1); } const T operator++(int) { T old((T&)*this); ++(*this); return old; } }; Now, number classes only define base operators +=, *= and T(1), then derive from Ring<T>: class Complex : public Ring<Complex> { ... };
Inheritance
Why stop with Ring<T>? define classes for other algebraic structures as well T SemiGroup T Monoid T Group T Ring T RingWithUnit T Field
T AbelianSemiGroup T AbelianMonoid T AbelianGroup
Programming in C++
Page 325
Inheritance
Design Guidelines
Not every is-a relationship in our natural environment is a candidate for inheritance Do not use inheritance if not all methods of the base class make sense for the derived class if methods would have a different semantic in the derived class if the meaning of components would change in the derived class if values or properties of components would be restricted in the derived class Example: A Square is a Rectangle but the method change_width() or change_height() would not make sense for square! For every possible derived object, it must make sense to assign it to a object of the corresponding base class. In doing so, new (additional) components of the derived class are ignored. Do not mistake is-like-a for is-a! Use inheritance carefully!
Programming in C++
Page 326
Multiple Inheritance
Multiple inheritance := inherit from more than one base class
Introduction
class derived : public base1, public base2 { /* ... */ }; Experts are disagreeing whether multiple inheritance is useful or not It is essential to the natural modeling of real-world problems It is slow, difficult to implement, and no more powerful than single inheritance Object-orient Languages: C++, Eiffel, Common LISP Object System (CLOS) offer multiple inheritance Smalltalk, Objective C, Object Pascal do not Java does not, but allows the implementation of multiple interfaces Fact: multiple inheritance in C++ opens up a Pandoras box of complexities Use multiple inheritance judiciously
Ambiguity of Base Class Members
If a derived class inherits a member name from more than one class, any usage of that name is inherently ambiguous you must explicitly say which member you mean class Lottery { public: virtual int draw(); }; class GraphicObj { public: virtual int draw(); };
class LotterySimulation: public Lottery, public GraphicObj {...}; LotterySimulation *pls = new LotterySimulation; pls->draw(); // error! ambiguous pls->Lottery::draw(); // OK pls->GraphicObj::draw(); // OK By explicitly qualifying a virtual function, it doesnt act virtual anymore It is impossible that LotterySimulation can redefine both of the draw() functions
Programming in C++
Page 328
Ambiguity2: the Diamond
Sooner or later, you come across the following inheritance relationship: class class class class A B C D { : : : /* ... public public public */ }; A { /* ... */ }; A { /* ... */ }; B, public C { /* ... */ }; UML: A
D includes two copies of A unnecessary duplication no syntactic means of distinguishing them Solution: virtual base classes class class class class A B C D { : : : /* ... */ }; virtual public A { /* ... */ }; virtual public A { /* ... */ }; public B, public C { /* ... */ }; D
only first copy of A is used Problem: specification has to be done of class designer (user/client may not have access)
Ambiguity2: the Diamond
Another problem: an object of class D may have up to five different addresses: class class class class D d; D* B* C* A* A* pd1 pd2 pd3 pd4 pd5 = = = = = &d; // pd1 is address of D part of D &d; // pd2 is address of B part of D &d; // pd3 is address of C part of D (B*) &d; // pd4 is address of A part of B part of D (C*) &d; // pd5 is address of A part of C part of D A B C D { : : : /* ... public public public */ }; A { /* ... */ }; A { /* ... */ }; B, public C { /* ... */ };
our simple self-test for operator=() fails (by checking the address of the object): if (&rhs == this) return; almost impossible to come up with efficient solution (best solution: implement unique object identificator)
Passing constructor arguments to virtual base classes
More Problems
normally, classes at level n of the hierarchy pass arguments to the classes at level n-1 For virtual base classes, arguments are specified in the classes most derived from the base Dominance of virtual functions class class class class A B C D { : : : virtual void mf(); /* ... */ }; public A { virtual void mf(); /* ... */ }; public A { /* ... */ }; public B, public C { /* ... */ }; // A::mf() or B::mf()?
D *pd = new D; pd->mf(); Casting restrictions
normally ambiguous, but B::mf() dominates if A is virtual base class for both B and C C++ prohibits to cast down from a pointer/reference to a virtual base class to a derived class There are cases where multiple inheritance might be useful Rule: try to avoid virtual base classes (diamond-shaped class hierarchy)
Programming in C++
Page 332
Programming in C++
More on Arrays
Programming in C++
Page 333
More on Arrays
What have we got so far with our array redesign? size of array need not be constant and known at compile-time array assignment and re-assignment optional range checking through derived safearray generic usage through templates What else could be done? adding mathematical operators to get a class vector
Motivation
vector can easily implemented by inheriting from array or safearry what about multi-dimensional arrays like matrix, array3d, ...? implementation? performance of vector or matrix operations compared to hand-coded loop expressions? for (int i=0; i<size; i++) a[i] = b[i] * c + d[i]; Functions for selecting parts of an array or vector (e.g., projections) Sparse arrays, BLAS, LAPACK, ...
More on Arrays
#include "array.h" #include <assert.h>
Simple vector Implementation
Derive vector from array and add mathematical operations
template<class T> class vector : public array<T> { public: vector(int size = def_array_size) : array<T>(size) {} vector(const array<T>& rhs) : array<T>(rhs) {} vector(const T* ay, int size) : array<T>(ay, size) {} vector<T>& operator+=(const vector<T>& rhs) { // elem. add assert (sz == rhs.sz); // same size? for (int i=0; i<sz; ++i) ia[i] += rhs.ia[i]; return *this; } vector<T>& operator+=(T rhs) { // elementwise scalar add for (int i=0; i<sz; ++i) ia[i] += rhs; return *this; } // ... };
More on Arrays
Simple vector Implementation
Define elementwise addition out of operator+= as usual: template<class T> vector<T> vector<T>::operator+(const vector<T>& rhs) { return vector<T>(*this) += rhs; } template<class T> vector<T> vector<T>::operator+(T rhs) { return vector<T>(*this) += rhs; } Global definition of operator+ to get conversion on both arguments not helpful here, as conversion not defined (for T=int even disastrous as vector of zeroes of size n is added!) To complete simple vector implementation also implement elementwise substraction, multiplication, division, ... elementwise trigonometrical (sin, cos, ...) and other mathematical functions (abs, ...) dot product, norm, minimum and maximum value or index ...
More on Arrays
Implementations of matrix(2,3); =
(0,0) (0,1) (0,2) (1,0) (1,1) (1,2)
matrix Data Layouts
0,0 0,1 0,2 1,0 1,1 1,2 row-major order (C), contiguous 0,0 0,1 0,2 1,0 1,1 1,2 non-contiguous, row vectors
0,0 1,0 0,1 1,1 0,2 1,2 column-major order (Fortran), contiguous 0,0 1,0 0,1 1,1 0,2 1,2 non-contiguous, column vectors
0,0 0,1 0,2 1,0 1,1 1,2 contiguous, row vectors
0,0 1,0 0,1 1,1 0,2 1,2 contiguous, column vectors
even more layouts (sparse, symmetric, packed, ... representations)

More on Arrays
Subarray Selection
overloaded versions of operator[] not possible, e.g., operator[](int,int) but we can use overloaded versions of operator() to specify subarray selections operator()(int) is just a replicated version of operator[] const T& operator()(int index) const { return ia[index]; } operator()(int,int) can be used to select a subarray [start, end] array<T> operator()(int start, int end) const { return array<T>(ia+start, end-start+1); } operator()(int,int,int) then for strided subarrays [start, end, stride] array<T> operator()(int start, int end, int stride) const { array<T> r((end-start+stride)/stride); for (int i=start, j=0; i<=end; i+=stride) r.ia[j++] = ia[i]; return r; } Not recommended: could use operator[] for indexing with range check, operator() without or vice versa (can you remember which is which?)
Programming in C++
More on Arrays
Subarray Selection with Range Objects
Overloaded operator() for subarray selection is only sub-optimal solution e.g., how do you implement it for class matrix? Better solution: use overloaded operator() for indexing in different dimensions use Range objects (Region for matrix, ...) for subarray selection class Range { public: Range (int base); Range (int base, int end, int stride = 1); ... }; template <class T> array<T> array<T>::operator()(const Range&) { /*...*/ } array<double> a(100), b(100); a = b(Range(4, 9));
Programming in C++
Page 339
More on Arrays
Multi-dimensional Array Design
Mathematical relationships between vector, matrix, ... calls for systematic design but multi-dimensional array design can be done in a variety of ways different uses of arrays require different trade-offs among time, space efficiency, compatibility with existing code (e.g. Fortran libraries), and flexibility no single array class can cope with the wide range of requirements in practice As an example, we have a look on the design used in [Barton and Nackman] They distinguish two levels of flexibility: Rigid arrays: dimensionality and shape fixed at compile time Formed arrays: dimensionality fixed, but shape determined/changeable at runtime And they distinguish two kinds based on the way clients can use them: Interfaced arrays: shares common interface base classes with other array classes; all classes with the same interface can be used interchangeably in client functions more efficient in code space and programmer time Concrete arrays: no common interface base class; no virtual function call overhead more efficient in function-call time (runtime)
More on Arrays
Non-type Template Arguments
How can we implement rigid arrays using templates? Non-type template arguments template<int N, class T> class array { private: T data[N]; // ... }; Array<100,int> a; // like int a[100];
Programming in C++
Page 341
More on Arrays
Example concrete array classes indented for use by client functions Class name ConcreteFormedArray1d<T> ConcreteRigidArray1d<T,n0> ConcreteFortranArray1d<T> ConcreteFormedArray2d<T> ConcreteRigidArray2d<T,n0,n1> ConcreteFortranArray2d<T> ConcreteFormedArray3d<T> ConcreteRigidArray3d<T,n0,n1,n2> ConcreteFortranArray3d<T> Storage layout Row major, contiguous Row major, contiguous Column major, contiguous Row major, contiguous Row major, contiguous Column major, contiguous Row major, contiguous Row major, contiguous Column major, contiguous
ConcreteFortranSymPackedArray2d<T> Upper triangular, packed
Programming in C++
Page 342
More on Arrays
Interfaced array class hierarchy overview

T
ArrayShape T Array2d FormedArray2d FortranArray2d RigidArray2d T Array1d FormedArray1d FortranArray1d RigidArray1d

Programming in C++
Array3d FormedArray3d FortranArray3d T RigidArray3d T T T
T,n0,n1,n2
T,n0,n1
T T Class
T,n0
= Interface Base Class

Page 343
More on Arrays
Class hierarchy details for FormedArray2d<T> showing 2-dimensional interfaces, projections and accessors ArrayShape ConstArray2d T InterfacedConstArrayProjection2d Array2d T InterfacedArrayProjection2d> InterfacedArray2d AccessedArray2d ConcreteFormedArray2d AccessedConstArray2d T T
T FormedArray2d
More on Arrays
vector class definition
Simple Rigid vector Implementation
template <class T, int N> class vector { private: T *begin, *end; public: vector(); vector(const vector<T,N>& rhs); ~vector(); T& operator[](int n); vector<T,N>& operator=(const vector<T,N>& rhs); vector<T,N> operator+(const vector<T,N>& rhs); ... }; Constructor: allocate data space and set end pointer template <class T, int N> vector<T,N>::vector() : begin(new T[N]), end(begin+N) {} Destructor: free data space template <class T, int N> vector<T,N>::~vector() { delete [] begin; }
More on Arrays
Copy Constructor: allocate data space and copy data over template <class T, int N> vector<T,N>::vector(const vector<T,N>& rhs) : begin(new T[N]), end(begin+N) { T* dest = begin; T* src = rhs.begin; while (src != rhs.end) *dest++ = *src++; } Assignment Operator: after self-test, copy data over can reuse data space as we know that the vectors have same length template <class T, int N> vector<T,N>& vector<T,N>::operator=(const vector<T,N>& rhs) { if (&rhs == this) return *this; T* dest = begin; T* src = rhs.begin; while (src != rhs.end) *dest++ = *src++; return *this; }
More on Arrays
Addition Operators: elementwise addition, define operator+() out of operator+=() template <class T, int N> vector<T,N>& vector<T,N>::operator+=(const vector<T,N>& rhs) { T* dest = begin; T* src = rhs.begin; while (dest!=end) *(dest++) += *(src++); return *this; } template <class T, int N> vector<T,N> vector<T,N>::operator+(const vector<T,N>& rhs) { return vector<T,N>(*this) += rhs; } Index Operator: nothing new here template <class T, int N> T& vector<T,N>::operator[](int n) { return begin[n]; } Rest of class methods left as exercise for the reader!
More on Arrays
Standard Optimization: Unroll / Inline
Problem: Overhead for short vector lengths Template member function specialization using manual loop unrolling and inlining inline vector<double,3>& vector<double,3>::operator=(const vector<double,3>& if (&rhs == this) return *this; double *dest = begin; // or: double *src = rhs.begin; // begin[0] = *dest++ = *src++; // begin[1] = *dest++ = *src++; // begin[2] = *dest = *src; return *this; } side note: partial specialization would be better (double T) but not yet supported by mainstream compilers rhs) {
rhs.begin[0]; rhs.begin[1]; rhs.begin[2];
template<class T> inline vector<T,3>& vector<T,3>::operator=(const vector<T,3>& rhs) { /*...*/ }

More on Arrays
Example: elementwise vector addition vector<T,N> u, v, w; // later... u = v + w;
More Performance Problems
// typical C (or Fortran-like version) for (int i=0; i<N; ++i) u[i]=v[i]+w[i];
Generated code (GHOST vector not generated if compiler features "Return Value Optimization") v.operator+(w) vector<T,N> NoName(v); NoName.begin = new T[N]; loop NoName[i] v[i]; NoName.operator+=(w); loop NoName[i] += w[i]; return NoName; vector<T,N> GHOST(NoName); GHOST.begin = new T[N]; loop GHOST[i] NoName[i]; NoName.~vector(); u.operator=(GHOST); loop u[i] GHOST[i]; GHOST.~vector();
More on Arrays
Standard Optimization: Memory Allocation
Problem: Too many temporary objects; e.g. u = v + w; 2 new / delete calls! implement own memory allocation: delete puts object in freelist; new uses freelist objects first Implementation using Allocate class modelled after STL: template <class T, int N> class vector { private: T *begin, *end; static Allocator<T,N> allocator_data; public: vector() : begin(allocator_data.allocate()), end(begin+N) {} ~vector() { allocator_data.deallocate(begin); } ... }; // Definition template <class T, int N> Allocator<T,N> vector<T,N>::allocator_data; // with preallocation: ... ::allocator_data(100);
More on Arrays
Class definition
Class Allocator
template <class T, int N> class Allocator { private: union { // data used either for T content[N]; // - vector storage Allocator<T,N>* next; // - pointer in freelist }; public: Allocator(); // default constructor Allocator(int n); // ctor with preallocation T *allocate(void); // "new" void deallocate(T* s); // "delete" ~Allocator(); }; Default Constructor: setup empty freelist template <class T, int N> inline Allocator<T,N>::Allocator() { next=0; }
Programming in C++
Page 351
More on Arrays
Class Allocator
Constructor with Preallocation: allocate block of memory and setup freelist template <class T, int N> inline Allocator<T,N>::Allocator(int n) { Allocator<T,N>* block = new Allocator<T,N>[n]; for (int i=0; i<n-1; ++i) block[i].next = &(block[i+1]); block[n-1].next = 0; next = block; } Example: Allocator<double,3> vector<double,3>::allocator_data(4); block allocator_data.next Destructor template <class T, int N> inline Allocator<T,N>::~Allocator() { if (next) delete next; // recursive ! }
More on Arrays
Allocate Function ("new") template <class T, int N> inline T* Allocator<T,N>::allocate(void) { if (next) { T* vec = next->content; next = next->next; return vec; } else { Allocator<T,N>* tmp = new Allocator<T,N>; return tmp->content; } } allocator_data.next
Class Allocator
vec
) (T * or
Programming in C++
Page 353
More on Arrays
Deallocate Function ("delete")
Class Allocator
template <class T, int N> inline void Allocator<T,N>::deallocate(T* vec) { Allocator<T,N> *tmp = (Allocator<T,N>*) vec; tmp->next = next; next = tmp; }
vec
(T *)
tmp
allocator_data.next
Programming in C++
Page 354
More on Arrays
Problem: copy loops
Standard Optimization: Reference Counting
avoid unnecessary copying using "copy-on-write" idiom (implemented by Reference Counting) Implementation this time without using handle/body class idiom each reference-counted object now has pointer to (shared) reference counter reference counter also managed by optimized memory managment vector<double,4> v1, v2; v1[0] = 3.6; v1[1] = 1.2; ... v2 = v1;
begin end repN v1 2 begin end repN v2 3.6 1.2 4.5 4.6
Programming in C++
Page 355
More on Arrays
Class vector definition
template <class T, int N> class vector { private: T *begin, *end; unsigned int *repN; // reference counter pointer (new) static Allocator<T,N> allocator_data; static Allocator<unsigned int, 1> allocator_repN; // (new) public: vector(); vector(const vector<T,N>& rhs); ~vector(); T& operator[](int n); // ... };
Programming in C++
Page 356
More on Arrays
Constructor now also allocates reference counter and sets it to 1 template <class T, int N> vector<T, N>::vector(void) : begin(allocator_data.allocate()), end(begin+N), repN(allocator_repN.allocate()) { *repN = 1; } Copy constructor: shallow copy plus increment of the counter template <class T, int N> vector<T,N>::vector(const vector<T,N>& rhs) : begin(rhs.begin), end(rhs.end), repN(rhs.repN) { (*repN)++; } Destructor only destructs if reference counter goes down to zero template <class T, int N> vector<T, N>::~vector() { if (!(--(*repN))) { allocator_repN.deallocate(repN); allocator_data.deallocate(begin); } }
More on Arrays
Assignment operator: shallow copy plus increment of the counter template <class T, int N> vector<T, N>& vector<T, N>::operator=(const vector<T, N>& rhs) { // self-test if (this == &rhs) return *this; // destroy lhs if no longer referenced if (!(--(*repN))) { allocator_repN.deallocate(repN); allocator_data.deallocate(begin); } // increment counter (*rhs.repN)++; // shallow copy of members repN = rhs.repN; begin = rhs.begin; end = rhs.end; return *this; }
Programming in C++
Page 358
More on Arrays
Index operator: if vector is referenced more than once, make copy template <class T, int N> T& vector<T, N>::operator[](int n) { if ((*repN) == 1) return begin[n]; else { (*repN)--; // count down old repN = allocator_repN.allocate(); // create new ref counter *repN = 1; // create new data space and copy over T* temp = allocator_data.allocate(); memcpy((void*) temp, (void*) begin, size_t(N*sizeof(T)) ); begin = temp; end = begin+N; return begin[n]; } } reference counter especially effective for large arrays
More on Arrays
Optimization: Temporary Base Class Idiom
Temporary Base Class Idiom = "Reference Counting without counting" Idea: shallow/deep copy flag encoded in types temporary vectors are represented by class Tvector template <class T, int N> class Tvector { private: T *begin, *end; static Allocator<T,N> allocator_data; public: "Standard" Constructor Tvector() : begin(allocator_data.allocate()), end(begin+N) {} Copy constructor does "shallow" copy only Tvector(const Tvector<T,N>& rhs) : begin(rhs.begin), end(rhs.end) {} Extra constructor for vector copy constructor Tvector(T* b) : begin(b), end(b+N) {}
More on Arrays
Destructor empty as destruction is all handled by class vector (virtual because vector will be derived from Tvector) virtual ~Tvector() {} "Standard" mathematical operators Tvector<T, N> operator+(const Tvector<T, N>& rhs); // ... Optimization (see below) Tvector<T, N> operator+(const vector<T, N>& rhs); We also need to declare class vector a friend: friend class vector<T, N>; If your compiler doesnt yet support friends of templates, we need to use the following "hack" //protected: }; T* start() const { return begin; }
Programming in C++
Page 361
More on Arrays
vector class now subclass of Tvector template <class T, int N> class vector : public Tvector<T,N> { public: Default constructor empty as construction is done by Tvector() vector() {} Deallocate here, as Tvector doesnt delete anything! ~vector() { allocator_data.deallocate(begin); } Copy constructor (see below) vector(const vector<T,N>& rhs); Assignment and Indexing handled here T& operator[](int n) { return begin[n]; } vector<T,N>& operator=(const vector<T,N>& rhs); vector<T,N>& operator=(const Tvector<T,N>& rhs); Tvector<T,N> operator+(const vector<T,N>& rhs); };
More on Arrays
Copy constructor uses special Tvector constructor and does deep copy template <class T, int N> vector<T,N>::vector(const vector<T,N>& rhs) : Tvector<T,N>(allocator_data.allocate()) { T* dest = begin; T* src = rhs.begin; while (dest != end) *(dest++) = *(src++); } temporary variables as well as return type of mathematical operators are now of type Tvector template <class T, int N> inline Tvector<T,N> vector<T,N>::operator+ (const vector<T,N>& rhs) { Tvector<T,N> t; T* sum1 = begin; T* sum2 = rhs.begin; T* dest = t.begin; // can use t.start() if // friend templates dont work while (sum1 != end) *(dest++) = *(sum1++) + *(sum2++); return t; }
More on Arrays
special assignment operator turn a Tvector into a vector and handles "delete" template <class T, int N> inline vector<T,N>& vector<T,N>::operator= (const Tvector<T,N>& rhs) { allocator_data.deallocate(begin); begin = rhs.begin; // or if necessary: begin = rhs.start(); end = rhs.end; // end = begin+N; } special optimization for mathematical Tvector operations if this is already temporary vector (e.g. (v1+v2) if u = v1 + v2 + v3) template <class T, int N> inline Tvector<T,N> Tvector<T,N>::operator+ (const vector<T,N>& rhs) { T* sum1 = begin; T* sum2 = rhs.begin; while (sum1 != end) *(sum1++) += *(sum2++); return *this; }
More on Arrays
Chained Expression Objects
Even More Advanced Optimization
Overloaded operators dont perform the operation but build an expression stack at runtime Assignment operator matches expression stack with library of tuned expression kernels x = v + w; will execute as remember expr. "vector + vector" execute "add(x,v,w)"
Expression templates Avoid temporary objects in the first place by automatically transform u = v + w; // vector u, v, w;
at compile time (more-or-less) into for (int i=0; i<u.length(); ++i) { u[i] = v[i] + w[i]; } using Template Meta-Programming (or "Compile-Time Programs") See Blitz++ (http://oonumerics.org/blitz/) and PETE (http://www.acl.lanl.gov/pete/)
Programming in C++
Page 366
Programming in C++
The C++ Standard Library and Generic Programming
Programming in C++
Page 367
The C++ Standard Library

Namespaces provide a way to partition the global scope
Namespaces
a namespace is NOT a module; but it supports techniques related to modularity namespace Chrono { class Date { /* ... */ }; enum Month { Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec }; bool leapyear(int y); Date next_weekday(Date d); } A namespace may only be defined at file scope or nested directly in another namespace
Programming in C++
Page 368
Namespaces
Names declared inside a namespace can be accessed from outside the namespace by using the fully qualified name Chrono::Date d(15, Chrono::May, 1998); allows mixnmatch between components from different libraries AnotherPackage::Date d2(1998, 5, 15); A namespace can be "unlocked" for the purpose of name lookup with a using-directive using namespace Chrono; Date d(15, May, 1998); "if name lookup reaches file scope before the name has been found search all unlocked namespaces as well as file scope (which is considered a "special-name" namespace)" An individual name can be imported into the current scope with a using-declaration using Chrono::Date; Date d(15, Chrono::May, 1998);

The new C++ standard has now an extensive standard library
Overview
Support for the standard C library (but slightly changed to fit C++s stricter type checking) Support for strings (string) Support for localization and internationalization Support for I/O standardized I/O streams Support for numeric applications complex numbers: complex special array classes: valarray Support for general-purpose containers and algorithms Standard Template Library (STL)
Programming in C++
Page 370
Everything is a Template ...
The name Standard Template Library is not particularly descriptive because almost everything in the C++ Standard Library is a template Standard string class is actually template < class charT, class traits = string_char_traits<charT>, class Allocator = allocator> class basic_string; typedef basic_string<char> string; Class complex is actually template<class T> class complex; class complex<float>; class complex<double>; class complex<long double>; Same is true for valarray, ios, istream, ostream, ... Note: no longer possible to use a forward declaration of these types: class ostream;
Programming in C++
// does no longer work!

Standard C++ Library

Standrad C++ library headers use a "new" style (note the missing .h!): <iostream> <fstream> <string> <complex> <vector> <list> ...
Portability Notes
Do not mix pre-standard old headers and new style headers! (e.g., <iostream.h> and <vector>) New C++ headers for C library facilities (not available yet for many compilers) <cassert> <cctype> <cerrno> <cfloat> <ciso646> <climits> <clocale> <cmath> <csetjmp> <csignal> <cstdarg> <cstddef> <cstdio> <cstdlib> <cstring> <ctime> <cwchar> <cwctype>
All C++ standard library objects (including the C library interface) are now in namespace std !!! Compiler vendors often supply migration headers: e.g. <vector.h>: #include <vector> using std::vector;
Generic Programming
Basics
Generic Programming is NOT about object-oriented programming Although first research papers appeared 1975, first experimental generic software was not implemented before 1989 not many textbooks on generic programming exist First larger example of generic software to become important outside research groups was STL (Standard Template Library) designed by Alexander Stepanov and Meng Lee of HP added to C++ standard in 1994 available as public domain software first from HP and now from SGI
Programming in C++
Page 373
Generic Programming
New programming techniques were always based on new abstractions often used sequences of instructions data + interface hierarchies of polymorphic ADTs For generic programming: set of requirements on data types Generic algorithm has generic instructions describing the steps of the algorithm set of requirements specifying the properties the algorithm arguments must satisfiy only first part can be expressed in C++ templates concept subroutines abstract data types inheritance
Basics
Programming in C++
Page 374
STL
STL is based on four fundamental concepts containers hold collections of objects bitset, vector, list, deque, queue, stack, set, map, ... iterators are pointer-like objects to walk through STL containers algorithms are functions that work on STL containers find, copy, count, fill, remove, search, ... functors are function objects used by the algorithms To understand these concepts, consider a function to find a value in an int array:
Basics
int find(int array[], int len, int value) { int idx; for (idx=0; idx<len; ++idx) if (array[idx]==value) return idx; return -1; } can be improved by using pointers to specify begin of search, end of search, and result also allows for search in subarrays
STL
Basics
To understand the basic principle of STL, look at the rules of C++ (and C) arrays and pointers: a pointer to an array can legitimately point to any element of the array or it can point to one element beyond the end of the array (but then it can only be compared to other pointers to the array and it cannot be dereferenced) and rewrite find to search in the range [begin, end): int* find(int* begin, int* end, int value) { while (begin != end && *begin != value) ++begin; return begin; // begin==end if not found } You could use find function like this: int values[50]; int *firstFive = find(values, values+50, 5); if (firstFive!=values+50) { //5 found...} else { //not found...} You can also use find to search subranges of the array: int *five = find(values+10, values+20, 5);
STL
Basics
Nothing inherent in the find function that limits it to array of int, so should be template: template<class T> T* find(T* begin, T* end, const T& value) { while (begin != end && *begin != value) ++begin; return begin; } Nice, but still to limiting: look at the operations on begin and end inequality operator, dereferencing, prefix increment, copying (for result!) Why restrict begin and end to pointers? allow any object which supports the operations above: iterators template<class Iterator, class T> Iterator find(Iterator begin, Iterator end, const T& value) { while (begin != end && *begin != value) ++begin; return begin; } This version is the actual implementation of find in the STL!
Programming in C++
Page 377
STL
We can apply find to every STL container, e.g. list list<char> cList; // fill cList with values... c0 c1 c2 it
Basics
...
cn end()
begin()
++
list<char>::iterator it = find(cList.begin(), cList.end(), x); if (it != cList.end()) { // found x ... } begin() and end() are STL container member functions which return iterators pointing to the beginning and end of the container Furthermore, C++ pointers are STL iterators, so e.g., int values[50]; // fill values with actual values ... int *firstFive = find(values, values+50, 5); // calls STL find if (firstFive != values+50) { // found 5 ... }
Programming in C++
Page 378
Generic Programming
A set of requirements (e.g., like for iterator) is called a concept A concept can be defined in two (equivalent) ways list of type requirements a set of types A type T is a model of a concept C if T satisfies all of Cs type requirements T belongs to the defining set of types
Concepts and Models
Concept requirements cannot fully be described as needed set of member functions ( classes) e.g., char* is model of concept iterator but has no member functions but can be seen as list of valid expressions
Programming in C++
Page 379
STL
Iterator concepts: categorize iterators based on their functionality Input Forward Output Functionality needed: ++i *i i=j i==j i!=j --i Bidirectional
Iterator Concepts
Random-Access
i[] i+n i-n i-j i<j
Input iterator I: Output iterator O: Forward iterator F:
*I may only be read once *O may only be written once *F may be read or written multiple times
Relation C1 C2 is called a refinement if concept C2 satisfies all of C1 requirements and possibly additional requirements all models of C2 are also models of C1 Modeling is relationship between a type and a concept Refinement is relationship between two concepts (inheritance is relationship between two types)
STL
Basic idea behind STL is simple
Basics
STL is just a collection of class and function templates that adhere to a set of conventions STL is extensible: you can add your own collections, algorithms, or iterators as long you follow the STL conventions STL is efcient: there is no big inheritance hierarchy, no virtual functions, ... STL: C containers + A algorithms Traditional Library: T types C A STL is portable Disadvantages no error checking (use "safe-STL"!) unusual programming interface Using traditional libraries is better than using no library! e.g., RogueWaves tools.h++ (Cray: CCtoollib), math.h++, lapack.h++ (CCmathlib)
Programming in C++
Page 381
STL
Containers store collections of objects (or pointers to objects)
Containers
All STL containers have a standardized interface. Apart from minor differences they provide the same constructors, member functions, and public types STL containers are grouped into four categories sequence containers linear unsorted collections (vector, deque, list) insert position depends on time / place not value sorted associative containers rapid insertion and deletion based on keys (set, map, multiset, multimap) insert position depends on value almost containers (string, built-in arrays, bitset, valarray) container adapters (stack, queue, priority_queue) There are no hashed containers in the C++ Standard STL public domain SGI STL provides them as an extension
STL Containers
Every STL container declares at least these public types as nested typedefs: Typename value_type size_type difference_type iterator const_iterator reverse_iterator reference const_reference key_type mapped_type key_compare
Programming in C++
Public Types
Description Type of element stored in container (typically T) Signed type for subscripts, element counts, ... Unsigned type of distances between iterators Type of iterator (behaves like value_type*) Type of iterator for constant collections (behaves like const value_type*) For traversing container in reverse order Type of reference to element (behaves like value_type&) Behaves like const value_type& Type of key Type of mapped value Type of comparison criterion
const_reverse_iterator Same for constant collections
Associative containers provide also:
STL Containers
#include <iostream> #include <vector> using namespace std; int main() { vector<float> x(5);
Example: Public Types
// Get iterators positioned at first and behind "last" element vector<float>::iterator first=x.begin(), last=x.end(); // Get reference to first element and change it vector<float>::reference z = x[0]; z = 8.0; cout << "x[0] = " << x[0] << endl; // Find the size of the collections vector<float>::size_type size=last - first; cout << "Size is " << size << endl; } Output: x[0] = 8 Size is 5
STL Containers
Default constructor to create empty container Container();
Constructors and Destructor
Every container Container provides the following constructors:
Copy constructor: initialize elements from container of same type Container(const Container&); Initialize container from container of other type through iterators element types must be assignment compatible template<class Iterator> Container(Iterator first, Iterator last); Destructor: destroy container and all of its elements ~Container(); Examples vector<int> a; vector<int> b(a); list<double> c(a.begin(), a.end());
Programming in C++
// calls default ctor // calls copy ctor // calls ctor(iter,iter)

Page 385
STL Containers
Every STL container provides the following member functions to obtain iterators: Method begin() end() rend() Points to first element one-past-last element Associated type
Iterators
Container::iterator Container::reverse_iterator
rbegin() first element of reverse sequence one-past-last element of reverse sequence
For const containers, iterator type is const_iterator or const_reverse_iterator vector, deque, string, valarray, and built-in arrays have random-access iterators list, map, multimap, set, and multiset have bidirectional iterators Example: output all values of a vector not: it<x.end()
would require random access! int data[5] = { 23, 42, 666, -89, 5 }; vector<int> x(data, data+5); for(vector<int>::iterator it=x.begin(); it!=x.end(); ++it) cout << *it << endl; note: ++it more efficfient than it++
STL Containers
#include <iostream> #include <vector> #include <list> using namespace std; int main() { vector<const mathies[0] = mathies[1] = mathies[2] =
Example: Creating Containers from Iterators
char *> mathies(3); "Alan Turing"; "Paul Erdos"; "Emmy Noether";
list<const char *> mathies2(mathies.begin(), mathies.end()); for(list<const char *>::iterator it=mathies2.begin(); it!=mathies2.end(); ++it) cout << *it << endl; } Output: Alan Turing Paul Erdos Emmy Noether
STL Containers
STL containers can be compared using the usual comparison operators Equality operator operator==() returns true if the containers are the same size and the corresponding elements of each container are equal Container elements are compared using T::operator==() Inequality is defined accordingly to determine if two containers are different The other comparison operators operator<() operator<=() operator>() operator>=()
Comparison
return true if first container is lexicographically less/less or equal/greater/greater or equal than second container Containers are compared element by element; first element which differs determines which container is less or greater
STL Containers
Container a, b; // fill a and b ...
Other Member Functions
Assign the contents of one container to the other a = b; Exchange the contents of the two containers a.swap(b); Get the current number of elements stored in container Container::size_type n = a.size(); Get the size of the largest possible container Container::size_type maxn = a.max_size(); Check whether container is empty (has no elements) bool isEmpty = a.empty();
STL Sequence Containers

Sequence containers provide
Overview
linear ( elements have a predecessor and successor), unsorted collections of elements insert position depends on time / place not value STL provides three sequence containers: vector<T> dynamic array fast random access, fast insert and delete at the end deque<T> double-ended queue fast random access, fast insert and delete at both the beginning and end list<T> doubly-linked list slow random access, fast insert and delete anywhere

In addition to the general constructors for all STL containers Container(); Container(const Container&);
Additional Constructors
template<class Iterator> Container(Iterator first, Iterator last); sequence containers SeqContainer also provide Create container with n default values SeqContainer(size_type n); Create container with n copies of an element x SeqContainer(size_type n, T x); Examples vector<int> x(5); list<double> y(3, 3.14); // => { 0, 0, 0, 0, 0 } // => { 3.14, 3.14, 3.14 }
Programming in C++
Page 391

SeqContainer a; SeqContainer::iterator it, r; SeqContainer::iterator f, l; SeqContainer::value_type val; // // // //
Inserting and Deleting Elements

Fill a ... Point somewhere into a Two more iterators Some value to insert
Insert element val right before the iterator it r = a.insert(it, val); // r points to inserted val Insert n copies of element val right before the iterator it Container::size_type n; a.insert(it, n, val); // void
Inserts elements described by iterator range [f, l) right before the iterator it a.insert(it, f, l); Remove element pointed to by iterator it r = a.erase(it); r = a.erase(f, l); Remove all elements a.clear();
Programming in C++
// void or range of elements described by [f, l)
// r = ++it // r = l
// == a.erase(a.begin(), a.end());
Assignment
Sequence containers also provide overloaded forms of a member function assign x.assign(...) has the same effects as x.clear(); x.insert(x.begin(), ...) but more efficient Assign n default values to container assign(size_type n); Assign n copies of an element x to container assign(size_type n, T x); Assign elements from container of other type described by iterators to container element types must be assignment compatible template<class Iterator> assign(Iterator first, Iterator last); Example vector<int> x; x.assign(3, 42);
Programming in C++
// => { 42, 42, 42 }

Optional Operations
These operations are provided only for the sequence containers for which they take constant time: Expression Semantics Container
Getting the first or last element: a.front() a.back() *a.begin() *--a.end() vector, list, deque vector, list, deque
Adding (push) or deleting (pop) elements at the beginning or end: a.push_front(x) a.push_back(x) a.pop_front() a.pop_back() a.insert(a.begin(),x) a.insert(a.end(),x) a.erase(a.begin()) a.erase(--a.end()) list, deque vector, list, deque list, deque vector, list, deque
Random access to elements: a[n] a.at(n) *(a.begin() + n) *(a.begin() + n) vector, deque vector, deque
at() provides bounds-checked access throws out_of_range if n >= a.size()

STL vector<T>
Basics
Sequence container vector<T> provides fast random access to elements vector<T> can be seen as C style array with a C++ wrapper but will automatically resize itself when necessary adheres to the STL conventions (i.e., defines public types, iterators, ...) Usage: #include <vector> using std::vector; vector<float> x(10); vector<T> provides random-access iterators all STL algorithms may be applied to them
Programming in C++
Page 395
STL vector<T>
vector<T> also replacement for built-in (especially) dynamic arrays vector<int> x(len); //instead of:
Basics
int *x = new int[len]; ...; delete[] x; //throw dice
for (int i=0; i<x.size(); ++i) { x[i] = 1 + int(6.0*rand()/(RAND_MAX+1.0)); } Advantages: Size does not have to be constant vector<T> knows its size
STL compliant, e.g., STL algorithms and iterator access works too: for (vector<int>::iterator it=x.begin(), it!=x.end(); ++it) { cout << " " << *it; } can dynamically increase size (automatically with insert() or push_back(), not []!!) vector<T> objects can be assigned bounds checking possible using at()
STL deque<T>
Sequence container deque<T> provides fast random access to elements very much like vector<T> can be seen as a vector which can grow dynamically on both ends Unlike vector<T>, deque<T> supports also constant time insert and erase operations at the beginning or end As with vector<T>, memory allocation and resizing is handled automatically but deque<T> does not provide methods capacity() and reserve() Usage: #include <deque> using std::deque; deque<float> x(10); deque<T> provides random-access iterators all STL algorithms may be applied to them
Basics
Programming in C++
Page 397
STL list<T>
Sequence container list<T> provides constant time insert and erase anywhere in the container unlike vector<T> or deque<T>, insert or erase operations never invalidate pointers or iterators has automatic storage management does not support random access list<T> is typically implemented as a doubly-linked list additional storage overhead per node (at least two pointers) Usage: #include <list> using std::list; list<float> x(10); list<T> provides bidirectional iterators not all STL algorithms may be applied to them (e.g. sort()!)
Basics
Page 398
STL list<T>
#include <iostream> #include <list> using namespace std; int main() { list<const char *> mammals; mammals.push_back("cat"); mammals.push_back("dog");
Example: Insertion
list<const char *>::iterator it = mammals.begin(); ++it; // it is now at "dog" mammals.insert(it, "cow"); // it is still at "dog"
const char *others[] = { "horse", "pig", "rabbit" }; mammals.insert(it, others, others+3); // it is still at "dog" for(it=mammals.begin(); it!=mammals.end(); ++it) cout << " " << *it; } Output: cat cow horse pig rabbit dog
STL list<T>
List Reordering: Sorting
STL generic sorting algorithms require random-access iterators (which list<T> doesnt have) list<T> provides its own efficient sort() member function Example #include <iostream> #include <list> #include <string> using namespace std; int main() { const char *places[] = { "Paris", "Rom", "London", "Juelich" }; list<string> placeList(places, places+4); placeList.sort(); for(list<string>::iterator it=placeList.begin(); it!=placeList.end(); ++it) cout << " " << *it; } Output: Juelich London Paris Rom

What sequence container should be used? Use vector<T> when fast, random-access is needed to the contents insertions and deletions usually occur at the end of the sequence size of the collection is reasonably constant or occasional resizing can be tolerated or size is known in advance
Final Remarks
If frequent insertions and deletions at the beginning of the sequence are also required, consider using deque<T> If frequent insertions and deletions are necessary everywhere in the sequence, use list<T>
STL provides adaptors which turn sequence containers into containers with restricted interface In particular, no iterators provided; can only be used through the specialized interface No real STL containers (STL algorithms cannot be used with the adapted containers) There are stack<T>, queue<T>, and priority_queue<T>
STL Container Adaptors
stack<T>
template <class T, class Container = deque<T> > class stack { public: typedef typename Container::value_type value_type; typedef typename Container::size_type size_type; explicit stack(const Container& = Container()); bool empty() const; size_type size() const; value_type& top(); // get top element const value_type& top() const; void push(const value_type& x); // add element on top void pop(); // remove top element }; Container can be any STL container with empty(), size(), back(), pop_back(), and push_back() Example: #include <stack> using std::stack; stack<char> s1; stack<int, vector<int> > s2;
Programming in C++
// uses deque<char> for storage // uses vector<int>

Page 402

template <class T, class Container = deque<T> > public: // the same typedefs as stack
queue<T>
class queue {
explicit queue(const Container& = Container()); bool empty() const; size_type size() const; value_type& front(); // get front element const value_type& front() const; value_type& back(); // get back element const value_type& back() const; void push(const value_type& x); // add element to back void pop(); // remove front element }; Container can be any STL container with empty(), size(), front(), back(), push_back(), and pop_front() vector cannot be used! Example: #include <queue> using std::queue; queue<char> q1;
priority_queue<T>
template <class T, class Ctr = vector<T>, class Cmp = less<typename Ctr::value_type> > class priority_queue { public: // the same typedefs as stack explicit priority_queue(const Cmp&=Cmp(), const Ctr&=Ctr()); bool empty() const; size_type size() const; const value_type& top() const; // get "top" element void push(const value_type& x); // add element void pop(); // remove "top" element }; "top" element := element with highest priority largest element based on Cmp Container Ctr must provide random-access iterators list cannot be used! Example: #include <queue> using std::priority_queue; priority_queue<char> pq1;
STL Associative Containers

Associative containers store the elements based on keys are sorted (based on keys) STL provides four associative containers: map<Key, T> collection of (key, value) pairs fast retrieval based on keys each key in map is unique one value per key set<T> map where key is value itself multimap<Key,T> and multiset<T> versions of map and set where keys must not be unique more than one value per key 1 3 4 7 set<int>
Overview
a:1 d:9 c:1 z:4
map<char,int>
1 3 4 4 multiset<int> a:1 c:9
c:1 z:4
multimap<char,int>
maps called associative array or table, multimap dictionary, and multiset bag in other languages

Associative containers are sorted based on key_type::operator<() or a user-specified predicate Cmp
Internal Sorting
Cmp must define strict weak ordering ([1]+[2] is partial ordering) [1] [2] [3] Cmp(x,x) is false // irreflective If Cmp(x,y) and Cmp(y,z), then Cmp(x,z) // transitive If equiv(x,y) and equiv(y,z), then equiv(x,z)
Associative containers have an optional extra template parameter specifying the sorting criterion default is key_type::operator<() Equality of keys is tested using key_type::operator==() with user-specified sorting criterion Cmp equiv(x,y) is defined as !(Cmp(x,y) || Cmp(y,x)) Note: operator<() for C style strings (char *) compares pointers not the contents! use: bool strLess(const char *p1, const char *p2) { return strcmp(p1, p2) < 0; }

The member functions return iterator end() to indicate not found
Finding Elements
There are five member functions for locating a key k in an associative container ac Return iterator to element with key k iterator it = ac.find(k); Find number of elements with key k size_type c = ac.count(k); Find first element with key greater equal than k iterator it = ac.lower_bound(k); Find first element with key greater than k iterator it = ac.upper_bound(k); Get subsequence [lower_bound, upper_bound) at once pair<iterator,iterator> p = ac.equal_range(k); Of course, the last three member functions are more useful for multiset and multimap
STL set<T> and multiset<T>
Basics
Associative container set<T> keeps a sorted collection of unique values Associative container multiset<T> keeps a sorted collection of values for set and multiset, key is value itself! T == value_type == key_type Usage: #include <set> using std::set; set<float> x; set<int, greater<int> > y; std::multiset<double> z; set<T> and multiset<T> provide bidirectional iterators not all STL algorithms may be applied to them // sorted by < // sorted by >
Programming in C++
Page 408
STL set<T> and multiset<T>
Inserting and Deleting Elements
The position of elements in an associative container are determined by the sorting criterion insertion member functions do not have iterator parameter specifying position for insert Two more forms of insert are provided for a set or multiset container SetContainer Insert value val SetContainer c; SetContainer::iterator it = c.insert(val); Add elements from other container described by iterator range [f, l) c.insert(f, l); // void
For set, keys are only inserted if they do not already occur in the container. Also, instead of returning an iterator, insert(val) returns a pair<iterator,bool> where the second part is false when the value was already present and was not inserted. In addition to the usual ways of deleting elements (erase(it), erase(f,l), and clear()), associative containers also allow deletion based on keys (== values for sets): c.erase(key);
STL set<T>
#include <iostream> #include <set> using namespace std; int main() { set<int> x; x.insert(42); x.insert(496); x.insert(6); x.insert(42); x.insert(-5);
Example
for(set<int>::iterator it=x.begin(); it!=x.end(); ++it) cout << " " << *it; cout << endl; } Output: -5 6 42 496
Programming in C++
Page 410
STL multiset<T>
#include <iostream> #include <set> using namespace std; int main() { multiset<int> x; x.insert(42); x.insert(496); x.insert(6); x.insert(42); x.insert(-5);
Example
for(multiset<int>::iterator it=x.begin(); it!=x.end(); ++it) cout << " " << *it; cout << endl; } Output: -5 6 42 42 496
STL map<Key,T> and multimap<key,T>
Basics
Associative container map<Key,T> keeps a sorted collection of unique (key, value) pairs Associative container multimap<Key,T> keeps a sorted collection of (key, value) pairs map and multimap have the same forms of insert (and erase) like sets, but their value_type is defined as pair<const Key,T> insert member functions take parameter of type pair<const Key,T> iterators point to pair<const Key,T> (const Key because changing keys could destroy sorting) Usage: #include <map> using std::map; map<int,int> m; std::multimap<char*,int,strLess> mm; // int -> int // char* -> int
map<Key,T> and multimap<Key,T> provide bidirectional iterators not all STL algorithms may be applied to them
STL
pair<T1,T2>
STL provides small utility class pair<T1,T2> which essentially looks like this: template<class T1, class T2> struct pair { T1 first; T2 second; pair(const T1& f, const T2& s) : first(f), second(s) {} }; Example of map insert map<string,float> numbers; numbers.insert(pair<string,float>("Pi", 3.141592653589)); numbers.insert(pair<string,float>("e", 2.718281828459)); To make pairs slightly less ugly, STL provides make_pair() function: numbers.insert(make_pair("Pi", 3.141592653589)); In addition, map (but not multimap) provides an overloaded operator[]: numbers["Pi"] = 3.141592653589; lookup key and return reference to value; if not found, insert pair(key,T())! For lookup without modifying map use find() or count()!
STL map<Key,T>
#include <iostream> #include <map> #include <string> using namespace std; int main() { map<string,double> prices; prices["sugar"] = 2.99; prices["salt"] = 1.87; prices["flour"] = 2.49; cout << "Sugar costs " << prices["sugar"] << endl; map<string,double>::iterator h = prices.find("salt"); cout << "Salt costs " << h->second << endl; } Output: Sugar costs 2.99 Salt costs 1.87
Example
Programming in C++
Page 414
STL multimap<Key,T>
Example
#include <iostream> #include <map> #include <string> using namespace std; typedef pair<string,string> Pair; typedef multimap<string,string> strMap; typedef pair<strMap::iterator, strMap::iterator> iterPair; int main() { strMap phonebook; phonebook.insert(Pair("Hans", phonebook.insert(Pair("Lisa", phonebook.insert(Pair("Moni", phonebook.insert(Pair("Hans",
"0123 "0999 "0180 "0771
/ / / /
454545")); 12345")); 999999")); 16528"));
iterPair ip = phonebook.equal_range("Hans"); for(strMap::iterator it=ip.first; it!=ip.second; ++it) cout << "Hans's phone number is " << it->second << endl; } Output:
Programming in C++
Hans's phone number is 0123 / 454545 Hans's phone number is 0771 / 16528
STL
Algorithms
STL provides a large assortment of algorithms which can be applied to any data structure which adheres to the STL conventions (especially provides iterators) Defined in the header file <algorithm> STL algorithms can be grouped into four categories: Nonmutating sequence algorithms operate on containers without making changes to their contents (e.g., find) can also be applied to const container Mutating sequence algorithms operate on containers changing their contents (e.g., fill). Often, mutating algorithms come in two versions foo() and foo_copy(): In-place version: replaces original contents of container with results Copying version: places the result in a new container Sorting-related algorithms sort containers or operate only on sorted containers set<T>, map<T>, sorted vector<T>s, ... Generalized numeric algorithms defined in header <numeric>
STL Algorithms
For example, one version of sort() has the following prototype:
Function Parameters
Some STL algorithms have a version which takes an extra function parameter.
template<class RandomIter, class Compare> void sort(RandomIter first, RandomIter last, Compare cmp); cmp is a function parameter specifying the sorting criterion for sorting the range [first, last) For example, suppose we have a very simple class Person: struct Person { Person(const string& first, const string& last) : firstName(first), lastName(last) {} string firstName, lastName; }; ostream& operator<<(ostream& ostr, const vector<Person>& folks) { vector<Person>::const_iterator it; for (it=folks.begin(); it!=folks.end(); ++it) ostr << it->firstName << " " << it->lastName << endl; return ostr; }
STL Algorithms
Function Parameters
We now want to be able to sort a vector of Person according to either the first or last name Function parameters can be expressed in two ways: as pointer to functions: bool compareFirstName(const Person& p1, const Person& p2) { return p1.firstName < p2.firstName; } as function objects or functors := objects which behave like functions object with function call operator operator() defined struct compareLastName { bool operator()(const Person& p1, const Person& p2) { return p1.lastName < p2.lastName; } }; biggest advantage: function objects can have local state also: more efficient because can be inlined (no indirect function calls!) Non-modifying Functions or functors which return bool are also called predicates
STL Algorithms
#include <iostream> #include <vector> #include <string> #include <algorithm> using namespace std; int main() { vector<Person> folks;
Function Parameters
folks.push_back(Person("Hans", "Lustig")); folks.push_back(Person("Lisa", "Sommer")); folks.push_back(Person("Moni", "Hauser")); folks.push_back(Person("Herbert", "Hauser")); // -- sort with function pointer sort(folks.begin(), folks.end(), compareFirstName); cout << "Sorted by first name:" << endl << folks << endl; // -- sort with functor; note the () to call default ctor to get an object! sort(folks.begin(), folks.end(), compareLastName()); cout << "Sorted by last name:" << endl << folks << endl; }
STL Algorithms Reference

To keep the following description of the STL algorithms compact the template<...> specification was omitted
General Remarks
secondary forms of the same algorithm are not described in full detail (e.g., the _copy version or versions with an additional optional parameter) the template parameter names are significant: Name In Out For Bi Ran Op, BinOp Cmp Meaning input iterator output iterator forward iterator bidirectional iterator random-access iterator unary and binary operation (function or functor) sorting criterion with strict weak ordering
Pred, BinPred unary and binary predicate
Programming in C++
Page 420
STL
Linear Search
Nonmutating Sequence Algorithms
Find first element equal to value; return last when not found In find(In first, In last, const T& value); Find first element for which unary predicate pred is true In find_if(In first, In last, Pred pred); Example: use find_if to find all persons whose last name matches a string (using string::find()!) define predicate functor struct lastNameMatch { lastNameMatch(const string& pattern) : patt(pattern) {} bool operator()(const Person& p) { return p.lastName.find(patt) != string::npos; } private: string patt; };
STL Algorithms
int main() { vector<Person> folks;
Example: find_if
folks.push_back(Person("Hans", "Lustig")); folks.push_back(Person("Lisa", "Sommer")); folks.push_back(Person("Moni", "Hauser")); folks.push_back(Person("Herbert", "Hauser")); vector<Person>::iterator it = folks.begin(); while (true) { it = find_if(it, folks.end(), lastNameMatch("use")); if (it == folks.end()) break; cout << it->firstName << " " << it->lastName << endl; ++it; } } Output: Moni Hauser Herbert Hauser
Programming in C++
Page 422
STL
Linear Search (cont.)
Find first element out of any values in [first2, last2) in the range [first1, last1) For find_first_of(For first1, For last1, For first2, For last2); Find first consecutive duplicate element For adjacent_find(For first1, For last1); Find first occurrence of subsequence [first2, last2) in [first1, last1) For search(For first1, For last1, For first2, For last2); Find last occurrence of subsequence [first2, last2) in [first1, last1) For find_end(For first1, For last1, For first2, For last2); Find first occurrence of subsequence of count consecutive copies of value For search_n(For first1, For last1, Size count, const T& value); All return last1 for indicating not found These five algorithms are also available with an additional parameter pred specifying a binary predicate to be used instead of operator==() to check for equality
STL
Counting Elements Count number of elements equal to value
difference_type count(In first, In last, const T& value); Count number of elements that satisfy predicate pred difference_type count_if(In first, In last, Pred pred); Minimum and Maximum Return the minimum or maximum of two elements const T& min(const T& a, const T& b); const T& max(const T& a, const T& b); Find smallest and largest element For min_element(For first, For last); For max_element(For first, For last); These four functions are also available with an additional parameter cmp specifying a sorting criterion to be used instead of operator<() for comparing elements
Programming in C++
Page 424
STL
Comparing Two Ranges
Is range1 equal to range2 (i.e., same elements in same order)? bool equal(In first1, In last1, In first2); Find first position in each range where the ranges differ pair<InIt1, InIt2> mismatch(In first1, In last1, In first2); Second range starting at first2 must be at least as long as range1 [first1, last1) Both also available with additional parameter specifying binary predicate pred Is range1 lexicographically less than range2? bool lexicographical_compare(In first1, In last1, In first2, In last2); Also available with additional parameter specifying sorting criterion cmp for_each Apply unary function or function object f to each element in the sequence Return f (useful for functors which keep / calculate state information) Op for_each(In first, In last, Op f);
STL
Copying Ranges
Mutating Sequence Algorithms
Copy range1 [first, last) to range2 starting at result Out copy(In first, In last, Out result); Copy range1 [first, last) to range2 ending at result backwards use this version if range1 and range2 overlap (start of range2 is between first and last) Bi copy_backward(Bi first, Bi last, Bi result); The result range must have enough elements to store result! (the elements are assigned the result values, they are not inserted) Example: block<int,6> x = { 1, 2, 3 4, 5, 6 }; vector<int> not_ok, ok(x.size()); copy(x.begin(), x.end(), not_ok.begin()); copy(x.begin(), x.end(), ok.begin()); // undefined! // OK!
Programming in C++
Page 426
STL
Transforming Elements
Apply unary operation op() to elements in range [first, last) and write to res Out transform(In first, In last, Out res, Op op); Apply binary operation op() to corresponding elements in range1 [first1, last1) and range2 starting at first2 and write to range starting at res Out transform(In first1, In last1, In first2, Out res, BinOp op); Example: inline int Square(int z) { return z*z; } block<int,6> x = { 1, 2, 3 4, 5, 6 }; vector<int> res(x.size()); transform(x.begin(), x.end(), res.begin(), Square); for (vector<int>::iterator it=res.begin(); it!=res.end(); ++it) cout << *it << " "; cout << endl; Output: 1 4 9 16 25 36
STL
Replacing Elements
Replace all elements with value old in-place with value new void replace(For first, For last, const T& old, const T& new); Replace all elements satisfying predicate pred in-place with value new void replace_if(For first, For last, Pred pred, const T& new); Also available as replace_copy and replace_copy_if with additional third parameter describing result range starting at output iterator out Filling Ranges Assign value to all elements in range [first, last) or [first, first+n) void fill(For first, For last, const T& value); void fill_n(Out first, Size n, const T& value); Assign result of calling gen() to all elements in range [first, last) or [first, first+n) void generate(For first, For last, Generator gen); void generate_n(Out first, Size n, Generator gen);
Programming in C++
Page 428
STL
Removing Elements Remove all elements equal to value
For remove(For first, For last, const T& value); Remove all elements which satisfy predicate pred For remove_if(For first, For last, Pred pred); Remove all consecutive duplicate elements (using operator==() or predicate pred) For unique(For first, For last); For unique(For first, For last, BinPred pred); Also available as remove_copy, remove_copy_if, and unique_copy with additional third parameter describing result range starting at output iterator out Note: These functions do not really remove the elements from the sequence but move them to the end returning the position where the removed elements start To really delete the elements from a Container C use erase(), e.g., for remove: C.erase(remove(C.begin(), C.end(), x), C.end());
Programming in C++
Page 429
STL
Permuting Algorithms
Reverse range in-place or copy reverse range to range starting at res void reverse(Bi first, Bi last); Out reverse_copy(Bi first, Bi last, Out res); Exchange [first, middle) and [middle, last) in-place or copy to res void rotate(For first, For middle, For last); Out rotate_copy(For first, For middle, For last, Out res); Transform range into next or previous lexicographical permutation bool next_permutation(Bi first, Bi last); bool prev_permutation(Bi first, Bi last); also available with additional parameter specifying sorting criterion cmp Randomly re-arrange elements (using the internal or an user-specified random-number generator) void random_shuffle(Ran first, Ran last); void random_shuffle(Ran first, Ran last, RandomNumberGen& rand);
Programming in C++
Page 430
STL
Partitions
Reorder the elements so that all elements satisfying pred precede the elements failing it Bi partition(Bi first, Bi last, Pred pred); Same as partition but preserves relative order of elements Bi stable_partition(Bi first, Bi last, Pred pred);
Swapping Elements Exchange values of elements a and b void swap(T& a, T& b); Exchange values of elements pointed to by it1 and it2 (swap(*it1, *it2)) void iter_swap(For it1, For it2); Swap the corresponding elements of range1 [first1, last1) and range2 starting at first2 For swap_ranges(For first1, For last1, For first2);
Programming in C++
Page 431
STL
Sorting Ranges Sort elements in ascending order (smallest element first) void sort(Ran first, Ran last);
Sorting Algorithms
Like sort() but preserves the relative order between equivalent elements void stable_sort(Ran first, Ran last); Put smallest middle-first elements into [first, middle) in sorted order void partial_sort(Ran first, Ran middle, Ran last); Put smallest rlast-rfirst elements of [first, last) into [rfirst, rfirst+N) in sorted order; N is minimum of last-first and rlast-rfirst Ran partial_sort_copy(In first, In last, Ran rfirst, Ran rlast); Sort sequence so that element pointed to by nth is at correct place elements in [first, nth) are smaller than the elements in [nth, last) good for calculating medians or other quantiles void nth_element(Ran first, Ran nth, Ran last); All functions also available with additional parameter specifying sorting criterion cmp
STL
Binary Search
Algorithms on Sorted Ranges
Determine whether value is in sequence [first, last) using binary search bool binary_search(For first, For last, const T& value); Returns first / last position where element equal to value could be inserted without destroying ordering For lower_bound(For first, For last, const T& value); For upper_bound(For first, For last, const T& value); Return pair<lower_bound, upper_bound> pair<For, For> equal_range(For first, For last, const T& value); Merging Two Sorted Ranges Combine sorted ranges [first1, last1) and [first2, last2) into res Out merge(In first1, In last1, In first2, In last2, Out res); Combine the two consecutive sorted ranges [first, middle) and [middle, last) in-place void inplace_merge(Bi first, Bi middle, Bi last); All functions on page also available with additional parameter specifying sorting criterion cmp
STL
Set Operations
Is every element in [first1, last1) included in range [first2, last2)? bool includes(In first1, In last1, In first2, In last2); Determine set-like union, intersection, difference, and symmetric difference of the ranges [first1, last1) and [first2, last2) and write to res Out set_union(In first1, In last1, In first2, In last2, Out res); Out set_intersection(In first1, In last1, In first2, In last2, Out res); Out set_difference(In first1, In last1, In first2, In last2, Out res); Out set_symmetric_difference(In first1, In last1, In first2, In last2, Out res); Input ranges need only be sorted, they must be no real sets (duplicate elements allowed) All functions also available with additional parameter specifying sorting criterion cmp
Programming in C++
Page 434
STL
Heap Operations
heap (here) is a tree represented as a sequential range where each node is less than or equal to its parent node *first is largest element Turn range [first, last) into heap order void make_heap(Ran first, Ran last); Add element at last-1 to heap [first, last-1) void push_heap(Ran first, Ran last); Remove (move to the end) largest element void pop_heap(Ran first, Ran last); Turn heap into sorted range void sort_heap(Ran first, Ran last); All functions also available with additional parameter specifying sorting criterion cmp
Programming in C++
Page 435
STL
Generalized Numeric Algorithms
Calculate the sum of initval plus all the elements in [first, last) using T::operator+() or binary function op T accumulate(In first, In last, T initval); T accumulate(In first, In last, T initval, BinOp op); Calculate the sum of initval plus the results of first1[i]*first2[i] for the range [first1, last1) using operator+(), operator*() or binary functions op1, op2 T inner_product(Input1 Input2 T inner_product(Input1 Input2 first1, first2, first1, first2, Input1 last1, T initval); Input1 last1, T initval, BinOp op1, BinOp op2);
Calculate running sum of all elements (or running result of op()) Out partial_sum(In first, In last, Out result); Out partial_sum(In first, In last, Out result, BinOp op); Calculate differences xi-xi-1 for elements in [first+1, last) (or use op() instead of -) Out adjacent_difference(In first, In last, Out result); Out adjacent_difference(In first, In last, Out result, BinOp op); These functions are defined in header <numeric>
Advanced STL: Containers

#include <stddef.h> template <class T, size_t N> struct block { T data[N];
Example: block
block: minimal container which adheres to STL container convention (like built-in array)
// public data
// -- public types -typedef T value_type; typedef T& reference; typedef const T& const_reference; typedef ptrdiff_t difference_type; typedef size_t size_type; // -- iterators -typedef T* iterator; typedef const T* const_iterator; iterator begin() { return data; } const_iterator begin() const { return data; } iterator end() { return data+N; } const_iterator end() const { return data+N; }
Example: block (cont.)
// -- member access -reference operator[](int i) { return data[i]; } const_reference operator[](int i) const { return data[i]; } // -- other member functions -size_type size() const { return N; } size_type max_size() const { return N; } bool empty() const { return N==0; } void swap(block& x) { for (size_t n = 0; n < N; ++n) std::swap(data[n], x.data[n]); } operator T*() { return data; } }; Because block is defined as a POD (Plain Old Data) type, initialization syntax still works! block<int, 6> x = { 1, 4, 7, 3, 8, 4 }; // provided for compatibility // with built-in arrays
Programming in C++
Page 438
We still need to define global comparison operators operator==() and operator<() template <class T, size_t N> bool operator==(const block<T,N>& lhs, const block<T,N>& rhs) { for (size_t n = 0; n < N; ++n) if (lhs.data[n] != rhs.data[n]) return false; return true; } template <class T, size_t N> bool operator<(const block<T,N>& lhs, const block<T,N>& rhs) { for (size_t n = 0; n < N; ++n) if (lhs.data[n] < rhs.data[n]) return true; else if (rhs.data[n] < lhs.data[n]) return false; return false; } STL contains algorithm adaptors which define operator!=(), operator<=(), operator>(), and operator>=() out of the two operators above
If we want block to be a reversible container, we need to add also #include <iterator> template <class T, size_t N> struct block { // ... typedef std::reverse_iterator<iterator> reverse_iterator; typedef std::reverse_iterator<const_iterator> const_reverse_iterator; reverse_iterator rbegin() { return reverse_iterator(end()); } const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); } reverse_iterator rend() { return reverse_iterator(begin()); } const_reverse_iterator rend() const { return const_reverse_iterator(begin()); } // ... };
Advanced STL: Sequence Containers
Invalidating Iterators/Pointers
vector<T> and deque<T> member functions which modify the container (insert, erase) can invalidate iterators and pointers into the container invalidated iterator := the iterator points to another element or becomes invalid This is not true for list<T> with the exception of a iterator/pointer to a deleted element Example: vector<int> x(5); vector<int>::iterator i0=x.begin(), i1=x.begin()+2, i2=x.begin()+4; 0 1 2 3 4 i0 i1 i2 x.erase(i1); 0 1 3 4 i0 i1 i2
list<int> x(5); list<int>::iterator i0=x.begin(), i1=i0, i2; ++i1; ++i1; i2=i1; ++i2; ++i2; 0 i0
Programming in C++
2 i1
4 x.erase(i1); i2
0 i0
1 i1
4 i2
Page 441
Advanced STL: vector<T>
Resizing Behavior
When adding elements to a full vector<T>, automatic resizing occurs How this resizing occurs is implementation dependent resizing vector one by one element would be horribly inefficient usual methods are to double the size of the vector or to add fixed-sized blocks and copy over old elements vector<T> has two counts associated with it its size := the number of elements currently stored in the vector its capacity := the number of elements which could be stored without resizing always: size <= capacity The following member functions related to resizing are available: Get the size of a vector vector<T>::size_type size(); Get the capacity of a vector vector<T>::size_type capacity();
Advanced STL: vector<T>

Resize the vector to be of length n resize(size_type n, T initValue = T()); if n < size() elements at the end are removed
Resizing Behavior
if n > size() additional elements initialized with initValue are added to the end Ensure that the capacity is at least n reserve(size_type n); can be used to pre-allocate vector memory if approximate size if known in advance saves memory allocations and copies! Example const int n = 9000000; vector<float> numbers; numbers.reserve(n); for (int i = 0; i < n; ++i) number.push_back(random()); without reserve, several dozens of resizes would occur. With the last resize, vector would probably allocate a 64Mbyte buffer, copy over the 32Mbyte old values, and 29Mbyte would be wasted.
Advanced STL: list<T>
List Reordering: Splicing
A list<T> has the advantage that it can be reordered by changing links list reorder functions dont copy elements like insert() rather they modify the list data structures that refer to the elements The following reorder member functions are provided: Move contents of list2 into list1 just before iter, leave list2 empty list<T> list1, list2; list<T>::iterator iter; list1.splice(iter, list2); // points into list1
Move element pointed to by iter2 from list2 into list1 just before iter. Element is removed from list2. list1 and list2 may be the same list list<T>::iterator iter2; list1.splice(iter, list2, iter2); // points into list2
Move the range [i2, j2) from list2 into list1 just before iter. The range is removed from list2 list<T>::iterator i2, j2; list1.splice(iter, list2, i2, j2);
// point into list2
Page 444
Advanced STL: list<T>

list1.merge(list2);
List Reordering: Other Functions
Combine two sorted lists by moving elements from list2 into list1 while preserving order. if one of the list is not sorted, merge still produces one list (however unsorted) There are also sort and merge with a second argument specifying the ordering criterion cmp list1.sort(cmp); list1.merge(list2, cmp); (Really) remove duplicates that appear consecutively or elements that appear consecutively and both satisfy the predicate pred list1.unique(); list1.unique(pred); (Really) remove all elements with the value val or that satisfy predicate pred list1.remove(val); list1.remove_if(pred); Reverse all elements in the list list1.reverse();
Advanced STL
Almost Containers
C-style built-in arrays, strings, valarrays, and bitsets are also containers however, each lacks some aspect or the other of the STL standard containers these almost containers are not completely interchangeable with STL containers Built-in arrays supplies subscripting and random-access iterators in the form of ordinary pointers provides no public types and doesnt know its size (like block<T>) std::string defined in <string> provides subscripting, random-access iterators, and most of STL conventions but implementation is optimized for use as a string of characters std::bitset<N> defined in <bitset> like a vector<bool> but provides operations to manipulate bits, is of fixed size N, and is optimized for space std::valarray defined in <valarray> is a (badly defined) vector for optimized numeric computation
Advanced STL
Predefined Functors
STL library also provides some predefined predicates and functors in header <functional> unnecessary to invent tiny functions just to implement trivial function objects The following basic predicates and arithmetic functors are defined: Predicate equal_to not_equal_to greater less less_equal logical_and logical_or logical_not #Args Op 2 2 2 2 2 2 2 1 == != > < >= <= && || ! Arith.Func. plus minus divides modulus negate #Args Op 2 2 2 2 1 + * / % -
multiplies 2
greater_equal 2
These basic predicates and functors are all templates with one parameter specifying the base type greater<foo> is a functor behaving like foo::operator>()
Advanced STL
Predefined Functor Adaptors
more complex functors can be composed out of trivial ones with the help of functor adaptors The following adaptors are provided by the STL: Function bind2nd(f,y) bind1st(f,x) not1(f) not2(f) mem_fun(f) #Args Action of Generated Functor 1 1 1 2 Call binary STL functor f with y as 2nd argument Call binary STL functor f with x as 1st argument Negate unary predicate f Negate binary predicate f
0 or 1 Transform 0- or 1-argument member function f into functor (call through pointer)
mem_fun_ref(f) 0 or 1 Transform 0- or 1-argument member function f into functor (call through reference) ptr_fun(f) 1 or 2 Transform pointer to unary or binary function f into functor
adapters are simple forms of a higher-order function := takes a function argument and produces a new function from it
Advanced STL
Example: Predefined Functors
Example: write function that deletes all numbers smaller and including 1000 in a sorted vector First, we could write our usual predicate function: bool bigger1000(int n) { return n > 1000; } Then, we use STL algorithms, to find and erase elements in the vector: void g1(vector<int>& numbers) { vector<int>::iterator vi = find_if(numbers.begin(), numbers.end(), bigger1000); numbers.erase(numbers.begin(), vi); } Can even do away with the local variable vi void g2(vector<int>& numbers) { numbers.erase(numbers.begin(), find_if(numbers.begin(), numbers.end(), bigger1000)); }
Programming in C++
Page 449
Advanced STL
Use binary functor greater greater<T> greater<int> gt;
Example: Predefined Functors

// gt(3,4) => false
Need adapter functor apply with 2nd argument bound to value bind2nd() to fix value 1000 (bind2nd(gt,1000)) (999) (bind2nd(gt,1000)) (1001) // => false // => true
Now we can replace bigger1000 by predicate function: void g3(vector<int>& numbers) { greater<int> gt; numbers.erase(numbers.begin(), find_if(numbers.begin(), numbers.end(), bind2nd(gt,1000))); } Of course, default constructor call greater<int>() can replace local variable gt: void g4(vector<int>& numbers) { numbers.erase(numbers.begin(), find_if(numbers.begin(), numbers.end(), bind2nd(greater<int>(), 1000))); }
Advanced STL
First, define appropriate comparison function
Example 2: Predefined Functors
Read persons from standard input and store them sorted by first name in a list
bool cmpPtrFirstName(const Person* p1, const Person* p2) { return p1->firstName < p2->firstName; } Next, use it to find the right place to insert the new person in the list list<Person*> folks; string name, fname; while ( cin >> fname >> name ) { Person* p = new Person(fname, name); list<Person*>::iterator it = folks.begin(); while ( it != folks.end() ) { if ( cmpPtrFirstName(p, *it) ) break; ++it; } folks.insert(it, p); } How about using STL algorithms (and predefined functors)?
Advanced STL
Use STL find_if algorithm and bind1st and ptr_fun functor adaptors to find the right place in the list while ( cin >> fname >> name ) { Person* p = new Person(fname, name); list<Person*>::iterator it = find_if(folks.begin(), folks.end(), bind1st(ptr_fun(cmpPtrFirstName), p)); folks.insert(it, p); } Can even do without local variable it while ( cin >> fname >> name ) { Person* p = new Person(fname, name); folks.insert(find_if(folks.begin(), folks.end(), bind1st(ptr_fun(cmpPtrFirstName), p)), p); } Is it possible to avoid the need for functor adaptor ptr_fun?
Programming in C++
Page 452
Advanced STL
Write STL compatible functor by deriving from binary_function<arg1_type, arg2_type, ret_type> helper class: struct cmpPtrFirstNameFtor : public binary_function<const Person*, const Person*, bool> { bool operator()(const Person* p1, const Person* p2) const { return p1->firstName < p2->firstName; } }; Then: while ( cin >> fname >> name ) { Person* p = new Person(fname, name); folks.insert(find_if(folks.begin(), folks.end(), bind1st(cmpPtrFirstNameFtor(), p)), p); } Can we do without functor adaptor bind1st?
Programming in C++
Page 453
Advanced STL
Implement unary functor with state (remembering the person to compare to): struct cmpPtrWithFirstName : public unary_function<const Person*, bool> { cmpPtrWithFirstName(const Person *pers) : ref(pers) {} bool operator()(const Person *other) const { return ref->firstName < other->firstName; } const Person* ref; }; Usage: folks.insert(find_if(folks.begin(), folks.end(), cmpPtrWithFirstName(p)), p); Note! Probably more efficient to simply insert persons into the list and sort them once: while ( cin >> fname >> name ) folks.push_back(new Person(fname, name)); folks.sort(cmpPtrFirstName);
Advanced STL
The STL header <iterator> provides
Iterator Adaptors
iterator primitives: utility classes and functions to simplify the task of defining new iterators iterator operations: Increments (or decrements for negative n) iterator i by n void advance(InputIter& i, Distance n); Returns the number of increments or decrements needed to get from first to last difference_type distance(InputIter first, InputIter last); predefined iterators: Insert iterators assignment to iterator inserts value in container back_inserter(Container& x); front_inserter(Container& x); inserter(Container& x, Iterator i); Stream iterators stepping iterator means reading/writing values from/to stream istream_iterator(istream& s); ostream_iterator(ostream& s, const char* delim); Reverse iterators (see block<T> example)
Advanced STL
Example: Stream Iterators
ostream_iterators useful for printing container (cont<T> C) if operator<< for type of container element T exists. Instead of for (cont<T>::iterator it=C.begin(); it!=C.end(); ++it) cout << *it << "\n"; you can use copy(C.begin(), C.end(), ostream_iterator<T>(cout, "\n")); Also useful for directly printing results of mutating sequence algorithms: inline int Square(int z) { return z*z; } block<int,6> x = { 1, 2, 3, 4, 5, 6 }; ostream_iterator<int> ot(cout, " "); transform(x.rbegin(), x.rend(), ot, Square); cout << "--- "; transform(x.begin(), x.end(), x.rbegin(), ot, multiplies<int>()); cout << endl; Output: 36 25 16 9 4 1 --- 6 10 12 12 10 6
Advanced STL
Example: Insert Iterators
Result range of mutating sequence algorithms (e.g., transform) must have enough elements to store result (because the elements are assigned the result values, they are not inserted) Make sure result container is large enough: block<int,6> x1 = { 1, 2, 3, 4, 5, 6 }; vector<int> res1(x1.size()); copy(x1.begin(), x1.end(), res1.begin()); res1: {1, 2, 3, 4, 5, 6} copy(x.begin(), x.end(), res1.rbegin()); res1: {6, 5, 4, 3, 2, 1} Or use iterator adaptors: block<int,6> x2 = { 1, 2, 3, 4, 5, 6 }; list<int> res2; copy(x2.begin(), x2.end(), back_inserter(res2)); res2: {1, 2, 3, 4, 5, 6} res2: {6, 5, 4, 3, 2, 1, 1, 2, 3, 4, 5, 6}
// OK! // reversed!
// OK!
copy(x2.begin(), x2.end(), front_inserter(res2)); // reversed!
STL Iterator Adaptors

#include <fstream> #include <vector> #include <algorithm> #include <iterator> using namespace std; int main (int argc, char ifstream ii(argv[1]); ofstream oo(argv[2]); vector<int> buf; // // // // get get get get
Example: Sort Numbers in File

the the the the I/O facilities vector facilities operations on containers iterator facilities
*argv[]) { // setup input // setup output // vector used for buffering
// initialize buffer from input copy(istream_iterator<int>(ii), istream_iterator<int>(), back_inserter(buf)); // sort the buffer sort(buf.begin(), buf.end());
// def ctor => EOF iterator
// copy to output copy(buf.begin(), buf.end(), ostream_iterator<int>(oo,"\n")); }

Advanced STL
STL Containers always contain copies of objects
Copying of Objects
adding objects to or getting objects from a container means copying moving objects in a sequence container (because of insert or erase) means copying changing order in a sequence container (because of sort, reverse, ...) means copying make sure copying objects works correctly pointer members deep copy?! derived objects slicing! for heavy objects or in the presence of inheritance: use containers of pointers to objects better: use smart pointers for automatic memory management
Programming in C++
Page 459
Advanced STL
Example: Copying of Objects
class P { public: P(const string& _n) : n(_n), i(1) { print(cout, "Construct"); } P(const P& p) : n(p.n), i(p.i+1) { print(cout, "Copy"); } P& operator=(const P& p) { print(cout, "Delete"); n = p.n; i = p.i+1; print(cout, "Copy Assign"); return *this; } ~P() { print(cout, "Delete"); } ostream& print(ostream& ostr, const char* action) const { return ostr << action << "(" << n << i << ")\n"; } private: string n; int i; };
Programming in C++
// My name is "n" // I am the i-th copy
Page 460
Advanced STL
Example: Using Objects

Possible output (depends on resize behavior):
Construct(Bob1) Copy(Bob2) //passing by value Delete(Bob1) //Construct(Joe1) Copy(Joe2) //passing by value Delete(Joe1) //Construct(Sue1) Copy(Bob3) //vector resize Copy(Joe3) //vector resize Copy(Sue2) //passing by value Delete(Bob2) //Delete(Joe2) //Delete(Sue1) //Copy(Bob4) Delete(Bob4) Copy Assign(Sue3) Out(Bob3) Out(Joe3) Out(Sue2) Out(Sue3) Delete(Sue3) Delete(Bob3) Delete(Joe3) Delete(Sue2)
Page 461
ostream& operator<<( ostream& ostr, const P& p) { return p.print(ostr, "Out"); } vector vec1, vec2; vec1.push_back( P("Bob") ); vec1.push_back( P("Joe") ); vec1.push_back( P("Sue") ); vec2.push_back( vec1[0] ); vec2[0] = vec1[2];
copy(vec1.begin(), vec1.end(), ostream_iterator(cout)); copy(vec2.begin(), vec2.end(), ostream_iterator(cout));

Programming in C++
Advanced STL
Example: Using Pointer to Objects

Output:
ostream& operator<<( ostream& ostr, const P* p) { return p->print(ostr, "Out"); } vector<P*> vec1, vec2; vec1.push_back( new P("Bob") ); vec1.push_back( new P("Joe") ); vec1.push_back( new P("Sue") ); vec2.push_back( vec1[0] ); vec2[0] = vec1[2];
Construct(Bob1) Construct(Joe1) Construct(Sue1) Out(Bob1) Out(Joe1) Out(Sue1) Out(Sue1) //no Delete?! Can do manual delete but might get complicated in larger program! Use smart pointer!
copy(vec1.begin(), vec1.end(), ostream_iterator<P*>(cout)); copy(vec2.begin(), vec2.end(), ostream_iterator<P*>(cout));

Advanced STL
typedef shared_ptr PPtr;
Example: Using Smart Pointer to Objects

Output: Construct(Bob1) Construct(Joe1) Construct(Sue1) Out(Bob1) Out(Joe1) Out(Sue1) Out(Sue1) Delete(Bob1) Delete(Joe1) Delete(Sue1) Note! Sue1 gets (correctly) deleted just once!
ostream& operator<<( ostream& ostr, const PPtr& p) { return p->print(ostr, "Out"); } vector<PPtr> vec1, vec2; vec1.push_back(PPtr(new P("Bob"))); vec1.push_back(PPtr(new P("Joe"))); vec1.push_back(PPtr(new P("Sue"))); vec2.push_back( vec1[0] ); vec2[0] = vec1[2];
copy(vec1.begin(), vec1.end(), ostream_iterator<PPtr>(cout)); copy(vec2.begin(), vec2.end(), ostream_iterator<PPtr>(cout));

Advanced STL
Example: Shared ownership based on reference counting template<typename T> class shared_ptr { private: T* px; long* pn;
Simple Smart Pointer Class
Idea: Implement pointer-like class which automatically deletes content if necessary
// contained pointer // pointer to reference counter
public: explicit shared_ptr(T* p = 0) : px(p), pn(new long(1)) {} ~shared_ptr() { if (--*pn == 0) { delete px; delete pn; } } shared_ptr(const shared_ptr& r) : px(r.px) { ++*(pn = r.pn); } shared_ptr& operator=(const shared_ptr& r); T& operator*() const T* operator->() const T* get() const bool unique() const };
{ { { {
return return return return
*px; } px; } px; } *pn == 1; }
Advanced STL
Simple Smart Pointer Class
template<typename T> shared_ptr<T>& shared_ptr<T>::operator=(const shared_ptr<T>& r) { if (pn != r.pn) { // increment new reference counter ++*(r.pn); // decrement old reference counter, delete if last if (--*pn == 0) { delete px; delete pn; } // copy pointer and counter px = r.px; pn = r.pn; } return *this; } Example smart pointer too simple for professional use other ownership models (no copy allowed, copy transfers ownership, shared, ...) const and inheritance issues multi-threading? better: see smart pointer collection at boost.org
Advanced STL
vector, deque, string: list: associative container:
Removing Objects from Containers

use erase/remove idiom
To eliminate all objects in a container C that have a particular value val:
C.erase(remove(C.begin(), C.end(), val), C.end()); use list method remove(val) use container method erase(key)
To eliminate all objects in a container that satisfy a particular predicate pred: vector, deque, string: list: associative container: AssocCtr C, OK; remove_copy_if(C.begin(), C.end(), inserter(OK, OK.end()), pred); C.swap(OK); use erase/remove_if idiom use list method remove_if(pred) use remove_copy_if and then swap elements
Programming in C++
Page 466
Advanced STL
Finding Objects in Containers
Which method should be used to find objects in STL containers? the faster and simpler, the better! unsorted containers: sorted sequence containers: associative containers: can only use linear-time algorithms find, find_if, count, and count_if can use faster binary_search, lower_bound, upper_bound, and equal_range algorithms can use faster binary_search, lower_bound, upper_bound, and equal_range methods
Note! the linear-time algorithms use equality to test whether two objects are the same, the others equivalence! equality x1 == x2 ! ( x1 < x2 ) && ! ( x2 < x1 )
equivalence
Programming in C++
Page 467
Advanced STL
Summary: What You Want to Know Does desired value exist? Where is first object of desired value? Algorithm to Use Unsorted Range find find Sorted Range
Finding Objects in Containers
Member Function to Use set or map count find multiset or multimap find find or lower_bound
binary_search equal_range lower_bound
Where is first object with find_if a value not preceding desired value? Where is first object with a value succeeding desired value? How many objects have desired value? Where are all objects with desired value?
Programming in C++
lower_bound lower_bound
find_if
upper_bound
upper_bound upper_bound
count find (iteratively)
equal_range equal_range
count
count
equal_range equal_range
Page 468
Advanced STL
What about calling old code?
Pass vector or string Data to C Functions
Use vector<T> instead of built-in arrays and string instead of char*!
Consider, we need to call an old C function void doSomething(const int *pInts, size_t numInts); but we have vector<int> v; pass address of first element and size (But dont forget empty vectors!) if ( !v.empty() ) { doSomething(&v[0], v.size()); } What about void doSomething(const char *pString); string s; Use string method c_str() doSomething(s.c_str());
Programming in C++
Page 469
STL
Books on STL Austern, Generic Programming and the STL, Addison-Wesley, 1998, ISBN 0-201-30956-4. Most up-to-date and complete book on STL, good tutorial and reference Josuttis, The C++ Standard Library A Tutorial and Reference Addison-Wesley, 1999, ISBN 0-201-37926-0. Most up-to-date and complete book on whole C++ standard library (including iostream, string, complex, ...) Meyers, Effective STL, Addison-Wesley, 2001, 0-201-74962-9. 50 specific ways to improve your use of the standard template library
Books
General C++ Books (but cover STL very well) Stroustrup, The C++ Programming Language, Third Edition Lippman and Lajoie, C++ Primer, Third Edition
Programming in C++
Page 470
STL
WWW STL Information SGI STL (public-domain implementation plus well-organized on-line documentation) http://www.sgi.com/tech/stl/ Adapted SGI STL (value-added and more portable version of SGI STL) http://www.stlport.org BOOST: free, peer-reviewed, portable C++ libraries http://www.boost.org
WWW
Programming in C++
Page 471
STL
Portability
Watch out for differences between original public domain STL from HP and the C++ standard: HP (SGI) STL container adaptors stack, queue, ... iterator access scope of items headers C++ Standard STL
Adaptor<Container<T> > Adaptor<T> Adaptor<T, Container<T> > (*iter).field global scope <algo.h> <function.h> <stack.h> <map.h>, <multimap.h> <set.h>, <multiset.h> times<T> iter->field or (*iter).field in namespace std <algorithm>, <numeric> <functional> <stack>, <queue> <map> <set> multiplies<T> int n; n = func(...); istream_iterator <T,charT,traits,Distance>
Page 472
* functor
algorithms: int n = 0; count, count_if, func(..., n); distance I/O iterators (ostream analog)
Programming in C++
istream_iterator <T,Distance>
Programming in C++
Advanced C++
Programming in C++
Page 473
Advanced C++
Private Inheritance: Access Specifiers
Private inheritance allows to implement a class in terms of another one: e.g. try to implement Set as List without head/tail and new insert through derivation with (compile-time) cancellation (but: not allowed in ARM C++!!!) class List { public: elem* head(); elem* tail(); int size(); bool has(elem&); void insert(elem&); }; However, it works the other way: class Set: private List { public: void insert(elem&); List::size; List::has; };
Programming in C++
class Set: public List { public: void insert(elem&); private: List::head; // error! in ARM C++ List::tail; // error! in ARM C++ }; In new C++ Standard: derivation with cancellation now allowed "using declaration" should be used instead of access specifiers: using List::size; using List::has;
Page 474
Advanced C++
But reuse through private inheritance has a severe limitation:
Private Inheritance
the following is illegal because no class may appear as a direct base class twice class Arm { ... }; class Leg { ... }; class Robot: Arm, Arm, Leg, Leg { private: // Robot specific members public: Robot(); }; // illegal!
Solution: use class members or layering (nested classes) class Robot { private: Arm leftarm, rightarm; Leg leftleg, rightleg; ... avoid private inheritance if possible
Advanced C++
Sometimes, the design of a class requires an auxiliary class Solution: nested classes class Stack { private: class StackNode { T data; StackNode *next; public: StackNode( const T& d, StackNode *n) : data(d), next(n) {} }; StackNode *top; public: Stack(); ~Stack(); void push(const T& data); T pop(); };
Programming in C++
Nested Classes
if compiler doesnt support nested classes use private global class with friend class StackNode { private: T data; StackNode *next; StackNode( const T& d, StackNode *n) : data(d), next(n) {} friend class Stack; }; class Stack { public: Stack(); ~Stack(); // ... };
Page 476
Advanced C++
Nested classes can now be forward declared just like other classes: class Outer { class Inner; public: Inner* getCookie(); private: class Inner { /* ... */ }; }; The definition can now also be outside the class: class Outer { class Inner; public: Inner* getCookie(); }; class Outer::Inner { /* ... */ };
Nested Classes
Programming in C++
Page 477
Advanced C++
New Cast Syntax
C programmers are already familiar with the C style cast syntax: (Type)Expression // double d = (double) 5;
C++ introduced the functional style cast syntax Type(Expression) // double d = double(5);
In specific circumstances, casts are useful (and necessary) But "old" style casts convert everything in everything (compiler believes you) 4 new casts added to C++ to allow finer control over casting new syntax xxx_cast<type>(expr) is easier to locate for tools/programmer it is harder to type (many believe: a good thing) makes clear what kinds of casts are "meaningful" (useful)
Programming in C++
Page 478
Advanced C++
comst / volatile conversion const_cast
New Cast Syntax
allows only to change the "constness" (of pointer and references) in a conversion: void foo(double&); const double PI = 3.1415; foo(const_cast<double&>(PI)); int d = const_cast<int&>(PI); compiletime checked conversion static_cast allows to perform any conversion where there is an implicit conversion in the opposite direction (most frequent use of casts in C): int total = 500, days = 9; double rate = static_cast<double>(total) / days; enum color {red=0, green, blue}; int i = 2; color c = static_cast<color>(i); // c = blue; foo(static_cast<int>(PI));
Programming in C++
// OK // error: more than const!
// error: changes constness!

Page 479
Advanced C++
New Cast Syntax
run-time checked conversion dynamic_cast allows to perform safe casts down or across an inheritance hierarchy Failed casts return null pointer (when casting pointers) or exception (with references) base b, *pb; derived d, *pd; pb = &d; // ... later pd = dynamic_cast<derived *>(pb); // fine // non-null only if pb // really points to // derived object // error: no pointer!
d = dynamic_cast<derived>(b);
Programming in C++
Page 480
Advanced C++
unchecked conversion reinterpret_cast allows to perform any conversion result is nearly always implementation-defined non-portable! typedef void(*FuncPtr)(); FuncPtr funcPtrArray[10]; int doSomething();
New Cast Syntax
funcPtrArray[0] = reinterpret_cast<FuncPtr>(&doSomething); If your compiler doesnt support the new style casts yet, you can use the following approximation #define static_cast(TYPE,EXPR) #define reinterpret_cast(TYPE,EXPR) #define const_cast(TYPE,EXPR) (TYPE)(EXPR) (TYPE)(EXPR) (TYPE)(EXPR)
// doesnt tell you when the casts fails; use with care #define dynamic_cast(TYPE,EXPR) (TYPE)(EXPR)
Advanced C++
Runtime Type Identification (RTTI)
Current C++ class libraries often use their "home-brewed" dynamic type framework: if (shape_ptr->myType() == RectangleType) { Rectangle *rec_ptr = (Rectangle *)shape_ptr; // ... } Every major library came up with there own facility; therefore, a standardisation took place: if (Rectangle *rec_ptr = dynamic_cast<Rectangle *>(shape_ptr)) { // rec_ptr in scope and not null } // rec_ptr no longer in scope There is also a type enquiry operator typeid returning a reference to a type description object of type type_info (it can be compared and has a name) if (typeid(*shape_ptr) == typeid(Circle)) { // its a Circle pointer } const type_info& rt = typeid(*shape_ptr); cout << "shape_ptr is a pointer to " << rt.name() << endl;
Advanced C++
Recall operator[] from safeArray: #include <assert.h> #include "safearray.h"
Exception Handling
T& safeArray<T>::operator[](int index) { assert(index >= 0 && index < Array<T>::size()); return Array<T>::operator[](index); } Printing error message and exit is sometimes too drastic error codes / error return values not intuitive and error-prone sometimes error code cannot returned or error return value does not exist (see above) can be ignored by caller must be passed up calling hierarchy (in deeply nested function calls) could use setjmp / longjmp; fine for C, but dont call destructors of local objects Solution: use exception handling!
Advanced C++
Exception Handling consists of three parts: trying to execute possibly failing code throwing an exception in case of failure catching the exception and handling it (exception handler)
Exception Handling
try Block: try { // code from which exception may be thrown } Region of program from which control can be transferred directly to an exception handler elsewhere in program Transferring control from try block to exception handler is called "throwing an exception"
Programming in C++
Page 484
Advanced C++
catch Block: Syntax: try { // code from which exception may be thrown
Exception Handling
} catch ( exception-type-1 &e1 ) { // exception handling code for type 1 exceptions } catch ( exception-type-2 &e2 ) { // exception handling code for type 2 exceptions } Region of program that contains exception-handling code Each thrown exception has a type When exception is thrown, control transfers to first catch block in an (dynamically) enclosing block with matching type For efficiency, catch exceptions by reference avoids call to copy constructor of exception object avoids slicing (i.e. automatic conversion to base object) of exception object
Advanced C++
throw Statement: Syntax: throw exception-type;
Exception Handling
Causes immediate transfer of control to exception handler (catch block) of matching type Copy of exception object is thrown (automatically) Throwing an exception causes abnormal exit from a function Normal exit calls destructor for all local objects. For consistency, throwing an exception invokes destructors for all objects instantiated since entering try block Order of destructor invocation is reverse of order of object instantiation void foo (int i) { String s1 = "a string"; Complex c1(i,i); if (some_error) { throw SomeException; // destructor called for c1, then s1 } String s2 = "another string"; }
Advanced C++
Exception Handling
Default catch Blocks: Syntax: catch (...) { // exception handling code for default case } Matches all exception types Use at most one default catch block for each try block Default catch block (if any) should be the last catch block accompanying a given try block Good programming practice dictates that every try block should have a default catch block
Programming in C++
Page 487
Advanced C++
Re-throwing Exceptions:
Exception Handling
allows some exceptions to be handled locally, others to be handled by high-level general purpose exception handlers Re-throw current exception by placing throw statement with no type specifier: throw; Exception Hierarchies Exception types can be user-defined (class) types Exception hierarchy = hierarchy (build using C++ inheritance mechanism) of user-defined exception types Exception base class = "category" of exceptions Derived exception class = individual exception type catch block for base type catches all exceptions in category Example from Standard C++ Library: class runtime_error : public exception {}; class underflow_error : public runtime_error {}; class range_error : public runtime_error {};
Advanced C++
Standard exceptions thrown by the language: Name bad_alloc bad_cast bad_typeid bad_exception out_of_range invalid_argument overflow_error Thrown by new dynamic_cast typeid exception specification at bitset<>::operator[] bitset constructor bitset<>::to_ulong
Standard Exceptions
Standard exceptions hierarchy: exception runtime_error range_error overflow_error underflow_error logic_error length_error domain_error out_of_range invalid_argument bad_alloc bad_cast bad_exception bad_typeid ios_base::failure
ios_base::failure ios_base::clear
Standard exceptions do NOT include asynchronous events like UNIX signals (e.g., segmentation violation) or math library errors (e.g., overflow, div by zero)!
Programming in C++
Page 489
Advanced C++
Exception Specifications:
Advanced Exception Handling
allow to specify list of exceptions, functions might throw void f1() throw(E1, E2); void f2() throw(); void f3(); is checked at runtime unexpected() is called if exception specification doesnt hold which by default calls terminate() (can be changed with set_unexpected()) Function try blocks: allow to catch exceptions in a method body and its member initialization list derived::derived(int i) try : base(i) { // body ... } catch (...) { // exception handler for initializer list + body ... }
// f1 can throw E1 or E2 exceptions // f2 doesnt throw exceptions // exception spec for f3 unknown!
Advanved C++
Improved version of class safeArray: Exception defined in safearray.h: class InvalidIndex { public: InvalidIndex(int i) : idx(i) {} int invalid() { return idx; } private: int idx; };
Exception Handling Example
should actually be a subclass of exception, logic_error, or out_of_range should also be nested class inside safeArray New version of operator[]: T& safeArray<T>::operator[](int index) { if (index < 0 || index >= Array<T>::size()) throw InvalidIndex(index); return Array<T>::operator[](index); }
Advanved C++
Simple example for exception handling: #include <iostream> #include "safearray.h"
Exception Handling Example
void initialize (safeArray<int>& a, int val) { for (int i=0; i<=a.size(); ++i) a[i] = val; } int main(int, char**) { safeArray<int> a(10); try { initialize(a, 42); } catch (InvalidIndex& idx) { std::cerr << "Access to invalid index a[" << idx.invalid() << "]" << std::endl; } } making programs fool-proof with exceptions is still hard; not much experience for now For more details and guidelines see Stroustrup, 3rd. Edition or Meyers, More Effective C++
Advanced C++
Unnamed Namespaces
Compilation-unit local (file local) declarations possible through unnamed namespaces: namespace { int internal_version; void check_filebuf(); } is equivalent to namespace SpecialUniqueName { int internal_version; void check_filebuf(); } using namespace SpecialUniqueName; use unnamed namespaces instead of static declarations: // -- deprecated! static int internal_version; static void check_filebuf();
Programming in C++
Page 493
Advanced C++
A shorter alias for a long namespace name can also be defined, e.g., namespace Chrono = Chronological_Utilities; This allows you to mixnmatch libraries more easily: namespace lib = Modena; //namespace lib = RogueWave; //namespace lib = std; // never need to change this: lib::string my_name;
Namespaces
Namespaces are not yet supported by many current compilers. You can partition the global namespace now by using struct and using fully qualified names to access them struct MyNamespace { static const float version = 1.6; }; cout << "Version " << MyNamespace::version << endl; For convenience, you can provide typedefs, references, ... as short-cuts in a separate header file, so people without global namespace problems can use them in a "normal" way
Advanced C++
Advanced Templates
Templates have been extended by the standard committee in many ways. (beyond how they are described in most books) Template friend declarations and definitions are permitted in class definitions and class template definitions. Example: class definition that declares a template class Peer<T> as a friend: class Person { private: float my_money; template<class T> friend class Peer; }; Example: class template that declares a template class foo<T> as a friend: template <class T> class bar { T var; friend class foo<T>; };
Programming in C++
Page 495
Advanced C++
template<typename T> class List { /*...*/ }; It is also used for resolving ambiguities:
Advanced Templates
The new keyword typename can be used instead of class in template parameter lists
template<class T> class Problem { public: void ack() { typename T::A * B; // without typename, could be } // interpreted as multiplication }; // T::A * B; Templates and static members: template <class T> class X { static T s; }; template <class T> T X<T>::s = 0; If needed, specialization: template<> double X<double>::s = 1.0;
Advanced C++
Template as template arguments template<class T> class List; template<class T> class Vector;
Advanced Templates
template<class T, template<class U> class C = List> class Group { C<T> container; //... }; Group<int> Group<int, Vector> group_int_list; group_int_vector;
Explicit instantiation (currently highly unportable) template<typename T> class List { bool has(T&) { /* ... */ } }; template class List<int>; // request inst. of List for T=int template bool List<elem>::has(elem&); // inst. of member has
Advanced C++
Partial Specialization template<class U, class V> class relation; template<> class relation<int, int>; template<class T> class relation<T*, T*>; relation<char*, char*> r1; relation<int*, char*> r2;
Advanced Templates
#1 primary template #2 specialization #3 partial special.
# uses 3 # uses 1 (different pointer types!)
Note: function templates cannot be partial specialized, however similar results can sometimes be achieved with template function overloading Use of template to disambiguate template names (can only be necessary for calling member template functions inside other templates) class X { public: template<int Nt> X* alloc(); }; template<class T> void f(T* p) { T* p1 = p->alloc<200>(); // ERROR: < means less than T* p2 = p->template alloc<200>(); // OK }
Advanced C++
Advanced Templates
Current compilers typically only support the inclusion model for template usage Bodies of member functions of class templates function templates need to be included before they can be used Cannot be compiled away in separate template implementation file (e.g., .cpp) New keyword export to support the so-called separation model: // main.C: export template<typename T> T twice(T); int main() { int i = 2; int j = twice(i); } // template_implementation.cpp: export template<typename T> T twice(T t) { return t*t; }
// template decl only
Advanced C++
We know already static class member: Declaration: in class definition (in .h)
Class related constants
class Complex { .... static int num_numbers; ... }; Definition: needed elsewhere (in .C, not in .h) int Complex::num_numbers = 0; As the initialization occurs outside the class, this wouldnt allow class related constants Initialization is now allowed for integral static const data members Definition + Declarations now in class definition (in .h) class Data { static const int max_size = 256; // enum {max_size = 256}; // use this if above doesnt work char buffer[max_size]; }; Definition elsewhere (in .C) no longer needed
Programming in C++
Page 500
Advanced C++
Abstract and Concrete Constness
Abstract constness of data members (const to the user/client), also called: conceptual constness Concrete constness of a data member (const to the implementation), also: bitwise constness
Example: non-normalized Rational class class Rational { void reduce() const; ... private: mutable long num; mutable long den; }; void Rational::reduce() const { long g = gcd(num, den); num /= g; den /= g; } // allowed for constant numbers // because it doesnt change // "abstract" value
// ERROR without mutable // ERROR without mutable
Programming in C++
Page 501
Advanced C++
Problem: class Vector { public: Vector(int len); };
Non-converting Constructors
// constructs a Vector len elements long
void print(const vector& v); print(3); // creates temp Vector(3) and passes it to print! Obviously the constructors are needed but they are not always suitable as conversions as well Solution: mark constructor "non-converting" with explicit (disallows implicit conversions) class Vector { public: explicit Vector(int len); }; print(3); // now error! // OK // error!
Page 502
Vector v1(3), v2 = Vector(3); Vector v3 = 3;

Programming in C++
Advanced C++
Variables can be declared inside conditions (and for statements) if (int d = prim(345)) { i /= d; break; }
Miscellany
while (Word& w = readnext()) { process(w); }
You can now overload functions on enumeration types enum Status { OK, Busy, Stopped }; void process(Status s); void process(int n); // was error, now OK There are now separate versions of new and delete for array allocation for overloading class Foo { void* operator void operator void* operator void operator }; new(size_t); delete(void *); new[](size_t); delete[](void *); // already available // recently added to C++
pointer to extern "C" functions is now a different type than pointer to global C++ function
Advanced C++
Scope of declaration inside for loop changed now only valid inside loop body
Standard C++ Portability Notes
Template name lookup and template instantiation procedures changed new now throws bad_alloc exception when out of memory OLD: NEW1: #include <new> X *p=new(nothrow)X; if (p==NULL) { do_something(); } NEW2: #include <new> try { X *p=new X; } catch(bad_alloc &) { do_something(); }
X *p=new X; if (p==NULL) { do_something(); } . . . Good summary:
Jack W. Reeves (B)leading Edge: Moving to Standard C++ C++ Report, Jul/Aug 1997
Advanced C++
Standard C++ iostream Changes
Incompatibilities between Cfront's iostream and Standard iostream. Biggest changes are: The Standard C++ library puts most library identifiers in the namespace std, e.g., ostream is now std::ostream import identifiers using namespace declarations stream classes are now templates taking the character type as parameter typedef basic_istream<char,char_traits<char> > istream; Base class ios is split into character type dependent and independent portions ios::flags now are ios_base::flags Can now throw exceptions in addition to setting error flag bits Internationalization using locale Assignment and copying of streams is prohibited File descriptors (through member function fd()) are not supported any longer string based stringstream class replaces char* based strstream
Programming in C++
Page 505
Advanced C++
char *p = "a string"; String literals are now const char* Postfix operator++ on bool operand Dont use it static keyword to declare objects local to file scope Use unnamed namespace access declaration using declarations strstream class Use stringstream class Standard C Library headers use new C++ C Library headers
Deprecated Features
Page 506
Programming in C++
Object-Oriented Design
Programming in C++
Page 507
Ranking of software lifecycle activities 1.) Design 2.) Design 3.) Design 4.) Implementation
Motivation
"The time-consuming thing to learn about C++ is not syntax, but design concepts." [Stroustroup]
"If the design is right, the implementation is trivial. If you get stuck how to implement something, go back to design."
Programming in C++
Page 508
General Design Basics
The most important single aspect of software development is to be clear about what you are trying to build Successful software development is a long-term activity The systems we construct tend to be at the limit of complexity that we and our tools can handle There are no "cookbook" methods that can replace intelligence, experience, and good taste in design and programming Experimentation is essential for all nontrivial software development Design and programming are iterative activities The different phases of a software project, such as design, programming, and testing, cannot be strictly separated Programming and design cannot be considered without also considering the management of these activities
Object-Oriented Design Concrete
Domain Set Relationships Abstract

Application Domain
Entities
domain analysis
Types
domain analysis
Objects
In addition,
Classes
Solution Domain
type relationships can be modelled with inheritance (public or private) entity relationships can be modelled with object hierarchies
Programming in C++
Page 510
Identify the entities in your application domain resources, events, (hardware) parts, software interfaces, concepts, ... Identify the behaviours of the entities services, tasks, functionality, responsibilities, ... Identify relationships/dependencies between entities is-a, is-kind-of, is-like, has-a, is-part-of, uses-a, creates-a, ...
Activities
Broaden Design (Guideline: should be implementable in at least 2 different ways) to be able to reuse later (design + source code!) helps the system evolve / maintain to be sure the implementation can fulfil its requirements Create a C++ design structure from the entities define classes (and their interfaces!), objects, inheritance and object hierarchy, ... Implement, Fine-Tune, Test, Maintain Note: this is not a sequential process rather than a back-and-forth or cyclic one
Summary: Say what you mean understand what you are saying
Translation to C++
A common base class means common characteristics Public inheritance means is-a or is-kind-of class derived : public base { /* ... */ }; every object of type derived is also an object of type base, but not vice-versa! Liskov substitution principle: can every usage of an object of type base be replaced by an object of class derived? additional functionality and/or data makes good subclass! Dont mistake is-like-a for is-a ! find higher abstraction, make parent: e.g. set is-like-a list, derive from collection
Private inheritance means is-implemented-in-terms-of class derived : private base { /* ... */ }; implementation issue; no design-level conceptional relationship
Translation to C++
use only if access to protected members needed or to redefine virtual functions, otherwise use layering Layering (nested classes) means has-a, is-part-of, or is-implemented-in-terms-of between classes class Inner { /* ... */ }; class Outer { Inner I; /* ... */ }; Class member(s) means has-a, is-part-of, or is-implemented-in-terms-of between objects class foo { /* ... */ }; class bar1 { foo I; /* ... */ }; class barN { foo *I; /* ... */ }; Member function(s) that take parameter of another class means uses-a foo::func(const bar& b) { /* ... */ }
// 1-to-1 mapping // 1-to-n mapping
General Principles
The Open/Closed Principle (Bertrand Meyer): Software entities (classes, modules, etc) should be open for extension, but closed for modification. New features can be added by adding new code rather than by changing working code Thus, the working code is not exposed to breakage The Liskov Substitution Principle: Derived classes must be usable through the base class interface without the need for the user to know the difference. Principle of Dependency Inversion: Details should depend upon abstractions. Abstractions should not depend upon details. All high level functions and data structures should be utterly independent of low level functions and data structures. Dependencies in the design must run in the direction of stability. The dependee must be more stable than the depender. (stability := probable change rate) The more stable a class hierarchy is, the more it must consist of abstract classes. A completely stable hierarchy should consist of nothing but abstract classes. Executable code changes more often than the interfaces
Some more Guidelines
Use classes to represent concepts Keep things as private as possible Once you publicize an aspect of your library (method, class, field), you can never take it out Watch out for the "giant object syndrome" Objects represent concepts in your application, not the application itself! Dont add features "just in case" If you must do something ugly, at least localize the ugliness inside a class Dont try technological fixes for sociological problems
Programming in C++
Page 515
How should objects be created and destroyed? (constructors, destructor, class specific new/delete)
Class Design == Type Design
How does object initialization differ from assignment? (constructors, operator=()) What does it mean to pass objects of new type by value? (copy constructor) What are the constraints on legal values for the new type? (error checking in constructors and operator=()) Does the new type fit into an inheritance graph? (virtuality of functions, ...) What kind of conversions are allowed? (constructors, conversion operators) What operators and functions make sense for the new type? (public interface) Strive for class interfaces that are complete and minimal What standard operators and functions should be explicitly disallowed? (declare private) Who should have access to the members of the new type? (access modes, friends) How general is the new type? (class template?) Goal: user-defined classes should be indistinguishable from built-in types!
Object-Oriented Design (both books use C++ for examples) Booch, Object-Oriented Analysis and Design with Applications, Second Edition, Benjamin/Cummings Publishing, 1994, ISBN 0-8053-5340-2. Budd, Introduction to Object Oriented Programming, Second Edition, Addison-Wesley, 1996, ISBN 0-201-82419-1. Aspects of Object-Oriented Design in C++ Gamma, Helm, Johnson, and Vlissides, Design Patterns: Elements of Reusable Object-Oriented Software, Addison-Wesley, 1995, ISBN 0-201-63361-2. Provides an overview of the ideas behind patterns and a catalogue of 23 fundamental patterns Carroll and Ellis, Designing and Coding Reusable C++, Addison-Wesley, 1995, ISBN 0-201-51284-X. Discusses many practical aspects of library design and implementation
Books
But remember: Design and programming, like bicycle or swiming, cannot be learned by reading books!
Programming in C++
Page 518
Programming in C++
class std::string
Programming in C++
Page 519
std::string
Standard string class is actually namespace std { template < class charT, class traits = string_char_traits<charT>, class Allocator = allocator> class basic_string { public: static const unsigned npos = -1; /* ... */ }; typedef basic_string<char> string; typedef basic_string<wchar_t> wstring; } To keep description of std::string simple in the following pages string is used instead of std::basic_string<char> traits and Allocator objects are ignored
Overview
string := sequence of characters := objects of type charT (including e.g., \0)
Page 520
std::string
Positions in a string of n characters are specified as an object of type size_t (typically unsigned int) in the range 0 (first character) to n-1 (last character)
Definitions
Substrings are specified by the start position pos and the number of characters len length of substring is determined by the minimum of len and size()-pos there is no separate substring class in the standard (but it is easy to define one) The string local special constant npos can be used to specify the length all the remaining characters is used by the search algorithms to indicate the result not found Member functions of string throw an exception out_of_range if a specified pos is not in the range 0 to n-1 length_error if a specified len would construct a string larger than the maximal possible length
std::string
Object definitions for all examples in the std::string chapter: #include <string> using namespace std;
Example Definitions
const string str0 = "***"; const string str1 = "0123456789"; string str2 = str1; string str3 = "345"; const char *cstr0 = "***"; const char *cstr1 = "abcdefghij"; char cstr2[16]; const char *cstr3 = "345";
Programming in C++
Page 522
std::string
Member Function Argument Categories
Arguments to string member functions fall into the following categories: 1.) an object of class string or a substring of it (... const string& str, size_t pos=0, size_t len=npos ...) Examples: str1 str1, 6 str1, 3, 4 str1, 3, 20 // // // // => => => => "0123456789" "6789" "3456" "3456789"
2.) a C/C++ built-in string (zero-terminated array of char) or the first len characters of it (... const char* s, size_t len=npos ...) Examples: cstr1 cstr1, 5 "*****" "*****", 3
// // // //
=> => => =>
"abcdefghij" "abcde" "*****" "***"

Page 523
std::string
3.) a repetition of len characters c
Member Function Argument Categories
(.... size_t len, char c ...) Examples: 5, * 2, a 4.) a (sub)string object specified by an iterator range (.... InputIterator first, InputIterator last ...) Examples: str1.begin(), str1.end() str1.begin()+2, str1.end()-2 str1.rbegin(), str1.rend() // => "0123456789" // => "234567" // => "9876543210" // => "*****" // => "aa"
Programming in C++
Page 524
std::string
Constructors
Constructors/Destructor
explicit string(); string(const string& str, size_t pos = 0, size_t len = npos); string(const char* s, size_t len); string(const char* s); string(size_t len, char c); template<class InputIterator> string(InputIterator begin, InputIterator end); Destructor ~string(); Examples string string string string string string
Programming in C++
s1; // => "" s2(str1, 3, 3); // => "345" s3(cstr1, 3); // => "abc" s4(3, '*'); // => "***" s5(str1.begin(), str1.end()); s6(str1.rbegin(), str1.rend());
// => "0123456789" // => "9876543210"

Page 525
std::string
Assignment operator with value semantics (i.e., conceptional deep copy) string& operator=(const string& str); string& operator=(const char* s); string& operator=(char c); Member function assign: modifies and returns this string& string& string& string& string&
Assignment
assign(const string&); assign(const string& str, size_t pos, size_t len); assign(const char* s, size_t len); assign(const char* s); assign(size_t len, char c);
template<class InputIterator> string& assign(InputIterator first, InputIterator last); Examples str2.assign(str1, 3, 3) // => "345" str2.assign(cstr1, 3) // => "abc" str2.assign(3, '*') // => "***" str2.assign(str1.begin(), str1.end()) // => "0123456789"
std::string
Iterators
string provides member types and operations similar to those provided by STL containers all STL algorithms can be applied to string but only few are useful as string often provides more optimized versions directly examples of useful ones are comparison or searches based on user-defined predicates Most useful are the usual iterators pointing to the first and one-after-the-last position string iterators are random access iterators iterator begin(); const_iterator begin() const; iterator end(); const_iterator end() const; reverse_iterator rbegin(); const_reverse_iterator rbegin() const; reverse_iterator rend(); const_reverse_iterator rend() const;
Programming in C++
Page 527
std::string
Like STLs vector<T>, strings have a length := number of characters stored in string capacity := number of characters which could be stored in string without new memory allocation
Capacity
Length related member functions size_t size() const; size_t length() const; size_t max_size() const; bool empty() const; Capacity related member functions size_t capacity() const; // returns capacity // returns length // same as size() // maximal possible length // size() == 0?
void resize(size_t len, char c = \0); // shrink or enlarge capacity to len // new characters are initialized with c void reserve(size_t len = 0); // inform string that at least len // characters are needed, change // capacity as needed
Page 528
Programming in C++
std::string
Individual characters of a string can be accessed through subscripting. It comes in two forms: with and without range check
Element Access
The result of using operator[](pos) is undefined if pos >= size() const_reference operator[](size_t pos) const; reference operator[](size_t pos); Member function at(pos) throws out_of_range if pos >= size() const_reference at(size_t pos) const; reference at(size_t pos); Otherwise, both return the character at position pos To access last character of a string str use str[str.size()-1] Examples: str1[5] str1.at(5) str1[42] str1.at(42)
Programming in C++
// => 5 // => 5 // => undefined // => throws out_of_range

std::string
Strings can be compared to (sub)strings or (sub)arrays of characters If pos1 and len1 are specified only this part of the string is compared Returns 0 if the (sub)strings are equal
Comparisons
a negative number if the string is lexicographically before the argument character object a positive number otherwise int compare(const string& str) const; int compare(size_t pos1, size_t len1, const string& str) const; int compare(size_t pos1, size_t len1, const string& str, size_t pos2, size_t len2) const; int compare(const char* s) const; int compare(size_t pos1, size_t len1, const char* s, size_t len2 = npos) const; Examples str1.compare(str1) str1.compare(3, 3, str1)
Programming in C++
// => 0 // => >0

std::string
Modifiers: append
Member function append allows adding characters described by the arguments to the end (short-cut for insert at the end of the string) append modifies the string itself (*this) and returns the modified string string& string& string& string& string& append(const string& str); append(const string& str, size_t pos, size_t len); append(const char* s, size_t len); append(const char* s); append(size_t len, char c);
template<class InputIterator> string& append(InputIterator first, InputIterator last); operator+= and push_back are provided as a conventional notation for the most common forms of append string& operator+=(const string& str); string& operator+=(const char* s); string& operator+=(char c); void push_back(const char);
std::string
Examples str2.append(str1) str2.append(str1, 3, 3) str2.append(cstr1, 3) str2.append(cstr1) str2.append(3, '*')
Examples: append
// => "01234567890123456789" // => "0123456789345" // => "0123456789abc" // => "0123456789abcdefghij" // => "0123456789***"
str2.append(str1.rbegin(), str1.rend()) // => "01234567899876543210" str2 += str1 str2 += cstr1 str2 += '*' str2.push_back(*) // => "01234567890123456789" // => "0123456789abcdefghij" // => "0123456789*" // => "0123456789*"
Programming in C++
Page 532
std::string
Modifiers: insert
Member function insert allows adding characters described by the arguments to the string characters can either be inserted before the index position pos modifies the string itself (*this) and returns the modified string string& insert(size_t pos, const string& str); string& insert(size_t pos, const string& str, size_t pos2, size_t len); string& insert(size_t pos, const char* s, size_t len); string& insert(size_t pos, const char* s); string& insert(size_t pos, size_t len, char c); before the position described by iterator into the same string p iterator insert(iterator p, char c); void insert(iterator p, size_t len, char c); template<class InputIterator> void insert(iterator p, InputIterator first, InputIterator last);
std::string
Examples str2.insert(3, str0) str2.insert(3, str0, 1, 1) str2.insert(3, cstr0, 1) str2.insert(3, cstr0) str2.insert(3, 3, '*')
Examples: insert
// => "012***3456789" // => "012*3456789" // => "012*3456789" // => "012***3456789" // => "012***3456789" // => "*0123456789" // => "***0123456789"
str2.insert(str2.begin(), '*') str2.insert(str2.begin(), 3, '*')
str2.insert(str2.begin(), str1.rbegin(), str1.rend()) // => "98765432100123456789"
Programming in C++
Page 534
std::string
Modifiers: erase
Member function erase deletes a range of characters described by the arguments from the string Delete a range of characters described by a start position pos and a length len string& erase(size_t pos = 0, size_t len = npos); Delete the single character specified by iterator position or delete a range of characters described by iterator pair first and last Returns an iterator pointing to the element immediately following the element(s) being erased iterator erase(iterator position); iterator erase(iterator first, iterator last); void clear(); // == erase(begin(), end()) Examples str2.erase(3, 3) str2.erase(3) str2.erase(str2.begin()) // => "0126789" // => "012" // => "123456789" // => "" // => "" // => ""
Page 535
str2.erase(str2.begin(), str2.end()) str2.clear() str2.erase()

std::string
Modifiers: replace
Member function replace allows changing a range of characters to other characters described by the arguments replace := assignment to a substring replace modifies the string itself (*this) and returns the modified string The range of characters to replace can be described by a start position pos1 and the length len1 string& replace(size_t pos1, size_t len1, const string& str); string& replace(size_t pos1, size_t len1, const string& str, size_t pos2, size_t len2); string& replace(size_t pos, size_t len1, const char* s, size_t len2); string& replace(size_t pos, size_t len1, const char* s); string& replace(size_t pos, size_t len1, size_t len2, char c); or
Programming in C++
Page 536
std::string
a pair of iterators i1 and i2 i1 and i2 must be valid iterators into the string (*this)
Modifiers: replace
string& replace(iterator i1, iterator i2, const string& str); string& replace(iterator i1, iterator i2, const char* s, size_t len); string& replace(iterator i1, iterator i2, const char* s); string& replace(iterator i1, iterator i2, size_t len, char c); template<class InputIterator> string& replace(iterator i1, iterator i2, InputIterator j1, InputIterator j2);
Programming in C++
Page 537
std::string
Examples str2.replace(3, 3, str0) str2.replace(3, 3, str0, 1, 1) str2.replace(3, 3, cstr0, 1) str2.replace(3, 3, cstr0) str2.replace(3, 3, 3, '*')
Examples: replace
// => "012***6789" // => "012*6789" // => "012*6789" // => "012***6789" // => "012***6789" // => "***" // => "*" // => "***" // => "***"
str2.replace(str2.begin(), str2.end(), str0) str2.replace(str2.begin(), str2.end(), cstr0, 1) str2.replace(str2.begin(), str2.end(), cstr0) str2.replace(str2.begin(), str2.end(), 3, '*')
str2.replace(str2.begin(), str2.end(), str0.begin(), str0.end()) // => "***"
Programming in C++
Page 538
std::string
Conversion to C/C++ style string
Miscellaneous
returns pointer to string owned character array containing copy of string const char* data() const; the same thing but \0 terminated const char* c_str() const; copy (parts of) string into user-supplied buffer (note: not \0-terminated!) size_t copy(char* s, size_t len, size_t pos = 0) const; Exchange the contents of two strings void swap(string&); Select substring (len characters starting from position pos) string substr(size_t pos = 0, size_t len = npos) const; Examples int i = str1.copy(cstr2, 3, 3); cstr2[i] = '\0' // cstr2="345" str2.swap(str3) // => str2="345" str3="0123456789" str1.substr(3, 3) // => "345"
std::string
size_t size_t size_t size_t
Search: find/rfind
Find substring described by arguments in string starting at position pos find(const string& str, size_t pos = 0) const; find(const char* s, size_t pos, size_t len) const; find(const char* s, size_t pos = 0) const; find(char c, size_t pos = 0) const; /*X*/
Find substring described by arguments in string searching backwards from pos size_t size_t size_t size_t rfind(const string& str, size_t pos = npos) const; rfind(const char* s, size_t pos, size_t len) const; rfind(const char* s, size_t pos = npos) const; rfind(char c, size_t pos = npos) const; /*X*/
Note: in forms marked /*X*/ len characters of s are searched from position pos in *this Both return start position of substring in string, or string::npos if not found Examples str1.find(str3, 0) str1.find(cstr1, 0) str1.rfind(str3) str1.rfind('3', string::npos)
Programming in C++
// // // //
=> => => =>
3 string::npos 3 3
Page 540
std::string
Search: find_first/last_of
Find first/last character out of character set described by arguments in string forward/backward from position pos size_t find_first_of(const string& str, size_t pos = 0) const; size_t find_first_of(const char* s, size_t pos, size_t len) const; size_t find_first_of(const char* s, size_t pos = 0) const; size_t find_first_of(char c, size_t pos = 0) const; size_t size_t size_t size_t find_last_of(const string& str, size_t pos = npos) const; find_last_of(const char* s, size_t pos, size_t len) const; find_last_of(const char* s, size_t pos = npos) const; find_last_of(char c, size_t pos = npos) const;
Both return start position of character in string, or string::npos if not found Examples str1.find_first_of(str3, 0) // str1.find_first_of(cstr3, 0, 3) // str1.find_last_of(cstr3, string::npos) str1.find_last_of('3', string::npos)
=> => // //
3 3 => 5 => 3
Page 541
std::string
Search: find_first/last_not_of
Find first/last character not in character set described by arguments in string forward/backward from position pos size_t find_first_not_of(const string& str, size_t pos = 0) const; size_t find_first_not_of(const char* s, size_t pos, size_t len) const; size_t find_first_not_of(const char* s, size_t pos = 0) const; size_t find_first_not_of(char c, size_t pos = 0) const; size_t find_last_not_of(const string& str, size_t pos = npos) const; size_t find_last_not_of(const char* s, size_t pos, size_t len) const; size_t find_last_not_of(const char* s, size_t pos = npos) const; size_t find_last_not_of(char c, size_t pos = npos) const; Both return start position of character in string, or string::npos if not found Examples str1.find_first_not_of(cstr3, 0) str1.find_last_not_of(str3, string::npos)
// => 0 // => 9
Page 542
std::string
Global Functions: Concatenation
Concatenation is implemented as global function operator+ to allow non-string arguments (character arrays and single chars) on left side of operator to avoid creation of temporary string objects resulting from automatic conversion string string string string string Examples str1 + str1 cstr1 + str1 '*' + str1 str1 + cstr1 str1 + '*'
Programming in C++
operator+(const string& lhs, operator+(const char* lhs, operator+(char lhs, operator+(const string& lhs, operator+(const string& lhs,
const string& rhs); const string& rhs); const string& rhs); const char* rhs); char rhs);
// => "01234567890123456789" // => "abcdefghij0123456789" // => "*0123456789" // => "0123456789abcdefghij" // => "0123456789*"
std::string
Global Functions: Equality
The equality operators operator== and operator!= are also implemented as global functions for the same reasons bool operator==(const string& lhs, const string& rhs); bool operator==(const char* lhs, const string& rhs); bool operator==(const string& lhs, const char* rhs); bool operator!=(const string& lhs, const string& rhs); bool operator!=(const char* lhs, const string& rhs); bool operator!=(const string& lhs, const char* rhs); Examples str1 == str1 cstr1 == str1 str1 == cstr1 str1 != str1 cstr1 != str1 str1 != cstr1 // => true // => false // => false // => false // => true // => true
Programming in C++
Page 544
std::string
So are the rest of the comparison operators
Global Functions: Comparison
bool operator< (const string& lhs, const string& rhs); bool operator< (const string& lhs, const char* rhs); bool operator< (const char* lhs, const string& rhs); bool operator> (const string& lhs, const string& rhs); bool operator> (const string& lhs, const char* rhs); bool operator> (const char* lhs, const string& rhs); bool operator<=(const string& lhs, const string& rhs); bool operator<=(const string& lhs, const char* rhs); bool operator<=(const char* lhs, const string& rhs); bool operator>=(const string& lhs, const string& rhs); bool operator>=(const string& lhs, const char* rhs); bool operator>=(const char* lhs, const string& rhs); Examples str1 >= str1 cstr1 > str1 cstr1 < str1
Programming in C++
// => true // => true // => false

std::string
string is expanded as needed to hold the word
Global Functions: I/O and swap
operator>> reads a whitespace-terminated word initial and terminating whitespace is not entered into the string istream& operator>>(istream& is, string& str); operator<< writes string contents to an output stream ostream& operator<<(ostream& os, const string& str); getline reads a line terminated by delim into str string str is expanded as needed to hold the line delimiter delim is not entered into the string istream& getline(istream& is, string& str, char delim = \n); Exchange the contents of the strings lhs and rhs void swap(string& lhs, string& rhs);
Programming in C++
Page 546
Programming in C++
English German Dictionary
Programming in C++
Page i
Programming in C++
abstract base class abstract/concrete constness access specifier aligment arithmetic types array automatic object assignment associativity basic types base class catch block cast character class comment compound statement conditional compilation
Programming in C++

abstrakte Basisklasse abstrakte(logische)/tatschliche Unvernderbarkeit Zugriffsspezifikation (Speicher)Ausrichtung arithmetische Typen Feld automatisches Objekt Zuweisung Assoziativitt elementare Typen, grundlegende Typen Basisklasse Ausnahmebehandlungsblock cast, explizite Typ(en)konversion/Typ(en)umwandlung Textzeichen Klasse Kommentar (Anweisungs)Block, Anweisungsfolge, zusammengesetzte Anweisung bedingte bersetzung
Dr. Bernd Mohr, FZ Jlich, ZAM Page ii
Programming in C++
constructor control flow conversion (operator) diasy-chaining data hiding data member declaration definition default parameter derived class derived types destructor do until loop dynamic binding encapsulation enumeration exception handling expression
Programming in C++

Konstruktor Steuerflu (Typ)Umwandlungsoperator aneinanderreihen, verketten, kaskadieren Geheimnisprinzip Datenelement Deklaration Definition Standardparameter(wert), vorbelegte Parameter Parameterwertvorgabe abgeleitete Klasse abgeleitete Typen Destruktor Durchlaufschleife dynamische Bindung Kapselung Aufzhlung Ausnahme(fall)behandlung Ausdruck
Dr. Bernd Mohr, FZ Jlich, ZAM Page iii
Programming in C++
floating-point for loop function body function call function head global header file heap hide identifier include directive indirection inheritance inline integer integral promotion integral types iteration
Programming in C++

Fliesskomma Zhlschleife Funktionsrumpf Funktionsaufruf Funktionskopf global Schnittstellendatei dynamischer Speicher, Freispeicher berdecken, verdecken Bezeichner Dateieinfgeanweisung Dereferenzierung Vererbung inline ganzzahlig integrale Promotion integrale Typen Schleife
Dr. Bernd Mohr, FZ Jlich, ZAM Page iv
Programming in C++
jump statement keyword label labeled statement literal member function member template memory allocation memory deallocation memory management multiple Inheritance namespace nested classes operator operator delete operator new overloading runtime type identification (RTTI)
Programming in C++

Sprunganweisung Schlsselwort, reservierter Bezeichner Sprungmarke benannte Anweisung Literal (auch "Konstante") Elementfunktion, Methode Elementschablone Speicheranforderung Speicherfreigabe Speicherverwaltung Mehrfachvererbung, mehrfache Vererbung Namensraum, Namensbereich (ein)geschachtelte Klassen Operator Lschoperator, Speicherfreigabe Erzeugungsoperator, Speicherbelegung berladen Typermittlung zur Laufzeit, Laufzeit-Typinformation
Dr. Bernd Mohr, FZ Jlich, ZAM Page v
Programming in C++
placement pointer polymorphism precedence preprocessor directives private member protected member public member pure virtual qualified name recursive reference relational operator return type scope signed stack statement static binding
Programming in C++

Plazierung Zeiger Polymorphie Prioritt Prprozessordirektiven privates Element geschtztes Element ffentliches Element rein virtuell, abstrakt qualifizierter Bezeichner / Name rekursiv Verweis / Referenz Vergleichsoperator Funktionswerttyp Gltigkeitsbereich, Bezugsrahmen vorzeichenbehaftet Stapel Anweisung statische Bindung
Dr. Bernd Mohr, FZ Jlich, ZAM Page vi
Programming in C++
static member static object storage class struct template throw exception unsigned union virtual function while loop

Klassenmethode, Klassenvariable, objektloses Element statisches Objekt Speicherklasse Struktur, Verbund, Rekord Schablone, generische / parametrisierte Klasse, Musterklasse Ausnahmebehandlungs(code) anstossen, Ausnahme auswerfen vorzeichenlos varianter Rekord virtuelle Funktion Abweisungsschleife
Programming in C++
Page vii
Programming in C++
Page viii
Programming in C++
Index
Programming in C++
Page ix
Symbols
/*...*/ // . . . .
............................ ............................
56 56
A
abstract base classes . . . . . . . abstract constness . . . . . . . . abstraction . . . . . . . . . . . . access member functions . . . . accumulate() . . . . . . . . adjacent_difference() adjacent_find() . . . . . advance() . . . . . . . . . . . allocate() . . . . . . . . . . Allocator . . . . . . . . . . . alternative tokens . . . . . . . . app . . . . . . . . . . . . . . . . arguments default . . . . . . . . . . . . reference . . . . . . . . . . Array . . . . . . . . . . . . . . . arrays . . . . . . . . . . . . . . . and pointers . . . . . . . . concrete or interfaced . . C-style . . . . . . . . . . . . Fortran . . . . . . . . . . . multi-dimensional . . . . .
Programming in C++
. . . . . . . . . . . . . . . 310 . . . . . . . . . . . . . . . 501 . . . . . . . . . . . . . . . 297 . . . . . . . . . . . . 97, 117 . . . . . . . . . . . . . . . 436 . . . . . . . . . . . . . . . 436 . . . . . . . . . . . . . . . 423 . . . . . . . . . . . . . . . 455 . . . . . . . . . . . . . . . 353 . . . . . . . . . . . . . . . 350 . . . . . . . . . . . . . . . 55 . . . . . . . . . . . . . . . 242 . . . . . . . . . . . . . . . 59 . . . . . . . . . . . . 63, 156 . . . . . . . . . . . . . . . 279 . . . . . . . . . . . . . . . 21 . . . . . . . . . . . . . . . 25 . . . . . . . . . . . . . . . 340 . . . . . . . . . . . . . . . 21 . . . . . . . . . . . . 337, 342 . . . . . . . . . . . . 340, 342
redesign . . . . . . rigid or formed . storage layout . . subarray selection assign() . . . . . . . assignment classes . . . . . . . self-test . . . . . . ate . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . 262 . . . . . . . . . . . . . . . . . . . . 340 . . . . . . . . . . . . . . . . . . . . 337 . . . . . . . . . . . . . . . . . 338, 339 . . . . . . . . . . . . . . . . . . . . 393 . . . . . . . . . . . 99, 118, 121, 122 . . . . . . . . . . . . . . . . . 100, 330 . . . . . . . . . . . . . . . . . . . . 242
B
back() . . . . . . . . back_inserter() bad() . . . . . . . . base classes . . . . . . basic data types . . . basic_string . . begin() . . . . . . . bernoulli numbers . . binary . . . . . . . . binary I/O . . . . . . . binary_search() bind1st() . . . . . bind2nd() . . . . . binding dynamic . . . . . static . . . . . . . bitset . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . 394 . . . . . . . . . . . . . . 426, 455, 457 . . . . . . . . . . . . . . . . . . . . . 259 . . . . . . . . . . . . . . . . . . . . . 297 . . . . . . . . . . . . . . . . . . . . . 17 . . . . . . . . . . . . . . . . . . . . . 371 . . . . . . . . . . . . . . . . . . . . . 386 . . . . . . . . . . . . . . . . . . . . . 221 . . . . . . . . . . . . . . . . . . . . . 242 . . . . . . . . . . . . . . . . . . . . . 254 . . . . . . . . . . . . . . . . . . . . 433 . . . . . . . . . . . . . . . . . . . . . 448 . . . . . . . . . . . . . . . . . . . . . 448 . . . . . . . . . . . . . . . . . . . . . 308 . . . . . . . . . . . . . . . . . . . . . 307 . . . . . . . . . . . . . . . 375, 382, 446
Page x
body class . . books . . . . bool . . . . boolalpha boolean type break . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . 225 . . . . . . . . . . . . . . . 5, 6, 7, 260, 470, 517 . . . . . . . . . . . . . . . . . . . . . . . . . . 69 . . . . . . . . . . . . . . . . . . . . . . . 246, 249 . . . . . . . . . . . . . . . . . . . . . . . . . . 69 . . . . . . . . . . . . . . . . . . . . . . . . . . 32
C
capacity() . . . . . . . . . . . . . . . . . . . . . . . . . casts . . . . . . . . . . . . . . . . . . . . . . 478, 479, 480, catch . . . . . . . . . . . . . . . . . . . . . . . . . . . 485, cerr . . . . . . . . . . . . . . . . . . . . . . . . . . . 233, chained expression objects . . . . . . . . . . . . . . . . . . character strings . . . . . . . . . . . . . . . . . . . . . . . . cin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . class templates . . . . . . . . . . . . . . . . . . . 278, 282, classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . abstract base classes . . . . . . . . . . . . . . . . . . access member functions . . . . . . . . . . . . . . . access specifiers . . . . . . . . . . . . . . . . . . . . . arrays of class objects . . . . . . . . . . . . . . . . . assignment . . . 99, 118, 121, 228, 271, 346, 358, base . . . . . . . . . . . . . . . . . . . . . . . . . . . . class members . . . . . . . . . . . . . . . . . . . . . . concatenation operator . . . . . . . . . . . 125, 151, concept . . . . . . . . . . . . . . . . . . . . . . . . . . constructor member initialization lists . . . . . . . constructors . . . . . . . . . . . . . . . . . . . . . . .
Programming in C++
442 481 487 234 365 107 236 283 510 310 97 88 138 364 297 475 230 89 158 90
conversions . . . . . . . . . default member functions derived . . . . . . . . . . . design . . . . . . . . . . . . destructor . . . . . . . . . . equality test operator . . . file organisation . . . . . . introduction . . . . . . . . life of an object . . . . . . literals . . . . . . . . . . . . modify member functions nested . . . . . . . . . . . . pointer data members . . . pointer to class objects . . static data members . . . . static member functions . virtual base classes . . . . clear() . . . . . . . . . . . . . clog . . . . . . . . . . . . . . . close() . . . . . . . . . . . . . command line arguments . . . comments . . . . . . . . . . . . . compiler . . . . . . . . . . . . . . Complex . . . . . . . . . . . . . complex . . . . . . . . . . . . . concept . . . . . . . . . . . . . . concrete constness . . . . . . . . concrete data types . . . . . . . const . . . . . . . . . . . . . .
. . . . . . . . . . . . 153, 154 . . . . . . . . . . . . . . . 157 . . . . . . . . . . . . . . . 297 . . . . . . . . . . . . . . . 516 . . . . . . . . . . . . . . . 95 . . . . . . . . . . . . 102, 124 . . . . . . . . . . . . . . . 164 . . . . . . . . . . . . . . . 84 . . . . . . . . . . . . . . . 86 . . . . . . . . . . . . . . . 137 . . . . . . . . . . . . . . . 98 . . . . . . . . . 476, 477, 513 . . . . . . . . . . . . . . . 106 . . . . . . . . . . . . . . . 137 . . . . . . . . . . . . . . . 160 . . . . . . . . . . . . . . . 161 . . . . . . . . . . . . . . . 329 . . . . . . . . . . . . 392, 409 . . . . . . . . . . . . 233, 234 . . . . . . . . . . . . . . . 244 . . . . . . . . . . . . . . . 34 . . . . . . . . . . . . . . . 56 . . . . . . . . . . . . . . . 10 . . . . . . . . . . . . 88, 104 . . . . . . . . . . . . 370, 371 . . . . . . . . . . . . 374, 379 . . . . . . . . . . . . . . . 501 . . . . . . . . . . . . . . . 85 . 19, 75, 133, 134, 500, 501
Page xi
const_cast . . . . . . . . . . . . . . . . . . . . . . . . . constant member functions . . . . . . . . . . . . . . 133, constants . . . . . . . . . . . . . . . . . . . . . . . . . . . . class related . . . . . . . . . . . . . . . . . . . . . . . declaration . . . . . . . . . . . . . . . . . . . . . . . . constructor . . . . . . . . . 90, 116, 269, 304, 357, 360, and freestore . . . . . . . . . . . . . . . . . . . . . . . and inheritance . . . . . . . . . . . . . . . . . . . . . . conversion . . . . . . . . . . . . . . . . . . . . . 92, copy . . . . . . . . . . 94, 101, 114, 269, 346, 357, default . . . . . . . . . . . . . . . . . . . . . 91, 113, member initialization lists . . . . . . . . . . . . 158, non-converting . . . . . . . . . . . . . . . . . . . . . . std::string . . . . . . . . . . . . . . . . . . . . . STL . . . . . . . . . . . . . . . . . . . . . . . . . . . . container types . . . . . . . . . . . . . . . . . . . . . . . . . containers see STL containers continue . . . . . . . . . . . . . . . . . . . . . . . . . . . controlled exit iteration . . . . . . . . . . . . . . . . . . . . conversions . . . . . . . . . . . . . . . . . . . . . 153, 154, copy assignment operator . . . . . . . . . . . . . . . . . . copy constructor . . . . . . 94, 101, 114, 269, 346, 357, copy() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . copy_backward() . . . . . . . . . . . . . . . . . . . . copy-on-write . . . . . . . . . . . . . . . . . . . . . . . . . count() . . . . . . . . . . . . . . . . . . . . . . . . . 407, count_if() . . . . . . . . . . . . . . . . . . . . . . . . . cout . . . . . . . . . . . . . . . . . . . . . . . . . . . 233,
479 134 75 500 19 362 155 303 153 363 205 304 502 525 385 282 32 32 306 122 363 426 426 355 424 424 234
D
data hiding . . . . . . . data members . . . . . const . . . . . . . . mutable . . . . . . static . . . . . . . . data types basic . . . . . . . . deallocate() . . . dec . . . . . . . . . . . declaration . . . . . . . declarations . . . . . . . default arguments . . . default constructor . . definition . . . . . . . . delete . . . . . . . . . overloading . . . . deque . . . . . . . . . derived class templates derived classes . . . . . destructor . . . . . . . . and freestore . . . and inheritance . STL . . . . . . . . distance() . . . . . divides . . . . . . . . do . . . . . . . . . . . . domains . . . . . . . . .
.................... .................... .................... .................... ....................
49 84 501 501 160
. . . . . . . . . . . . . . . . . . . . 17 . . . . . . . . . . . . . . . . . . . . 354 . . . . . . . . . . . . . . . . . 246, 249 . . . . . . . . . . . . . . . . . . . . 172 . . . . . . . . . . . . . . . . . . 19, 58 . . . . . . . . . . . . . . . . . . . . 59 . . . . . . . . . . . . . . 91, 113, 205 . . . . . . . . . . . . . . . . . . . . 172 . . . . . . . . . . . . . . 72, 155, 168 . . . . . . . . . . . . . . . . . . . . 169 . . . . . . . . 375, 382, 390, 397, 401 . . . . . . . . . . . . . . . . . . . . 320 . . . . . . . . . . . . . . . . . . . . 297 . . . . . 95, 116, 270, 357, 361, 362 . . . . . . . . . . . . . . . . . . . . 155 . . . . . . . . . . . . . . . . . . . . 303 . . . . . . . . . . . . . . . . . . . . 385 . . . . . . . . . . . . . . . . . . . . 455 . . . . . . . . . . . . . . . . . . . . 447 . . . . . . . . . . . . . . . . . . . . 32 . . . . . . . . . . . . . . . . . . . . 510
Page xii
Programming in C++
dynamic binding dynamic_cast
. . . . . . . . . . . . . . . . . . . . . . . . 308 . . . . . . . . . . . . . . . . . . . . 480, 482
E
empty() . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389 encapsulation . . . . . . . . . . . . . . . . . . . . . . . . . . 49 end() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386 endl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249 ends . . . . . . . . . . . . . . . . . . . . . . . . . . . 249, 255 entities . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 510 enum . . . . . . . . . . . . . . . . . . . . . . . . . . . 19, 503 enumerations . . . . . . . . . . . . . . . . . . . . . . . 19, 503 eof() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259 equal() . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425 equal_range() . . . . . . . . . . . . . . . . . . . 407, 433 equal_to . . . . . . . . . . . . . . . . . . . . . . . . . . . 447 erase() . . . . . . . . . . . . . . . . . . . . . . . . . 392, 409 examples Allocator . . . . . . . . . . . . . . . . . . . . . . . 350 Array . . . . . . . . . . . . . . . . . . . . . . . . . . 279 Bernoulli . . . . . . . . . . . . . . . . . . . . . . . . . 221 boundArray . . . . . . . . . . . . . . . . . . . . . . 322 Complex 88, 104, 183, 184, 185, 186, 187, 188, 189, 190,
191, 192
Harmonic . . . . . . . . . . . . . . . . . . . . . . . . . 219 I/O . . . . . . . . . . . . . . . . . . . . . . . 245, 248, 253 Inheritance . . . . . . . . . . . . . . . . . . . . . . . . 311 Rational . . . . . . . . . . . . . . . . . . . . . . . . 198 Rectangle 178, 179, 180, 181, 182, 183, 184, 185, 186,
187, 188, 189, 190, 191, 192
Employee . . . . exception handling FArray . . . . . FStack . . . . .
. . . . . . . . . . . . . . . . . 196, 197 . . . . . . . . . . . . . . . . 491, 492 . . . . . . . . . . . . . . . . . . . . 266 . . . . . . . . 79, 193, 194, 195, 275
safeArray . . . . . . . safeFArray . . . . . . Shape . . . . . . . . . . smart pointer . . . . . . . Stack . . . . . . . . . . . . Stack . . . . . . . . . . STL block . . . . . . . STL creating containers STL find_if() . . . STL function parameters STL iterator adaptors . . STL list insertion . . . . STL list sorting . . . . . STL map . . . . . . . . . STL multimap . . . . STL multiset . . . . STL predefined functors STL public types . . . . STL set . . . . . . . . . STL transform() . . String . . . . . . . . . toohot . . . . . . . . . Tvector . . . . . . . .
. . . . . . . . . . . . . . . . 320 . . . . . . . . . . . . . 302, 304 . . . . . . . . . . . . . . . . 311 . . . . . . . 460, 461, 462, 463 . . . . . . . . . . . . . . . . 37 . . . . . . . . . . . . . . . . 281 . . . . . . . 437, 438, 439, 440 . . . . . . . . . . . . . . . . 387 . . . . . . . . . . . . . . . . 422 . . . . . . . . . . . . . . . 419 . . . . . . . . . . . . . . . . 458 . . . . . . . . . . . . . . . . 399 . . . . . . . . . . . . . . . . 400 . . . . . . . . . . . . . . . . 414 . . . . . . . . . . . . . . . . 415 . . . . . . . . . . . . . . . . 411 . . . . . . . . . . . . . 449, 451 . . . . . . . . . . . . . . . . 384 . . . . . . . . . . . . . . . . 410 . . . . . . . . . . . . . . . . 427 . . . . . . . . . . 126, 135, 136 . . . . . . . . . . . . . . . . 273 . . . . . . . . . . . . . . . . 360
Page xiii
Programming in C++
vector . . . . . . . . exception . . . . . . . . . exception handling . . . . . catch block . . . . . . . exception hierarchies . exception specifications function try blocks . . standard exceptions . . throw statement . . . . try block . . . . . . . . explicit . . . . . . . . . . export . . . . . . . . . . . . expression templates . . . . expressions . . . . . . . . . . extern . . . . . . . . . . . . external linkage . . . . . . .
. . . . . 334, 335, 345, 356, 362 . . . . . . . . . . . . . . . . . 488 . . . . . . . . . . . . . . 483, 484 . . . . . . . . . . . . . . 485, 487 . . . . . . . . . . . . . . . . . 488 . . . . . . . . . . . . . . . . 490 . . . . . . . . . . . . . . . . . 490 . . . . . . . . . . . . . . . . . 489 . . . . . . . . . . . . . . . . . 486 . . . . . . . . . . . . . . . . . 484 . . . . . . . . . . . . . . 154, 502 . . . . . . . . . . . . . . . . . 499 . . . . . . . . . . . . . . . . . 365 . . . . . . . . . . . . . . . . . 20 . . . . . . . . . . . . . . . . . 73 . . . . . . . . . . . . . . . . . 73
F
fail() . . . . . . . . false . . . . . . . . . FArray . . . . . . . . file organization . . . fill() . . . . . . . . fill_n() . . . . . . find() . . . . . . . . find_end() . . . . find_first_of() find_if() . . . . .
Programming in C++
. . . . . . . . . . . . . . . . . . . . . 259 . . . . . . . . . . . . . . . . . . . . . 69 . . . . . . . . . . . . . . . . . . . . . 266 . . . . . . . . . . . . . . . . . . . . . 164 . . . . . . . . . . . . . . . . . . 247, 428 . . . . . . . . . . . . . . . . . . . . . 428 . . . . . . . . . . . . . . . . . . 407, 421 . . . . . . . . . . . . . . . . . . . . . 423 . . . . . . . . . . . . . . . . . . . . 423 . . . . . . . . . . . . . . . . . . . . . 421
fixed . . . . . . . . . . . . . . . flags() . . . . . . . . . . . . . . flush . . . . . . . . . . . . . . . flush() . . . . . . . . . . . . . . for . . . . . . . . . . . . . . . . . for_each() . . . . . . . . . . . format control . . . . . . . . . . . freeze() . . . . . . . . . . . . . friend . . . . . . . . . . . . . . . friend functions . . . . . . . . . . friend templates . . . . . . . . . . front() . . . . . . . . . . . . . . front_inserter() . . . . . fstream . . . . . . . . . . . . . . open modes . . . . . . . . . . function object . . . . . . . . . . . function overloading . . . . . . . versus function templates . function templates . . . . . . . . . overloading . . . . . . . . . . versus macros . . . . . . . . versus overloaded functions functions . . . . . . . . . . . . . . explicit conversion . . . . . friend . . . . . . . . . . . . . function object . . . . . . . . functor . . . . . . . . . . . . . inline . . . . . . . . . . . . . member . . . . . . . . . . . .
. . . . . . . . 246, 249, 252 . . . . . . . . . . . . . . 247 . . . . . . . . . . . . . . 249 . . . . . . . . . . . . . . 234 . . . . . . . . . . . . . . 31 . . . . . . . . . . . . . . 425 . . . . . . . . . . . . . . 246 . . . . . . . . . . . . . . 255 . . . . . . . . 143, 144, 476 . . . . . . . . . . . 143, 144 . . . . . . . . . . . . . . 361 . . . . . . . . . . . . . . 394 . . . . . . . . . . . 455, 457 . . . . . . . . . . . 241, 321 . . . . . . . . . . . . . . 242 . . . . . . . . . . . . . . 418 . . . . . . . . . . . . 65, 66 . . . . . . . . . . . . . . 285 . . . . . . . . . . . . . . 284 . . . . . . . . . . . . . . 289 . . . . . . . . . . . . . . 285 . . . . . . . . . . . . . . 285 . . . . . . . . . . . . . . 27 . . . . . . . . . . . . . . 154 . . . . . . . . . . . 143, 144 . . . . . . . . . . . . . . 418 . . . . . . . . . . . . . . 418 . . . . . . . . 64, 163, 164 . . . . . . . . . . . . . . 84
Page xiv
overloading functor . . . . . .
. . . . . . . . . . . . . . . . . . . . . . 65, 66 . . . . . . . . . . . . . . . . . . . . . . . . 418
G
gcd() . . . . . . . . . general . . . . . . . generate() . . . . generate_n() . . generic programming get() . . . . . . . . . getline() . . . . . good() . . . . . . . . greater . . . . . . . greater_equal .
. . . . . . . . . . . . . . . . . . . . . 204 . . . . . . . . . . . . . . . . . . . . . 252 . . . . . . . . . . . . . . . . . . . . . 428 . . . . . . . . . . . . . . . . . . . . . 428 . . . . . . . . . . . . . . . . . . 373, 374 . . . . . . . . . . . . . . . . . . 236, 238 . . . . . . . . . . . . . . . . . . 236, 546 . . . . . . . . . . . . . . . . . . . . . 259 . . . . . . . . . . . . . . . . . . . . . 447 . . . . . . . . . . . . . . . . . . . . . 447
H
handle class . . . . harmonic numbers has-a relation . . . hex . . . . . . . . high-order function history of C++ . .
. . . . . . . . . . . . . . . . . . . . 225, 226 . . . . . . . . . . . . . . . . . . . . . . . 219 . . . . . . . . . . . . . . . . . . . . . . . 513 . . . . . . . . . . . . . . . . . . . . 246, 249 . . . . . . . . . . . . . . . . . . . . . . 448 ........................ 2
I
if . . . . . ifstream ignore()
. . . . . . . . . . . . . . . . . . . . . . . . . . . 29 . . . . . . . . . . . . . . . . . . . . . . . . 241, 244 . . . . . . . . . . . . . . . . . . . . . . . . . . . 238
in . . . . . . . . . . . . . . . . . . . include guards . . . . . . . . . . . . includes() . . . . . . . . . . . . indexed iteration . . . . . . . . . . . indexing . . . . . . . . . . . . . . . . inheritance . . . . . . . . . . . . . . access control . . . . . . . . . access rules . . . . . . . . . . . access specifiers . . . . . . . . assignment . . . . . . . . . . . automatic conversions . . . . constructors and destructor . derived class definition . . . derived class templates . . . . dynamic binding . . . . . . . . inherited members . . . . . . is-a relation . . . . . . . . . . . multiple . . . . . . . . . . . . . overloading member funtions private inheritance . . . . . . public inheritance . . . . . . . slicing . . . . . . . . . . . . . . static binding . . . . . . . . . . inline . . . . . . . . . . . . . . . . . . inline . . . . . . . . . . . . . . . . inline functions . . . . . . . . . . . inner_product() . . . . . . . inplace_merge() . . . . . . . input . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . 242 . . . . . . . . . . . . . 74 . . . . . . . . . . . . . 434 . . . . . . . . . . . . . 31 . . . . . . . . . . . . . 272 . . . . 49, 296, 297, 512 . . . . . . . . . . . . . 301 . . . . . . . . . . . . . 299 . . . . . . . . . . . . . 474 . . . . . . . . . . . . . 318 . . . . . . . . . . . . . 306 . . . . . . . . . . . . . 303 . . . . . . . . . . . . . 300 . . . . . . . . . . . . . 320 . . . . . . . . . . . . . 308 . . . . . . . . . . . . . 299 . . . . . . . . . . . . . 298 . . . . . . . . . . . . . 327 . . . . . . . . . . . . . 319 . . . . 301, 474, 475, 513 . . . . . . . 300, 301, 512 . . . . . . . . . . . . . 317 . . . . . . . . . . . . . 307 . . . . . . . . . . 163, 164 . . . . . . . . . . . . . 64 . . . . . . . 64, 163, 164 . . . . . . . . . . . . . 436 . . . . . . . . . . . . . 433 . . . . 70, 232, 236, 505
Page xv
Programming in C++
binary . . . . . . . . . . . . . . . files . . . . . . . . . . . . . . . . format control . . . . . . . . . . manipulators . . . . . . . . . . . random file access . . . . . . . insert() . . . . . . . . . . . . . . . inserter() . . . . . . . . . . . . . internal . . . . . . . . . . . . . . . ios . . . . . . . . . . . . . . . . . . . iostream . . . . . . . . . . . . . . . is-a relation . . . . . . . . . . . . . . . is-implemented-in-terms-of relation is-kind-of relation . . . . . . . . . . . is-part-of relation . . . . . . . . . . . istream . . . . . . . . . . . . . . . . istream_iterator() . . . . . iter_swap() . . . . . . . . . . . . iterators see STL iterators
. . . . . . . . . . . . 254 . . . . . . . . . . . . 241 . . . . . . . . . . . . 246 . . . . . . . . . . . . 249 . . . . . . . . . . . . 258 . . . . . . 392, 409, 413 . . . . . . . . . . . . 455 . . . . . . . . . . . . 246 . . . . . . 242, 246, 321 . . . . . . . . . 232, 321 . . . . . . . . . 298, 512 . . . . . . . . . . . . 513 . . . . . . . . . . . . 512 . . . . . . . . . . . . 513 . . . . . . . . . 236, 321 . . . . . . . . . . . . 455 . . . . . . . . . . . . 431
lexicographical_compare() . . . . . . . . . . . list . . . . . . . . . . . . . . . . . . 375, 382, 390, 398, reordering . . . . . . . . . . . . . . . . . . . . . . 444, sorting . . . . . . . . . . . . . . . . . . . . . . . . . . . literals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . and classes . . . . . . . . . . . . . . . . . . . . . . . . logical_and . . . . . . . . . . . . . . . . . . . . . . . . logical_not . . . . . . . . . . . . . . . . . . . . . . . . logical_or . . . . . . . . . . . . . . . . . . . . . . . . . lower_bound() . . . . . . . . . . . . . . . . . . . 407,
425 401 445 400 18 137 447 447 447 433
M
macros . . . . . . . . . . . . . . . . . . . . . . . . . . . 66, 285 make_heap() . . . . . . . . . . . . . . . . . . . . . . . . 435 manipulators . . . . . . . . . . . . . . . . . . . . . . . . . . 249 user-defined . . . . . . . . . . . . . . . . . . . . 251, 252 map . . . . . . . . . . . . . . . . . . . . . . 375, 382, 405, 412 mathematical operators 103, 140, 141, 142, 149, 150, 206, 207,
286, 324, 325, 349
K
keywords
............................
54
L
layering . . . . left . . . . . less . . . . . less_equal
Programming in C++
. . . . . . . . . . . . . . . . . . . . . . 475, 513 . . . . . . . . . . . . . . . . . . . . . . . . . 246 . . . . . . . . . . . . . . . . . . . . . . . . . 447 . . . . . . . . . . . . . . . . . . . . . . . . . 447
matrix . . . . . . . max() . . . . . . max_element() maxsize() . . . mem_fun() . . . mem_fun_ref() member functions constant . . . defaults . . .
. . . . . . . . . . . . . . . . . . . . . . . 337 . . . . . . . . . . . . . . . . . . . . . . . 424 . . . . . . . . . . . . . . . . . . . . . . 424 . . . . . . . . . . . . . . . . . . . . . . . 389 . . . . . . . . . . . . . . . . . . . . . . . 448 . . . . . . . . . . . . . . . . . . . . . . 448 . . . . . . . . . . . . . . . . . . . . 84, 139 . . . . . . . . . . . . . . . . . . . . 133, 134 . . . . . . . . . . . . . . . . . . . . . . . 157
Page xvi
pure virtual . . . . . . . . . . . . static . . . . . . . . . . . . . . . . versus global functions . . . . . virtual . . . . . . . . . . . . . . . member initialization lists . . . . . . member templates . . . . . . . . . . . memory allocation . . . . . . . . . . merge() . . . . . . . . . . . . . . . . methods . . . . . . . . . . . . . . . . . min() . . . . . . . . . . . . . . . . . . min_element() . . . . . . . . . . minus . . . . . . . . . . . . . . . . . . mismatch() . . . . . . . . . . . . . model . . . . . . . . . . . . . . . . . . modify member functions . . . . . . modulus . . . . . . . . . . . . . . . . multi-dimensional arrays . . . . . . . multimap . . . . . . . . . . . . . . . multiple inheritance . . . . . . . . . . dominance of virtual functions virtual base classes . . . . . . . multiplies . . . . . . . . . . . . . multiset . . . . . . . . . . . . . . . multiway selection . . . . . . . . . . mutable . . . . . . . . . . . . . . . .
. . . . . . . . . . . . 310 . . . . . . . . . . . . 161 . . . . . . . . . . . . 147 . . . . . . 308, 309, 315 . . . . . . . . . 158, 304 . . . . . . . . . 290, 291 . . . . . . 72, 168, 350 . . . . . . . . . 433, 445 . . . . . . . . . . . . 84 . . . . . . . . . . . . 424 . . . . . . . . . . . . 424 . . . . . . . . . . . . 447 . . . . . . . . . . . . 425 . . . . . . . . . . . . 379 . . . . . . . . . . . . 98 . . . . . . . . . . . . 447 . . . . . . . . . 340, 342 . . . . . . 382, 405, 412 . . . . . . . . . . . . 327 . . . . . . . . . . . . 331 . . . . . . . . . . . . 329 . . . . . . . . . . . . 447 . . . . . . 382, 405, 408 . . . . . . . . . . . . 30 . . . . . . . . . . . . 501
namespace . . . . . . . . namespaces . . . . . . . . . unnamed . . . . . . . using declaration . . using directive . . . . negate . . . . . . . . . . . nested classes . . . . . . . new . . . . . . . . . . . . . overloading . . . . . . next_permutation() nocreate . . . . . . . . . noreplace . . . . . . . . not_equal_to . . . . . not1() . . . . . . . . . . . not2() . . . . . . . . . . . npos . . . . . . . . . . . . nth_element() . . . .
. . . . . . . . . 368, 369, 493, 494 . . . . . . . . . . . . . . . 368, 369 . . . . . . . . . . . . . . . . . . 493 . . . . . . . . . . . . . . . . . . 369 . . . . . . . . . . . . . . . . . . 369 . . . . . . . . . . . . . . . . . . 447 . . . . . . . . . . . . 476, 477, 513 . . . . . . . . . . . . 72, 155, 168 . . . . . . . . . . . . . . . . . . 169 . . . . . . . . . . . . . . . . . 430 . . . . . . . . . . . . . . . . . . 242 . . . . . . . . . . . . . . . . . . 242 . . . . . . . . . . . . . . . . . . 447 . . . . . . . . . . . . . . . . . . 448 . . . . . . . . . . . . . . . . . . 448 . . . . . . . . . . . . . . . . . . 521 . . . . . . . . . . . . . . . . . . 432
O
object . . . . . . . . . object-oriented design objects . . . . . . . . . oct . . . . . . . . . . ofstream . . . . . . open modes . . . . . . open() . . . . . . . . operator- . . . . . operator delete
N
name mangling
Programming in C++
.........................
73
. . . . . . . . . . . . . . . . . . . . . 84 . . . . . . . . . . . . . . . . . 508, 510 . . . . . . . . . . . . . . . . . . 418, 510 . . . . . . . . . . . . . . . . . . 246, 249 . . . . . . . . . . . . . . . . . . 241, 244 . . . . . . . . . . . . . . . . . . . . . 242 . . . . . . . . . . . . . . . . . . . . . 244 . . . . . . . . . . . . . . . . . . . . . 208 . . . . . . . . . . . . . . 168, 169, 171
Page xvii
operator delete[] . . . . . . . . . . . . . . . . . . 503 operator new . . . . . . . . . . . . . . . . . 168, 169, 170 operator new[] . . . . . . . . . . . . . . . . . . . . . 503 operator overloading . . . . . . . . . . . . . . . . . . 68, 152 operator!= . . . . . . . . . . . . . . . . . . . . . . . . . 213 operator() . . . . . . . . . . . . . . . . . . . . . . 338, 339 operator* . . . . . . . . . . . . . . . . . 209, 286, 324, 464 operator*= . . . . . . . . . . . . . . . . . . . . . . . . . 209 operator+ 103, 125, 140, 141, 142, 149, 150, 151, 207, 230,
286, 324, 336, 347, 349, 361, 363, 364 operator++ . . . . . . . . . . . . . . . . . . . 142, 286, operator+= . . . . . . . . . . . . . 141, 142, 206, 335, operator/ . . . . . . . . . . . . . . . . . . . . . . . 211, operator/= . . . . . . . . . . . . . . . . . . . 210, 211, operator:: . . . . . . . . . . . . . . . . . . . . . . 130, 324 347 212 212 131 operator< . . . . . . . . . . . . . . . . . . . . . . . . . . 214 operator<< . . . . . . . 146, 215, 233, 235, 256, 257, 316 operator<= . . . . . . . . . . . . . . . . . . . . . . . . . 214 operator-= . . . . . . . . . . . . . . . . . . . . . . . . . 208 operator= 99, 118, 121, 122, 202, 228, 271, 318, 330, 346, 358, 364 operator== . . . . . . . . . . . . . . . . 102, 124, 213, 229 operator-> . . . . . . . . . . . . . . . . . . . . . . . . . 464 operator> . . . . . . . . . . . . . . . . . . . . . . . . . . 214 operator>= . . . . . . . . . . . . . . . . . . . . . . . . . 214 operator>> . . . . . . . . . . . . . . . . 237, 238, 239, 240 operator[] . . . . . . . . . . 264, 272, 305, 338, 347, 359 operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272 assignment . . . . . . 99, 228, 271, 318, 346, 358, 364
Programming in C++
basic . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 boolean . . . . . . . . . . . . . . . . . . . . . . . 213, 214 concatenation . . . . . . . . . . . . . . . . 125, 151, 230 conversion . . . . . . . . . . . . . . . . . . . . . . . . 153 copy assignment . . . . . . . . . . . . . . . . . . . . . 122 equality test . . . . . . . . . . . . . . . . . 102, 124, 229 indexing . . . . . . . . . . . . . . . . . . . . . . . 264, 305 mathematical 103, 140, 141, 142, 149, 150, 206, 207, 286,
324, 325, 349
output . . . . . . . . . overloading . . . . . . scope resolution . . . optimization . . . . . . . . ostream . . . . . . . . . . ostream_iterator() out . . . . . . . . . . . . . output . . . . . . . . . . . . binary . . . . . . . . . buffered . . . . . . . . files . . . . . . . . . . format control . . . . manipulators . . . . . random file access . overloading functions . . . . . . . new and delete . . . . operator<< . . . . operator>> . . . . operators . . . . . . .
. . . . . . . . . . . . . . . . . . 146 . . . . . . . . . . . . . . . 68, 152 . . . . . . . . . . . . . . . 130, 131 . . . . . . 348, 350, 355, 360, 365 . . . . . . . . . . . . 233, 234, 321 . . . . . . . . . . . . . . 455, 456 . . . . . . . . . . . . . . . . . . 242 . . . 70, 146, 215, 232, 233, 505 . . . . . . . . . . . . . . . . . . 254 . . . . . . . . . . . . . . . . . . 234 . . . . . . . . . . . . . . . . . . 241 . . . . . . . . . . . . . . . . . . 246 . . . . . . . . . . . . . . . . . . 249 . . . . . . . . . . . . . . . . . . 258 . . . . . . . . . . . . . 65, 66, 285 . . . . . . . . . . . . . . . . . . 169 . . . . . . . . . 235, 256, 257, 316 . . . . . . . . . 237, 238, 239, 240 . . . . . . . . . . . . . . . 68, 152
Page xviii
P
pair . . . . . . . . . . . . . parameters default . . . . . . . . . . reference . . . . . . . . partial ordering . . . . . . . . partial specialization . . . . partial_sort() . . . . partial_sort_copy() partial_sum() . . . . . partition() . . . . . . . peek() . . . . . . . . . . . . plus . . . . . . . . . . . . . pointer data members . . . . pointer to class members . . pointers . . . . . . . . . . . . pop_back() . . . . . . . . pop_front() . . . . . . . pop_heap() . . . . . . . . precision() . . . . . . . predicate . . . . . . . . . . . prev_permutation() priority_queue . . . . private . . . . . . . . . . . procedures . . . . . . . . . . program structure . . . . . . protected . . . . . . . . . ptr_fun() . . . . . . . . .
Programming in C++
. . . . . . . . . . . . . . 412, 413 . . . . . . . . . . . . . . . . . 59 . . . . . . . . . . . . . . 63, 156 . . . . . . . . . . . . . . . . . 406 . . . . . . . . . . . . . . . . . 498 . . . . . . . . . . . . . . . . . 432 . . . . . . . . . . . . . . . . 432 . . . . . . . . . . . . . . . . . 436 . . . . . . . . . . . . . . . . . 431 . . . . . . . . . . . . . . 238, 239 . . . . . . . . . . . . . . . . . 447 . . . . . . . . . . . . . . . . . 106 . . . . . . . . . . . . . . . . . 173 . . . . . . . . . . . . . . . 24, 25 . . . . . . . . . . . . . . . . . 394 . . . . . . . . . . . . . . . . . 394 . . . . . . . . . . . . . . . . . 435 . . . . . . . . . . . . . . . . . 247 . . . . . . . . . . . . . . . . . 418 . . . . . . . . . . . . . . . . . 430 . . . . . . . . . . . 382, 401, 404 . . . . . . . . 88, 299, 300, 474 . . . . . . . . . . . . . . . . . 28 . . . . . . . . . . . . . . . . . 26 . . . . . . . . . . . . . . 88, 299 . . . . . . . . . . . . . . . . . 448
public . . . . . . . . . . . . . pure . . . . . . . . . . . . . . pure virtual member functions push_back() . . . . . . . . push_front() . . . . . . . push_heap() . . . . . . . . put() . . . . . . . . . . . . . putback() . . . . . . . . . .
. . . . . . . . . . 88, 299, 300 . . . . . . . . . . . . . . . . 310 . . . . . . . . . . . . . . . 310 . . . . . . . . . . . . . . . . 394 . . . . . . . . . . . . . . . . 394 . . . . . . . . . . . . . . . . 435 . . . . . . . . . . . . . . . . 233 . . . . . . . . . . . . . 238, 240
Q
queue
....................
375, 382, 401, 403
R
random file access . . . random_shuffle() Range . . . . . . . . . Rational . . . . . . . rbegin() . . . . . . . read() . . . . . . . . . records . . . . . . . . . . reference arguments . reference counting . . . body class . . . . handle class . . . reference parameters . references . . . . . . . . refinement . . . . . . .
. . . . . . . . . . . . . . . . . . . . 258 . . . . . . . . . . . . . . . . . . . 430 . . . . . . . . . . . . . . . . . . . . 339 . . . . . . . . . . . . . . . . . . . . 198 . . . . . . . . . . . . . . . . . . . . 386 . . . . . . . . . . . . . . . . . 236, 254 . . . . . . . . . . . . . . . . . . . . 22 . . . . . . . . . . . . . . . . . . . . 63 . . . . . . . . . . . . . . 224, 355, 360 . . . . . . . . . . . . . . . . . . . . 225 . . . . . . . . . . . . . . . . . . . . 226 . . . . . . . . . . . . . . . . . . . . 63 . . . . . . . . . . . . . . . 60, 63, 156 . . . . . . . . . . . . . . . . . . . . 380
Page xix
reinterpret_cast . remove() . . . . . . . . . remove_copy() . . . . remove_copy_if() . remove_if() . . . . . . rend() . . . . . . . . . . . replace() . . . . . . . . replace_copy() . . . replace_copy_if() replace_if() . . . . . reserve() . . . . . . . . resetiosflags() . . resize() . . . . . . . . . reuse . . . . . . . . . . . . . reverse() . . . . . . . . reverse_copy() . . . right . . . . . . . . . . . . rotate() . . . . . . . . . rotate_copy() . . . . RTTI . . . . . . . . . . . . . runtime type identification
. . . . . . . . . . . . . . . . . . 481 . . . . . . . . . . . . . . . 429, 445 . . . . . . . . . . . . . . . . . . 429 . . . . . . . . . . . . . . . . . . 429 . . . . . . . . . . . . . . . 429, 445 . . . . . . . . . . . . . . . . . . 386 . . . . . . . . . . . . . . . . . . 428 . . . . . . . . . . . . . . . . . . 428 . . . . . . . . . . . . . . . . . . 428 . . . . . . . . . . . . . . . . . . 428 . . . . . . . . . . . . . . . . . . 443 . . . . . . . . . . . . . . . . . . 250 . . . . . . . . . . . . . . . . . . 443 . . . . . . . . . . . . . . . . . . 297 . . . . . . . . . . . . . . . 430, 445 . . . . . . . . . . . . . . . . . . 430 . . . . . . . . . . . . . . . . . . 246 . . . . . . . . . . . . . . . . . . 430 . . . . . . . . . . . . . . . . . . 430 . . . . . . . . . . . . . . . . . . 482 . . . . . . . . . . . . . . . . . . 482
S
safeArray . safeFArray scientific scope resolution search() . .
Programming in C++
. . . . . . . . . . . . . . . . . . . . . . . . . 320 . . . . . . . . . . . . . . . . . . . . . . 302, 304 . . . . . . . . . . . . . . . . . . . 246, 249, 252 . . . . . . . . . . . . . . . . . . . . . 130, 131 . . . . . . . . . . . . . . . . . . . . . . . . . 423
search_n() . . . . . . . . . . . . . . . selection . . . . . . . . . . . . . . . . . . . set . . . . . . . . . . . . . . . . . . . . . set_difference() . . . . . . . . . set_intersection() . . . . . . . set_symmetric_difference() set_union() . . . . . . . . . . . . . . setbase() . . . . . . . . . . . . . . . . setf() . . . . . . . . . . . . . . . . . . . setfill() . . . . . . . . . . . . . . . . setiosflags() . . . . . . . . . . . . setprecision() . . . . . . . . . . . setw() . . . . . . . . . . . . . . . . . . . showbase . . . . . . . . . . . . . . . . . showpoint . . . . . . . . . . . . . . . . showpos . . . . . . . . . . . . . . . . . . size() . . . . . . . . . . . . . . . . . . . skipws . . . . . . . . . . . . . . . . . . . slicing . . . . . . . . . . . . . . . . . . . . smart pointer . . . . . . . . . . . . . . . . sort() . . . . . . . . . . . . . . . . . . . sort_heap() . . . . . . . . . . . . . . splice() . . . . . . . . . . . . . . . . . stable_partition() . . . . . . . stable_sort() . . . . . . . . . . . . Stack . . . . . . . . . . . . . . . . . . . . . Stack . . . . . . . . . . . . . . . . . . . stack . . . . . . . . . . . . . . . . . . . standard library . . . . . . . . . . . . . .
. . . . . . . . . . 423 . . . . . . . . . . 29 . 375, 382, 405, 408 . . . . . . . . . . 434 . . . . . . . . . . 434 . . . . . . . . . . 434 . . . . . . . . . . 434 . . . . . . . . . . 250 . . . . . . . . . . 247 . . . . . . . . . . 250 . . . . . . . . . . 250 . . . . . . . . . . 250 . . . . . . . . . . 250 . . . . . . . 246, 249 . . . . . . . 246, 249 . . . . . . . 246, 249 . . . . . . . 389, 442 . . . . . . . 246, 249 . . . . . . . . . . 317 . . . . . . . 464, 465 . . . . . . . 432, 445 . . . . . . . . . . 435 . . . . . . . . . . 444 . . . . . . . . . . 431 . . . . . . . . . . 432 . . . . . . . . . . 37 . . . . . . . . . . 281 . 375, 382, 401, 402 . . . . . . . . . . 370
Page xx
standard template library see STL statements do loop . . . . . . . . . . . . . . for loop . . . . . . . . . . . . . . if . . . . . . . . . . . . . . . . . . switch . . . . . . . . . . . . . . . while loop . . . . . . . . . . . . static . . . . . . . . . . . . . . . . . static binding . . . . . . . . . . . . . . static data members . . . . . . . . . . static member functions . . . . . . . static_cast . . . . . . . . . . . . std::string . . . . . . . . . . . . append . . . . . . . . . . . . . . . assignment . . . . . . . . . . . . capacity . . . . . . . . . . . . . . comparison . . . . . . . . . . . . concatenation . . . . . . . . . . constructors . . . . . . . . . . . conversion to C style string . . denition . . . . . . . . . . . . . destructor . . . . . . . . . . . . . element access . . . . . . . . . . erase . . . . . . . . . . . . . . . . nd . . . . . . . . . . . . . . . . . insert . . . . . . . . . . . . . . . . iterators . . . . . . . . . . . . . . length . . . . . . . . . . . . . . . npos . . . . . . . . . . . . . . .
Programming in C++
. . . . . . . . . . . . 32 . . . . . . . . . . . . 31 . . . . . . . . . . . . 29 . . . . . . . . . . . . 30 . . . . . . . . . . . . 32 . . . . . . 160, 161, 496 . . . . . . . . . . . . 307 . . . . . . . . . . . . 160 . . . . . . . . . . . . 161 . . . . . . . . . . . . 479 . . . . . . 128, 370, 446 . . . . . . . . . 531, 532 . . . . . . . . . . . . 526 . . . . . . . . . . . . 528 . . . . . . 530, 544, 545 . . . . . . . . . . . . 543 . . . . . . . . . . . . 525 . . . . . . . . . 469, 539 . . . . . . . . . . . . 520 . . . . . . . . . . . . 525 . . . . . . . . . . . . 529 . . . . . . . . . . . . 535 . . . . . . 540, 541, 542 . . . . . . . . . 533, 534 . . . . . . . . . . . . 527 . . . . . . . . . . . . 528 . . . . . . . . . . . . 521
replace . . . . . . . . . . . . . . . . search . . . . . . . . . . . . . . . . size . . . . . . . . . . . . . . . . . . substring . . . . . . . . . . . . . . stdio . . . . . . . . . . . . . . . . . . STL . . . . . . . . . . . . . . . . . . . . books . . . . . . . . . . . . . . . . copying objects . . . . . . . . . . finding objects . . . . . . . . . . . portability . . . . . . . . . . . . . . removing objects . . . . . . . . . WWW . . . . . . . . . . . . . . . . STL algorithms . . . . . . . . . . . . . binary search . . . . . . . . . . . . comparing ranges . . . . . . . . . copying ranges . . . . . . . . . . . counting elements . . . . . . . . . filling ranges . . . . . . . . . . . . function parameters . . . . . . . . functors . . . . . . . . . . . . . . . generalized numeric algorithms heap operations . . . . . . . . . . linear search . . . . . . . . . . . . merging ranges . . . . . . . . . . minimum and maximum . . . . . mutating sequence algorithms . nonmutating sequence algorithms partitions . . . . . . . . . . . . . . permuting algorithms . . . . . . .
. . . . . 536, 537, 538 . . . . . 540, 541, 542 . . . . . . . . . . . 528 . . . . . . . . 521, 539 . . . . . . . . . . . 246 . . . . . . . . 371, 375 . . . . . . . . . . . 470 . . . . . . . . . . . 459 . . . . . . . . 467, 468 . . . . . . . . . . . 472 . . . . . . . . . . . 466 . . . . . . . . . . . 471 . . . . . 375, 416, 420 . . . . . . . . . . . 433 . . . . . . . . . . . 425 . . . . . . . . . . . 426 . . . . . . . . . . . 424 . . . . . . . . . . . 428 . . . . . . . . 417, 418 . . . . . . . . . . . 418 . . . . . . . . 416, 436 . . . . . . . . . . . 435 . . . . . . . . 421, 423 . . . . . . . . . . . 433 . . . . . . . . . . . 424 . . . . . . . . 416, 426 . . . . . . . 416, 421 . . . . . . . . . . . 431 . . . . . . . . . . . 430
Page xxi
predefined functor adaptors predefined functors . . . . . removing elements . . . . . replacing elements . . . . . set operations . . . . . . . . sorting . . . . . . . . . . . . . sorting-related algorithms . swapping elements . . . . . transforming elements . . . STL containers . . . . . . . . . . . 'almost' containers . . . . . . assigning elements . . . . . associative containers . . . comparison . . . . . . . . . . constructors . . . . . . . . . container adaptors . . . . . . deleting elements . . . . . . destructor . . . . . . . . . . . finding elements . . . . . . . inserting elements . . . . . . internal sorting . . . . . . . . invalidating iterators . . . . iterators . . . . . . . . . . . . list reordering . . . . . . . . optional operations . . . . . other member functions . . public types . . . . . . . . . sequence containers . . . . . STL iterators . . . . . . . . . . . .
Programming in C++
. . . . . . . . . . . . . . 448 . . . . . . . . . . . . . . 447 . . . . . . . . . . . . . . 429 . . . . . . . . . . . . . . 428 . . . . . . . . . . . . . . 434 . . . . . . . . . . . . . . 432 . . . . . . . . . . . 416, 432 . . . . . . . . . . . . . . 431 . . . . . . . . . . . . . . 427 . . . . . . . . . . . 375, 382 . . . . . . . . . . . 382, 446 . . . . . . . . . . . . . . 393 . . . . . . . . . . . 382, 405 . . . . . . . . . . . . . . 388 . . . . . . . . . . . 385, 391 . . . . . . . . . . . 382, 401 . . . . . . . . 392, 409, 466 . . . . . . . . . . . . . . 385 . . . . . . . . . . . 407, 467 . . . . . . . . 392, 409, 413 . . . . . . . . . . . . . . 406 . . . . . . . . . . . . . . 441 . . . . . . . . . . . . . . 386 . . . . . . . . . . . . . . 444 . . . . . . . . . . . . . . 394 . . . . . . . . . . . . . . 389 . . . . . . . . . . . . . . 383 . . . . . . . . 382, 390, 401 . . . . . . . . . . . 375, 380
container iterators . . . . . . insert iterators . . . . . . . . invalidating iterators . . . . predefined iterators . . . . . reverse iterators . . . . . . . stream iterators . . . . . . . storage layout . . . . . . . . . . . str() . . . . . . . . . . . . . . . strcat . . . . . . . . . . . . . . . . . strcmp . . . . . . . . . . . . . . . . strcpy . . . . . . . . . . . . . . . . strdup . . . . . . . . . . . . . . . . streams . . . . . . . . . . . . . . . error handling . . . . . . . . flags . . . . . . . . . . . . . . strict weak ordering . . . . . . . . String . . . . . . . . . . . . . . . string see std::string strlen . . . . . . . . . . . . . . . . . strstream . . . . . . . . . . . . struct . . . . . . . . . . . . . . . structs . . . . . . . . . . . . . . . . subarray selection . . . . . . . . . subclass . . . . . . . . . . . . . . . superclass . . . . . . . . . . . . . . swap() . . . . . . . . . . . . . . . swap_ranges() . . . . . . . . switch . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . 386 . . . . . . . . 426, 455, 457 . . . . . . . . . . . . . . 441 . . . . . . . . 455, 456, 457 . . . . . . . . . . . 440, 455 . . . . . . . . . . . 455, 456 . . . . . . . . . . . . . . 337 . . . . . . . . . . . . . . 255 . . . . . . . . . . . . . . 109 . . . . . . . . . . . . . . 109 . . . . . . . . . . . . . . 109 . . . . . . . . . . . . . . 109 . . . . . . . . . . . . . . 232 . . . . . . . . . . . . . . 259 . . . . . . . . . . . . . . 247 . . . . . . . . . . . . . . 406 . . . . . . . . 126, 135, 136 . . . . . . . . . . . . . . 109 . . . . . . . . . . . 255, 321 . . . . . . . . . 22, 57, 162 . . . . . . . . . . . . 22, 57 . . . . . . . . . . . 338, 339 . . . . . . . . . . . . . . 297 . . . . . . . . . . . . . . 297 . . . . . . . . 389, 431, 546 . . . . . . . . . . . . . . 431 . . . . . . . . . . . . . . 30
Page xxii
T
template meta-programming . . . . . . . . . . . templates classes . . . . . . . . . . . . . . . . . . . . . . constraints . . . . . . . . . . . . . . . . . . . container . . . . . . . . . . . . . . . . . . . . containers see STL containers default template parameters . . . . . . . . . derived class . . . . . . . . . . . . . . . . . . explicit instantiation . . . . . . . . . . . . . explicit qualification . . . . . . . . . . . . . expressions . . . . . . . . . . . . . . . . . . . friends . . . . . . . . . . . . . . . . . . . . . . functions . . . . . . . . . . . . . . . . . . . . member definition outside class definition member templates . . . . . . . . . . . . . . . non-type template arguments . . . . . . . . partial specialization . . . . . . . . . . . . . static . . . . . . . . . . . . . . . . . . . . . . . template function overloading . . . . . . . template parameters . . . . . . . . . . . . . template specialization . . . . . . . . . . . . template type arguments . . . . . . . . . . . temporary base class . . . . . . . . . . . . . . . . this . . . . . . . . . . . . . . . . . . . . . . . . . throw . . . . . . . . . . . . . . . . . . . . . . . . . transform() . . . . . . . . . . . . . . . . . . . true . . . . . . . . . . . . . . . . . . . . . . . . .
Programming in C++
. . . . . 365 . . 278, 282 . . . . . 283 . . . . . 282 . . . . . 293 . . . . . 320 . . . . . 497 . . . . . 289 . . . . . 365 . . 361, 495 . . . . . 284 . . . . . 280 . . 290, 291 . . . . . 341 . . . . . 498 . . . . . 496 . . . . . 289 . . . . . 292 . . 287, 288 . . . . . 497 . . . . . 360 . . . . . 100 . . . . . 486 . . . . . 427 . . . . . 69
trunc . . . try . . . . . Tvector . . type design . type_info typeid() . typename . types . . . . .
.......................... .......................... .......................... .......................... .......................... .......................... .......................... ..........................
242 484 360 516 482 482 496 510
U
UML . . . . 297, 302, 311, 320, 321, 325, 329, 343, 344, unexpected() . . . . . . . . . . . . . . . . . . . . . . . Unified Modeling Language see UML union . . . . . . . . . . . . . . . . . . . . . . . . . . . . . unions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . anonymous . . . . . . . . . . . . . . . . . . . . . . . . unique() . . . . . . . . . . . . . . . . . . . . . . . . 429, unique_copy() . . . . . . . . . . . . . . . . . . . . . . unitbuf . . . . . . . . . . . . . . . . . . . . . . . . . . . . unnamed namespaces . . . . . . . . . . . . . . . . . . . . . unrolling . . . . . . . . . . . . . . . . . . . . . . . . . . . . unsetf() . . . . . . . . . . . . . . . . . . . . . . . . . . . upper_bound() . . . . . . . . . . . . . . . . . . . 407, uppercase . . . . . . . . . . . . . . . . . . . . . . . 246, user-defined types . . . . . . . . . . . . . . . . . . . . 84, uses-a relation . . . . . . . . . . . . . . . . . . . . . . . . . using . . . . . . . . . . . . . . . . . . . . . . . . . . . . . using declaration . . . . . . . . . . . . . . . . . . . . . . .
489 490 57 57 76 445 429 246 493 348 247 433 249 516 513 369 369
Page xxiii
using directive
. . . . . . . . . . . . . . . . . . . . . . . . . 369
V
valarray . . . . . . . . . . . . . . . . . . . . . 370, 382, vector . . 334, 335, 345, 356, 362, 375, 382, 390, 395, pass data to C functions . . . . . . . . . . . . . . . . resizing behavior . . . . . . . . . . . . . . . . . . . . virtual . . . . . . . . . . . . . . . . . . . . . . . . . 308, virtual base classes . . . . . . . . . . . . . . . . . . . . . . virtual member functions . . . . . . . . . . . . 308, 309, overloading . . . . . . . . . . . . . . . . . . . . . . . .
446 401 469 442 329 329 315 319
W
while . . width() write() ws . . . . WWW . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247 . . . . . . . . . . . . . . . . . . . . . . . . . 233, 254 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249 . . . . . . . . . . . . . . . . . . . . . . . 8, 365, 471
Programming in C++
Page xxiv

C++ Cxx-Kurs

Uploaded by

Copyright:

Available Formats

C++ Cxx-Kurs

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

C++ Cxx-Kurs

Uploaded by

Copyright:

Available Formats

Programming in C++

Dr. Bernd Mohr [email protected] Forschungszentrum Jlich Germany

Dr. Bernd Mohr, FZ Jlich, ZAM

International Standard (ISO/IEC 14882:1998, "Programming Language -- C++")

Dr. Bernd Mohr, FZ Jlich, ZAM

C++ Legality Books

C++ Morality Books

Dr. Bernd Mohr, FZ Jlich, ZAM

Additional (Expert) Reading

Dr. Bernd Mohr, FZ Jlich, ZAM

C++ on the WWW

http://www.fz-juelich.de/zam/PT/lang/cplusplus.html WWW C++ Information http://www.fz-juelich.de/zam/cxx/

Dr. Bernd Mohr, FZ Jlich, ZAM

Dr. Bernd Mohr, FZ Jlich, ZAM

Some General Remarks "C++: The Cobol of the 90s"

ANSI C and C++

is a better C "as close to C as possible but no closer" [Stroustroup / Koenig, 1989]

Dr. Bernd Mohr, FZ Jlich, ZAM

Dr. Bernd Mohr, FZ Jlich, ZAM

Dr. Bernd Mohr, FZ Jlich, ZAM

Basic Data Types

.false., .true. c or "c" foo or "foo" 456, -9 3.89, -0.4e7 (-1.0,0.0)

const const const const

double PI=3.1415; char SP= ; double NEG_PI=-PI; double TWO_PI=2*PI;

real,parameter::PI=3.1415 character,parameter::SP= real,parameter::NEG_PI=-PI real,parameter::TWO_PI=2*PI

integer a, b real x integer::i = 396

ANSI C and Fortran: declarations in any order ANSI C is case-sensitive:

foo and Foo or FOO are all distinct identifiers!

char c[10]; Nums p, q; float a[2][3]; p[4] = -78; a[0][1] = 2.3;

character,dimension(0:9):: c integer,dimension(0:19):: p, q real,dimension(0:1,0:2):: a p(4) = -78 a(0,2) = 2.3

Pascal records cannot be returned by functions

Dr. Bernd Mohr, FZ Jlich, ZAM

Dr. Bernd Mohr, FZ Jlich, ZAM

integer,pointer :: a character,pointer :: b, c type(Engine),pointer :: mp a => i a = 3 nullify(b) allocate(mp) mp%level = 0 deallocate(mp)

ANSI C (and C++) Arrays and Pointers

{ local declarations statements }

local declarations statements end [program]

ANSI C and Fortran: declarations in any order

{ local decls statements incl. return expr; } int j; j = 3 * F(2.0, 6);

subroutine F(i) integer i local decls statements return end

{ local decls statements }

Dr. Bernd Mohr, FZ Jlich, ZAM

Dr. Bernd Mohr, FZ Jlich, ZAM

int func(int i) { if (i > 0) { return 1; } else ...

const int MAXBUF = 256; int myBuf[MAXBUF]; int getBuffer();

Access to Command Line Arguments

Dr. Bernd Mohr, FZ Jlich, ZAM

void finish(Stack *S) { free(S); }

/* replace top 2 elements */ /* by their sum */

Simple Stack Problems

/* OK, assuming As state is valid*/

/* lost old B (memory leak) /* oops! just wiped out A and B

Dr. Roldan Pozo, NIST

Simple Stack Problems

Dr. Bernd Mohr, FZ Jlich, ZAM

function names like DStack_init() less likely to cause naming conflicts

Dr. Roldan Pozo, NIST

Generic Stack in C (via C preprocessor)

/* Generic(?) Dynamic Stack

/* replace top 2 elements / / by their sum */

/3/ /1/ /2/ /4/ /1/ i: Stack: ? ? SP p: a: 3 /2/ i:

/3/ /1/ /2/ /4/