book

Programming: Principles and Practice Using C++, 2nd Edition

by Bjarne Stroustrup

May 2014

Beginner

1312 pages

38h 36m

English

Addison-Wesley Professional

Read now

Unlock full access

0.1 The structure of this book0.1.1 General approach0.1.2 Drills, exercises, etc.0.1.3 What comes after this book?0.2 A philosophy of teaching and learning0.2.1 The order of topics0.2.2 Programming and programming language0.2.3 Portability0.3 Programming and computer science0.4 Creativity and problem solving0.5 Request for feedback0.6 References0.7 BiographiesBjarne StroustrupLawrence “Pete” Petersen
1.1 Introduction1.2 Software1.3 People1.4 Computer science1.5 Computers are everywhere1.5.1 Screens and no screens1.5.2 Shipping1.5.3 Telecommunications1.5.4 Medicine1.5.5 Information1.5.6 A vertical view1.5.7 So what?1.6 Ideals for programmers
2.1 Programs2.2 The classic first program2.3 Compilation2.4 Linking2.5 Programming environments

3.1 Input3.2 Variables3.3 Input and type3.4 Operations and operators3.5 Assignment and initialization3.5.1 An example: detect repeated words3.6 Composite assignment operators3.6.1 An example: find repeated words3.7 Names3.8 Types and objects3.9 Type safety3.9.1 Safe conversions3.9.2 Unsafe conversions
4.1 Computation4.2 Objectives and tools4.3 Expressions4.3.1 Constant expressions4.3.2 Operators4.3.3 Conversions4.4 Statements4.4.1 Selection4.4.2 Iteration4.5 Functions4.5.1 Why bother with functions?4.5.2 Function declarations4.6 vector4.6.1 Traversing a vector4.6.2 Growing a vector4.6.3 A numeric example4.6.4 A text example4.7 Language features
5.1 Introduction5.2 Sources of errors5.3 Compile-time errors5.3.1 Syntax errors5.3.2 Type errors5.3.3 Non-errors5.4 Link-time errors5.5 Run-time errors5.5.1 The caller deals with errors5.5.2 The callee deals with errors5.5.3 Error reporting5.6 Exceptions5.6.1 Bad arguments5.6.2 Range errors5.6.3 Bad input5.6.4 Narrowing errors5.7 Logic errors5.8 Estimation5.9 Debugging5.9.1 Practical debug advice5.10 Pre- and post-conditions5.10.1 Post-conditions5.11 Testing
6.1 A problem6.2 Thinking about the problem6.2.1 Stages of development6.2.2 Strategy6.3 Back to the calculator!6.3.1 First attempt6.3.2 Tokens6.3.3 Implementing tokens6.3.4 Using tokens6.3.5 Back to the drawing board6.4 Grammars6.4.1 A detour: English grammar6.4.2 Writing a grammar6.5 Turning a grammar into code6.5.1 Implementing grammar rules6.5.2 Expressions6.5.3 Terms6.5.4 Primary expressions6.6 Trying the first version6.7 Trying the second version6.8 Token streams6.8.1 Implementing Token_stream6.8.2 Reading tokens6.8.3 Reading numbers6.9 Program structure
7.1 Introduction7.2 Input and output7.3 Error handling7.4 Negative numbers7.5 Remainder: %7.6 Cleaning up the code7.6.1 Symbolic constants7.6.2 Use of functions7.6.3 Code layout7.6.4 Commenting7.7 Recovering from errors7.8 Variables7.8.1 Variables and definitions7.8.2 Introducing names7.8.3 Predefined names7.8.4 Are we there yet?
8.1 Technicalities8.2 Declarations and definitions8.2.1 Kinds of declarations8.2.2 Variable and constant declarations8.2.3 Default initialization8.3 Header files8.4 Scope8.5 Function call and return8.5.1 Declaring arguments and return type8.5.2 Returning a value8.5.3 Pass-by-value8.5.4 Pass-by-const-reference8.5.5 Pass-by-reference8.5.6 Pass-by-value vs. pass-by-reference8.5.7 Argument checking and conversion8.5.8 Function call implementation8.5.9 constexpr functions8.6 Order of evaluation8.6.1 Expression evaluation8.6.2 Global initialization8.7 Namespaces8.7.1 using declarations and using directives
9.1 User-defined types9.2 Classes and members9.3 Interface and implementation9.4 Evolving a class9.4.1 struct and functions9.4.2 Member functions and constructors9.4.3 Keep details private9.4.4 Defining member functions9.4.5 Referring to the current object9.4.6 Reporting errors9.5 Enumerations9.5.1 “Plain” enumerations9.6 Operator overloading9.7 Class interfaces9.7.1 Argument types9.7.2 Copying9.7.3 Default constructors9.7.4 const member functions9.7.5 Members and “helper functions”9.8 The Date class
10.1 Input and output10.2 The I/O stream model10.3 Files10.4 Opening a file10.5 Reading and writing a file10.6 I/O error handling10.7 Reading a single value10.7.1 Breaking the problem into manageable parts10.7.2 Separating dialog from function10.8 User-defined output operators10.9 User-defined input operators10.10 A standard input loop10.11 Reading a structured file10.11.1 In-memory representation10.11.2 Reading structured values10.11.3 Changing representations
11.1 Regularity and irregularity11.2 Output formatting11.2.1 Integer output11.2.2 Integer input11.2.3 Floating-point output11.2.4 Precision11.2.5 Fields11.3 File opening and positioning11.3.1 File open modes11.3.2 Binary files11.3.3 Positioning in files11.4 String streams11.5 Line-oriented input11.6 Character classification11.7 Using nonstandard separators11.8 And there is so much more
12.1 Why graphics?12.2 A display model12.3 A first example12.4 Using a GUI library12.5 Coordinates12.6 Shapes12.7 Using Shape primitives12.7.1 Graphics headers and main12.7.2 An almost blank window12.7.3 Axis12.7.4 Graphing a function12.7.5 Polygons12.7.6 Rectangles12.7.7 Fill12.7.8 Text12.7.9 Images12.7.10 And much more12.8 Getting this to run12.8.1 Source files
13.1 Overview of graphics classes13.2 Point and Line13.3 Lines13.4 Color13.5 Line_style13.6 Open_polyline13.7 Closed_polyline13.8 Polygon13.9 Rectangle13.10 Managing unnamed objects13.11 Text13.12 Circle13.13 Ellipse13.14 Marked_polyline13.15 Marks13.16 Mark13.17 Images
14.1 Design principles14.1.1 Types14.1.2 Operations14.1.3 Naming14.1.4 Mutability14.2 Shape14.2.1 An abstract class14.2.2 Access control14.2.3 Drawing shapes14.2.4 Copying and mutability14.3 Base and derived classes14.3.1 Object layout14.3.2 Deriving classes and defining virtual functions14.3.3 Overriding14.3.4 Access14.3.5 Pure virtual functions14.4 Benefits of object-oriented programming
15.1 Introduction15.2 Graphing simple functions15.3 Function15.3.1 Default Arguments15.3.2 More examples15.3.3 Lambda expressions15.4 Axis15.5 Approximation15.6 Graphing data15.6.1 Reading a file15.6.2 General layout15.6.3 Scaling data15.6.4 Building the graph
16.1 User interface alternatives16.2 The “Next” button16.3 A simple window16.3.1 A callback function16.3.2 A wait loop16.3.3 A lambda expression as a callback16.4 Button and other Widgets16.4.1 Widgets16.4.2 Buttons16.4.3 In_box and Out_box16.4.4 Menus16.5 An example16.6 Control inversion16.7 Adding a menu16.8 Debugging GUI code
17.1 Introduction17.2 vector basics17.3 Memory, addresses, and pointers17.3.1 The sizeof operator17.4 Free store and pointers17.4.1 Free-store allocation17.4.2 Access through pointers17.4.3 Ranges17.4.4 Initialization17.4.5 The null pointer17.4.6 Free-store deallocation17.5 Destructors17.5.1 Generated destructors17.5.2 Destructors and free store17.6 Access to elements17.7 Pointers to class objects17.8 Messing with types: void* and casts17.9 Pointers and references17.9.1 Pointer and reference parameters17.9.2 Pointers, references, and inheritance17.9.3 An example: lists17.9.4 List operations17.9.5 List use17.10 The this pointer17.10.1 More link use
18.1 Introduction18.2 Initialization18.3 Copying18.3.1 Copy constructors18.3.2 Copy assignments18.3.3 Copy terminology18.3.4 Moving18.4 Essential operations18.4.1 Explicit constructors18.4.2 Debugging constructors and destructors18.5 Access to vector elements18.5.1 Overloading on const18.6 Arrays18.6.1 Pointers to array elements18.6.2 Pointers and arrays18.6.3 Array initialization18.6.4 Pointer problems18.7 Examples: palindrome18.7.1 Palindromes using string18.7.2 Palindromes using arrays18.7.3 Palindromes using pointers
19.1 The problems19.2 Changing size19.2.1 Representation19.2.2 reserve and capacity19.2.3 resize19.2.4 push_back19.2.5 Assignment19.2.6 Our vector so far19.3 Templates19.3.1 Types as template parameters19.3.2 Generic programming19.3.3 Concepts19.3.4 Containers and inheritance19.3.5 Integers as template parameters19.3.6 Template argument deduction19.3.7 Generalizing vector19.4 Range checking and exceptions19.4.1 An aside: design considerations19.4.2 A confession: macros19.5 Resources and exceptions19.5.1 Potential resource management problems19.5.2 Resource acquisition is initialization19.5.3 Guarantees19.5.4 unique_ptr19.5.5 Return by moving19.5.6 RAII for vector
20.1 Storing and processing data20.1.1 Working with data20.1.2 Generalizing code20.2 STL ideals20.3 Sequences and iterators20.3.1 Back to the example20.4 Linked lists20.4.1 List operations20.4.2 Iteration20.5 Generalizing vector yet again20.5.1 Container traversal20.5.2 auto20.6 An example: a simple text editor20.6.1 Lines20.6.2 Iteration20.7 vector, list, and string20.7.1 insert and erase20.8 Adapting our vector to the STL20.9 Adapting built-in arrays to the STL20.10 Container overview20.10.1 Iterator categories
21.1 Standard library algorithms21.2 The simplest algorithm: find()21.2.1 Some generic uses21.3 The general search: find_if()21.4 Function objects21.4.1 An abstract view of function objects21.4.2 Predicates on class members21.4.3 Lambda expressions21.5 Numerical algorithms21.5.1 Accumulate21.5.2 Generalizing accumulate()21.5.3 Inner product21.5.4 Generalizing inner_product()21.6 Associative containers21.6.1 map21.6.2 map overview21.6.3 Another map example21.6.4 unordered_map21.6.5 set21.7 Copying21.7.1 Copy21.7.2 Stream iterators21.7.3 Using a set to keep order21.7.4 copy_if21.8 Sorting and searching21.9 Container algorithms
22.1 History, ideals, and professionalism22.1.1 Programming language aims and philosophies22.1.2 Programming ideals22.1.3 Styles/paradigms22.2 Programming language history overview22.2.1 The earliest languages22.2.2 The roots of modern languages22.2.3 The Algol family22.2.4 Simula22.2.5 C22.2.6 C++22.2.7 Today22.2.8 Information sources
23.1 Text23.2 Strings23.3 I/O streams23.4 Maps23.4.1 Implementation details23.5 A problem23.6 The idea of regular expressions23.6.1 Raw string literals23.7 Searching with regular expressions23.8 Regular expression syntax23.8.1 Characters and special characters23.8.2 Character classes23.8.3 Repeats23.8.4 Grouping23.8.5 Alternation23.8.6 Character sets and ranges23.8.7 Regular expression errors23.9 Matching with regular expressions23.10 References
24.1 Introduction24.2 Size, precision, and overflow24.2.1 Numeric limits24.3 Arrays24.4 C-style multidimensional arrays24.5 The Matrix library24.5.1 Dimensions and access24.5.2 1D Matrix24.5.3 2D Matrix24.5.4 Matrix I/O24.5.5 3D Matrix24.6 An example: solving linear equations24.6.1 Classical Gaussian elimination24.6.2 Pivoting24.6.3 Testing24.7 Random numbers24.8 The standard mathematical functions24.9 Complex numbers24.10 References
25.1 Embedded systems25.2 Basic concepts25.2.1 Predictability25.2.2 Ideals25.2.3 Living with failure25.3 Memory management25.3.1 Free-store problems25.3.2 Alternatives to the general free store25.3.3 Pool example25.3.4 Stack example25.4 Addresses, pointers, and arrays25.4.1 Unchecked conversions25.4.2 A problem: dysfunctional interfaces25.4.3 A solution: an interface class25.4.4 Inheritance and containers25.5 Bits, bytes, and words25.5.1 Bits and bit operations25.5.2 bitset25.5.3 Signed and unsigned25.5.4 Bit manipulation25.5.5 Bitfields25.5.6 An example: simple encryption25.6 Coding standards25.6.1 What should a coding standard be?25.6.2 Sample rules25.6.3 Real coding standards
26.1 What we want26.1.1 Caveat26.2 Proofs26.3 Testing26.3.1 Regression tests26.3.2 Unit tests26.3.3 Algorithms and non-algorithms26.3.4 System tests26.3.5 Finding assumptions that do not hold26.4 Design for testing26.5 Debugging26.6 Performance26.6.1 Timing26.7 References
27.1 C and C++: siblings27.1.1 C/C++ compatibility27.1.2 C++ features missing from C27.1.3 The C standard library27.2 Functions27.2.1 No function name overloading27.2.2 Function argument type checking27.2.3 Function definitions27.2.4 Calling C from C++ and C++ from C27.2.5 Pointers to functions27.3 Minor language differences27.3.1 struct tag namespace27.3.2 Keywords27.3.3 Definitions27.3.4 C-style casts27.3.5 Conversion of void*27.3.6 enum27.3.7 Namespaces27.4 Free store27.5 C-style strings27.5.1 C-style strings and const27.5.2 Byte operations27.5.3 An example: strcpy()27.5.4 A style issue27.6 Input/output: stdio27.6.1 Output27.6.2 Input27.6.3 Files27.7 Constants and macros27.8 Macros27.8.1 Function-like macros27.8.2 Syntax macros27.8.3 Conditional compilation27.9 An example: intrusive containers
A.1 GeneralA.1.1 TerminologyA.1.2 Program start and terminationA.1.3 CommentsA.2 LiteralsA.2.1 Integer literalsA.2.2 Floating-point-literalsA.2.3 Boolean literalsA.2.4 Character literalsA.2.5 String literalsA.2.6 The pointer literalA.3 IdentifiersA.3.1 KeywordsA.4 Scope, storage class, and lifetimeA.4.1 ScopeA.4.2 Storage classA.4.3 LifetimeA.5 ExpressionsA.5.1 User-defined operatorsA.5.2 Implicit type conversionA.5.3 Constant expressionsA.5.4 sizeofA.5.5 Logical expressionsA.5.6 new and deleteA.5.7 CastsA.6 StatementsA.7 DeclarationsA.7.1 DefinitionsA.8 Built-in typesA.8.1 PointersA.8.2 ArraysA.8.3 ReferencesA.9 FunctionsA.9.1 Overload resolutionA.9.2 Default argumentsA.9.3 Unspecified argumentsA.9.4 Linkage specificationsA.10 User-defined typesA.10.1 Operator overloadingA.11 EnumerationsA.12 ClassesA.12.1 Member accessA.12.2 Class member definitionsA.12.3 Construction, destruction, and copyA.12.4 Derived classesA.12.5 BitfieldsA.12.6 UnionsA.13 TemplatesA.13.1 Template argumentsA.13.2 Template instantiationA.13.3 Template member typesA.14 ExceptionsA.15 NamespacesA.16 AliasesA.17 Preprocessor directivesA.17.1 #includeA.17.2 #define
B.1 OverviewB.1.1 Header filesB.1.2 Namespace stdB.1.3 Description styleB.2 Error handlingB.2.1 ExceptionsB.3 IteratorsB.3.1 Iterator modelB.3.2 Iterator categoriesB.4 ContainersB.4.1 OverviewB.4.2 Member typesB.4.3 Constructors, destructors, and assignmentsB.4.4 IteratorsB.4.5 Element accessB.4.6 Stack and queue operationsB.4.7 List operationsB.4.8 Size and capacityB.4.9 Other operationsB.4.10 Associative container operationsB.5 AlgorithmsB.5.1 Nonmodifying sequence algorithmsB.5.2 Modifying sequence algorithmsB.5.3 Utility algorithmsB.5.4 Sorting and searchingB.5.5 Set algorithmsB.5.6 HeapsB.5.7 PermutationsB.5.8 min and maxB.6 STL utilitiesB.6.1 InsertersB.6.2 Function objectsB.6.3 pair and tupleB.6.4 initializer_listB.6.5 Resource management pointersB.7 I/O streamsB.7.1 I/O streams hierarchyB.7.2 Error handlingB.7.3 Input operationsB.7.4 Output operationsB.7.5 FormattingB.7.6 Standard manipulatorsB.8 String manipulationB.8.1 Character classificationB.8.2 StringB.8.3 Regular expression matchingB.9 NumericsB.9.1 Numerical limitsB.9.2 Standard mathematical functionsB.9.3 ComplexB.9.4 valarrayB.9.5 Generalized numerical algorithmsB.9.6 Random numbersB.10 TimeB.11 C standard library functionsB.11.1 FilesB.11.2 The printf() familyB.11.3 C-style stringsB.11.4 MemoryB.11.5 Date and timeB.11.6 Etc.B.12 Other libraries
C.1 Getting a program to runC.2 Installing Visual StudioC.3 Creating and running a programC.3.1 Create a new projectC.3.2 Use the std_lib_facilities.h header fileC.3.3 Add a C++ source file to the projectC.3.4 Enter your source codeC.3.5 Build an executable programC.3.6 Execute the programC.3.7 Save the programC.4 Later
D.1 IntroductionD.2 Downloading FLTKD.3 Installing FLTKD.4 Using FLTK in Visual StudioD.5 Testing if it all worked
E.1 Callback implementationE.2 Widget implementationE.3 Window implementationE.4 Vector_refE.5 An example: manipulating Widgets

Content preview from Programming: Principles and Practice Using C++, 2nd Edition

26. Testing

“I have only proved the code correct, not tried it.”

—Donald Knuth

This chapter covers testing and design for correctness. These are huge topics, so we can only scratch their surfaces. The emphasis is on giving some practical ideas and techniques for testing units, such as functions and classes, of a program. We discuss the use of interfaces and the selection of tests to run against them. We emphasize the importance of designing systems to simplify testing and the use of testing from the earliest stages of development. Proving programs correct and dealing with performance problems are also briefly considered.

26.1 What we want

26.1.1 Caveat

26.2 Proofs

26.3 Testing

26.3.1 Regression tests

26.3.2 Unit tests

26.3.3 Algorithms and non-algorithms ...