Question? Leave a message!




Lecture Notes c++ Programming

lecture notes on object oriented programming using c++ and bject oriented programming c++ lecture notes pdf free download
HowdyNicolson Profile Pic
HowdyNicolson,France,Professional
Published Date:09-07-2017
Website URL
Comment
Fundamentals of ++ C Programming Richard L. Halterman School of Computing Southern Adventist University June 2, 2017 DRAFTCopyright © 2008–2017 Richard L. Halterman. All rights reserved.i Contents 1 The Context of Software Development 1 1.1 Software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 1.2 Development Tools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 1.3 Learning Programming with C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 1.4 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 2 Writing a C++ Program 7 2.1 General Structure of a Simple C++ Program . . . . . . . . . . . . . . . . . . . . . . . . . 7 2.2 Editing, Compiling, and Running the Program . . . . . . . . . . . . . . . . . . . . . . . . 8 2.3 Variations of our simple program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 2.4 Template for simple C++ programs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 2.5 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 3 Values and Variables 15 3.1 Integer Values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 3.2 Variables and Assignment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 3.3 Identifiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 3.4 Additional Integer Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 3.5 Floating-point Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 3.6 Constants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 3.7 Other Numeric Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 3.8 Characters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 3.9 Enumerated Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 3.10 Type Inference with auto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 3.11 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 4 Expressions and Arithmetic 37 ©2017 Richard L. Halterman Draft date: June 2, 2017CONTENTS ii 4.1 Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 4.2 Mixed Type Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 4.3 Operator Precedence and Associativity . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 4.4 Comments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 4.5 Formatting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 4.6 Errors and Warnings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 4.6.1 Compile-time Errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 4.6.2 Run-time Errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 4.6.3 Logic Errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52 4.6.4 Compiler Warnings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 4.7 Arithmetic Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 4.8 Integers vs. Floating-point Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 4.8.1 Integer Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 4.8.2 Floating-point Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64 4.9 More Arithmetic Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 4.10 Bitwise Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 4.11 Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 4.12 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 5 Conditional Execution 85 5.1 Type bool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 5.2 Boolean Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 5.3 The Simple if Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 5.4 Compound Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91 5.5 The if/else Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 5.6 Compound Boolean Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 5.7 Nested Conditionals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100 5.8 Multi-way if/else Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111 5.9 Errors in Conditional Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116 5.10 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117 6 Iteration 123 6.1 The while Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123 6.2 Nested Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133 6.3 Abnormal Loop Termination . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140 ©2017 Richard L. Halterman Draft date: June 2, 2017CONTENTS iii 6.3.1 The break statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140 6.3.2 The goto Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141 6.3.3 The continue Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143 6.4 Infinite Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144 6.5 Iteration Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148 6.5.1 Drawing a Tree . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148 6.5.2 Printing Prime Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150 6.6 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153 7 Other Conditional and Iterative Statements 159 7.1 The switch Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159 7.2 The Conditional Operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164 7.3 The do/while Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165 7.4 The for Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167 7.5 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173 8 Using Functions 179 8.1 Introduction to Using Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181 8.2 Standard Math Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186 8.3 Maximum and Minimum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190 8.4 clock Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191 8.5 Character Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192 8.6 Random Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193 8.7 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197 9 Writing Functions 201 9.1 Function Basics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202 9.2 Using Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210 9.3 Pass by Value . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215 9.4 Function Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217 9.4.1 Better Organized Prime Generator . . . . . . . . . . . . . . . . . . . . . . . . . . 217 9.4.2 Command Interpreter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219 9.4.3 Restricted Input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220 9.4.4 Better Die Rolling Simulator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222 9.4.5 Tree Drawing Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223 ©2017 Richard L. Halterman Draft date: June 2, 2017CONTENTS iv 9.4.6 Floating-point Equality . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224 9.4.7 Multiplication Table with Functions . . . . . . . . . . . . . . . . . . . . . . . . . 227 9.5 Commenting Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230 9.6 Custom Functions vs. Standard Functions . . . . . . . . . . . . . . . . . . . . . . . . . . 231 9.7 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233 10 Managing Functions and Data 239 10.1 Global Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239 10.2 Static Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247 10.3 Overloaded Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249 10.4 Default Arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250 10.5 Recursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252 10.6 Making Functions Reusable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258 10.7 Pointers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264 10.8 Reference Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269 10.9 Pass by Reference . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271 10.9.1 Pass by Reference via Pointers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272 10.9.2 Pass by Reference via References . . . . . . . . . . . . . . . . . . . . . . . . . . 274 10.10Higher-order Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275 10.11Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278 11 Sequences 287 11.1 Vectors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289 11.1.1 Declaring and Using Vectors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289 11.1.2 Traversing a Vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293 11.1.3 Vector Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297 11.1.4 Vectors and Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300 11.1.5 Multidimensional Vectors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305 11.2 Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309 11.2.1 Static Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309 11.2.2 Pointers and Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314 11.2.3 Dynamic Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320 11.2.4 Copying an Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324 11.2.5 Multidimensional Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328 11.2.6 C Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331 ©2017 Richard L. Halterman Draft date: June 2, 2017CONTENTS v 11.2.7 Command-line Arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334 11.3 Vectors vs. Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336 11.4 Prime Generation with a Vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339 11.5 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342 12 Sorting and Searching 349 12.1 Sorting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349 12.2 Flexible Sorting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352 12.3 Search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354 12.3.1 Linear Search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354 12.3.2 Binary Search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357 12.4 Vector Permutations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367 12.5 Randomly Permuting a Vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373 12.6 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379 13 Standard C++ Classes 381 13.1 String Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382 13.2 Input/Output Streams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386 13.3 File Streams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389 13.4 Complex Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395 13.5 Better Pseudorandom Number Generation . . . . . . . . . . . . . . . . . . . . . . . . . . 396 14 Custom Objects 405 14.1 Object Basics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405 14.2 Instance Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407 14.3 Member Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413 14.4 Constructors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420 14.5 Defining a New Numeric Type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423 14.6 Encapsulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425 14.7 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 428 15 Fine Tuning Objects 435 15.1 Passing Object Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435 15.2 Pointers to Objects and Object Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437 15.3 Thethis Pointer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 440 15.4 const Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443 ©2017 Richard L. Halterman Draft date: June 2, 2017CONTENTS vi 15.5 Separating Method Declarations and Definitions . . . . . . . . . . . . . . . . . . . . . . . 444 15.6 Preventing Multiple Inclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 451 15.7 Overloaded Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454 15.7.1 Operator Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454 15.7.2 Operator Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 457 15.8 static Members . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 458 15.9 Classes vs. structs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 462 15.10Friends . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 463 15.11Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 468 16 Building some Useful Classes 469 16.1 A Better Rational Number Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 469 16.2 Stopwatch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 471 16.3 Sorting with Logging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 477 16.4 Automating Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 481 16.5 Convenient High-quality Pseudorandom Numbers . . . . . . . . . . . . . . . . . . . . . . 485 17 Inheritance and Polymorphism 489 17.1 I/O Stream Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 489 17.2 Inheritance Mechanics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 491 17.3 Uses of Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493 17.4 Polymorphism . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 501 17.5 Protected Members . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 507 17.6 Fine Tuning Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 515 17.7 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 524 18 Memory Management 527 ++ 18.1 Memory Available to C Programs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527 18.2 Manual Memory Management . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 528 18.3 Linked Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 533 18.4 Resource Management . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 542 18.5 Rvalue References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 562 18.6 Smart Pointers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 573 19 Generic Programming 591 19.1 Function Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 591 ©2017 Richard L. Halterman Draft date: June 2, 2017CONTENTS vii 19.2 Class Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 602 19.3 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 615 20 The Standard Template Library 617 20.1 Containers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 617 20.2 Iterators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 619 20.3 Iterator Ranges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 623 20.4 Lambda Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 633 20.5 Algorithms in the Standard Library . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 639 20.6 Namespaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 657 21 Associative Containers 665 21.1 Associative Containers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 665 21.2 Thestd::set Data Type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 665 21.3 Tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 671 21.4 Thestd::map Data Type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 674 21.5 Thestd::unordered_map Data Type . . . . . . . . . . . . . . . . . . . . . . . . . . 678 21.6 Counting with Associative Containers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 680 21.7 Grouping with Associative Containers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 685 21.8 Memoization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 688 22 Handling Exceptions 695 22.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 695 22.2 Exception Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 696 22.3 Custom Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 704 22.4 Catching Multiple Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 706 22.5 Exception Mechanics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 709 22.6 Using Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 712 Appendices 717 A Using Visual Studio 2015 to Develop C++ Programs 717 B Command Line Development 723 B.0.1 Visual Studio Command Line Tools . . . . . . . . . . . . . . . . . . . . . . . . . 724 B.0.2 Developing C++ Programs with the GNU Tools . . . . . . . . . . . . . . . . . . . 726 ©2017 Richard L. Halterman Draft date: June 2, 2017CONTENTS viii Bibliography 728 Index 729 ©2017 Richard L. Halterman Draft date: June 2, 2017ix Preface Legal Notices and Information Permission is hereby granted to make hardcopies and freely distribute the material herein under the following conditions: • The copyright and this legal notice must appear in any copies of this document made in whole or in part. • None of material herein can be sold or otherwise distributed for commercial purposes without written permission of the copyright holder. • Instructors at any educational institution may freely use this document in their classes as a primary or optional textbook under the conditions specified above. A local electronic copy of this document may be made under the terms specified for hard copies: • The copyright and these terms of use must appear in any electronic representation of this document made in whole or in part. • None of material herein can be sold or otherwise distributed in an electronic form for commercial purposes without written permission of the copyright holder. • Instructors at any educational institution may freely store this document in electronic form on a local server as a primary or optional textbook under the conditions specified above. Additionally, a hardcopy or a local electronic copy must contain the uniform resource locator (URL) providing a link to the original content so the reader can check for updated and corrected content. The current standard URL ishttp://python.cs.southern.edu/cppbook/progcpp.pdf. If you are an instructor using this book in one or more of your courses, please let me know. Keeping track of how and where this book is used helps me justify to my employer that it is providing a useful service to the community and worthy of the time I spend working on it. Simply send a message tohaltermansouthern.edu with your name, your institution, and the course(s) in which you use it. The source code for all labeled listings is available at https://github.com/halterman/CppBook-SourceCode. ©2017 Richard L. Halterman Draft date: June 2, 20171 Chapter 1 The Context of Software Development A computer program, from one perspective, is a sequence of instructions that dictate the flow of electri- cal impulses within a computer system. These impulses affect the computer’s memory and interact with the display screen, keyboard, mouse, and perhaps even other computers across a network in such a way as to produce the “magic” that permits humans to perform useful tasks, solve high-level problems, and play games. One program allows a computer to assume the role of a financial calculator, while another transforms the machine into a worthy chess opponent. Note the two extremes here: • at the lower, more concrete level electrical impulses alter the internal state of the computer, while • at the higher, more abstract level computer users accomplish real-world work or derive actual plea- sure. So well is the higher-level illusion achieved that most computer users are oblivious to the lower-level activity (the machinery under the hood, so to speak). Surprisingly, perhaps, most programmers today write software at this higher, more abstract level also. An accomplished computer programmer can develop sophisticated software with little or no interest or knowledge of the actual computer system upon which it runs. Powerful software construction tools hide the lower-level details from programmers, allowing them to solve problems in higher-level terms. The concepts of computer programming are logical and mathematical in nature. In theory, computer programs can be developed without the use of a computer. Programmers can discuss the viability of a program and reason about its correctness and efficiency by examining abstract symbols that correspond to the features of real-world programming languages but appear in no real-world programming language. While such exercises can be very valuable, in practice computer programmers are not isolated from their machines. Software is written to be used on real computer systems. Computing professionals known as software engineers develop software to drive particular systems. These systems are defined by their underlying hardware and operating system. Developers use concrete tools like compilers, debuggers, and profilers. This chapter examines the context of software development, including computer systems and tools. ©2017 Richard L. Halterman Draft date: June 2, 20171.1. SOFTWARE 2 1.1 Software A computer program is an example of computer software. Software makes a computer a truly universal machine transforming it into the proper tool for the task at hand. One can refer to a program as a piece of software as if it were a tangible object, but software is actually quite intangible. It is stored on a medium. A hard drive, a CD, a DVD, and a USB pen drive are all examples of media upon which software can reside. The CD is not the software; the software is a pattern on the CD. In order to be used, software must be stored in the computer’s memory. Typically computer programs are loaded into memory from a medium like the computer’s hard disk. An electromagnetic pattern representing the program is stored on the computer’s hard drive. This pattern of electronic symbols must be transferred to the computer’s memory before the program can be executed. The program may have been installed on the hard disk from a CD or from the Internet. In any case, the essence that was transferred from medium to medium was a pattern of electronic symbols that direct the work of the computer system. These patterns of electronic symbols are best represented as a sequence of zeroes and ones, digits from the binary (base 2) number system. An example of a binary program sequence is 10001011011000010001000001001110 To the underlying computer hardware, specifically the processor, a zero here and three ones there might mean that certain electrical signals should be sent to the graphics device so that it makes a certain part of the display screen red. Unfortunately, only a minuscule number of people in the world would be able to produce, by hand, the complete sequence of zeroes and ones that represent the program Microsoft Word for an Intel-based computer running the Windows 8 operating system. Further, almost none of those who could produce the binary sequence would claim to enjoy the task. The Word program for older Mac OS X computers using a PowerPC processor works similarly to the Windows version and indeed is produced by the same company, but the program is expressed in a com- pletely different sequence of zeroes and ones The Intel Core i7 processor in the Windows machine accepts a completely different binary language than the PowerPC processor in the Mac. We say the processors have their own machine language. 1.2 Development Tools If very few humans can (or want) to speak the machine language of the computers’ processors and software is expressed in this language, how has so much software been developed over the years? Software can be represented by printed words and symbols that are easier for humans to manage than binary sequences. Tools exist that automatically convert a higher-level description of what is to be done ++ into the required lower-level code. Higher-level programming languages like C allow programmers to express solutions to programming problems in terms that are much closer to a natural language like English. Some examples of the more popular of the hundreds of higher-level programming languages that have been devised over the past 60 years include FORTRAN, COBOL, Lisp, Haskell, C, Perl, Python, Java, and C. Most programmers today, especially those concerned with high-level applications, usually do not worry about the details of underlying hardware platform and its machine language. One might think that ideally such a conversion tool would accept a description in a natural language, such as English, and produce the desired executable code. This is not possible today because natural languages are quite complex compared to computer programming languages. Programs called compilers that translate one computer language into another have been around for over 60 years, but natural language ©2017 Richard L. Halterman Draft date: June 2, 20171.2. DEVELOPMENT TOOLS 3 processing is still an active area of artificial intelligence research. Natural languages, as they are used by most humans, are inherently ambiguous. To understand properly all but a very limited subset of a natural language, a human (or artificially intelligent computer system) requires a vast amount of background knowledge that is beyond the capabilities of today’s software. Fortunately, programming languages provide a relatively simple structure with very strict rules for forming statements that can express a solution to any problem that can be solved by a computer. ++ Consider the following program fragment written in the C programming language: subtotal = 25; tax = 3; total = subtotal + tax; ++ These three lines do not make up a complete C program; they are merely a piece of a program. The statements in this program fragment look similar to expressions in algebra. We see no sequence of bi- nary digits. Three words, subtotal, tax, and total, called variables, are used to hold information. Mathematicians have used variables for hundreds of years before the first digital computer was built. In programming, a variable represents a value stored in the computer’s memory. Familiar operators (= and +) are used instead of some cryptic binary digit sequence that instructs the processor to perform the operation. ++ Since this program is expressed in the C language, not machine language, it cannot be executed directly ++ ++ on any processor. A C compiler is used to translate the C code into machine code. The higher-level language code is called source code. The compiled machine language code is called the target code. The compiler translates the source code into the target machine language. ++ The beauty of higher-level languages is this: the same C source code can be compiled to different ++ target platforms. The target platform must have a C compiler available. Minor changes in the source code may be required because of architectural differences in the platforms, but the work to move the program from one platform to another is far less than would be necessary if the program for the new platform had to be rewritten by hand in the new machine language. Just as importantly, when writing the program the ++ human programmer is free to think about writing the solution to the problem in C , not in a specific machine language. Programmers have a variety of tools available to enhance the software development process. Some common tools include: • Editors. An editor allows the user to enter the program source code and save it to files. Most pro- gramming editors increase programmer productivity by using colors to highlight language features. The syntax of a language refers to the way pieces of the language are arranged to make well-formed sentences. To illustrate, the sentence The tall boy runs quickly to the door. uses proper English syntax. By comparison, the sentence Boy the tall runs door to quickly the. is not correct syntactically. It uses the same words as the original sentence, but their arrangement does not follow the rules of English. Similarly, programmers must follow strict syntax rules to create well-formed computer programs. Only well-formed programs are acceptable and can be compiled and executed. Some syntax-aware editors can use colors or other special annotations to alert programmers of syntax errors before the program is compiled. ©2017 Richard L. Halterman Draft date: June 2, 20171.2. DEVELOPMENT TOOLS 4 Figure 1.1 Source code to target code sequence Concept of (Design problem program logic) solution Programmer’s Editor (Edit) responsibility include io using namespace std; Source code int main() srand(23); int n; n = rand(); proc(n); Library declarations (source code) istream cin; ostream cout; int rand(); Preprocessor (Preprocess) void sand(); typedef unsigned U define NULL (0) include io using namespace std; Enhanced int main() srand(23); int n; source code n = rand(); proc(n); Automated Compiler (Compile) by tools 101100010101 Object code 000010001100 1100001111010100 0011101101110011 1000000010000110 0111000000111111 1100111011001001 0000100001111000 0001110111101101 Pre-compiled 1101111011111010 libraries (object code) 11000011110 00111011011 1000000010000110 Linker 0111000000111111 (Link) 1100111011001001 0000100001111000 0001110111101101 1101111011111010 101100010101 000010001100 1100001111010100 0011101101110011 Executable 1000000010000110 0111000000111111 1100111011001001 program 0000100001111000 0001110111101101 1101111011111010 ©2017 Richard L. Halterman Draft date: June 2, 20171.2. DEVELOPMENT TOOLS 5 • Compilers. A compiler translates the source code to target code. The target code may be the machine language for a particular platform or embedded device. The target code could be another source ++ ++ language; for example, the earliest C compiler translated C into C, another higher-level language. ++ The resulting C code was then processed by a C compiler to produce an executable program. C ++ compilers today translate C directly into machine language. ++ The complete set of build tools for C includes a preprocessor, compiler, and linker: – Preprocessor—adds to or modifies the contents of the source file before the compiler begins processing the code. We use the services of the preprocessor mainly toinclude information about library routines our programs use. ++ – Compiler—translates C source code to machine code. – Linker—combines the compiler-generated machine code with precompiled library code or compiled code from other sources to make a complete executable program. Most compiled ++ C code is incapable of running by itself and needs some additional machine code to make a complete executable program. The missing machine code has been precompiled and stored in a repository of code called a library. A program called a linker combines the programmer’s compiled code and the library code to make a complete program. We generally do not think about the preprocessor, compiler, and linker working as three separate programs (although they do); the tools we use make it appear as only one process is taking place: translating our source code to an executable program. • Debuggers. A debugger allows a programmer to more easily trace a program’s execution in order to locate and correct errors in the program’s implementation. With a debugger, a developer can simultaneously run a program and see which line in the source code is responsible for the program’s current actions. The programmer can watch the values of variables and other program elements to see if their values change as expected. Debuggers are valuable for locating errors (also called bugs) and repairing programs that contain errors. (See Section 4.6 for more information about programming errors.) • Profilers. A profiler collects statistics about a program’s execution allowing developers to tune ap- propriate parts of the program to improve its overall performance. A profiler indicates how many times a portion of a program is executed during a particular run, and how long that portion takes to execute. Profilers also can be used for testing purposes to ensure all the code in a program is actually being used somewhere during testing. This is known as coverage. It is common for software to fail after its release because users exercise some part of the program that was not executed anytime during testing. The main purpose of profiling is to find the parts of a program that can be improved to make the program run faster. The programming components of the development process are illustrated in Figure 1.1. Many developers use integrated development environments (IDEs). An IDE includes editors, debug- ++ gers, and other programming aids in one comprehensive program. Examples of IDEs for C include Microsoft’s Visual Studio 2015, the Eclipse Foundation’s Eclipse CDT, and Apple’s XCode. Despite the plethora of tools (and tool vendors’ claims), the programming process for all but trivial programs is not automatic. Good tools are valuable and certainly increase the productivity of developers, but they cannot write software. There are no substitutes for sound logical thinking, creativity, common sense, and, of course, programming experience. ©2017 Richard L. Halterman Draft date: June 2, 20171.3. LEARNING PROGRAMMING WITH C++ 6 1.3 Learning Programming with C++ ++ ++ Bjarne Stroustrup of AT&T Bell Labs created C in the mid 1980s. C is an extension of the programming language C, a product of AT&T Bell Labs from the early 1970s. C was developed to write the Unix operating system, and C is widely used for systems-level software and embedded systems development. ++ C initially provided object-oriented programming features (see Chapter 13 and Chapter 14) and later ++ ++ added generic programming capabilities. C ’s close relationship to C allows C programs to utilize a large collection of code developed in C. ++ C is widely used in industry for commercial software development. It is an industrial strength pro- gramming language used for developing complex systems in business, science, and engineering. Examples ++ of software written in C include Microsoft Windows 8, Microsoft Office, macOS, and Adobe Creative Suite. ++ In order to meet the needs of commercial software development and accomplish all that it does, C ++ itself is complex. While experienced programmers can accomplish great things with C , beginners some- times have a difficult time with it. Professional software developers enjoy the flexible design options that ++ C permits, but beginners need more structure and fewer options so they can master simpler concepts before moving on to more complex ones. ++ This book does not attempt to cover all the facets of the C programming language. Experienced ++ programmers should look elsewhere for books that cover C in much more detail. The focus here is on introducing programming techniques and developing good habits. To that end, our approach avoids some of ++ the more esoteric features of C and concentrates on the programming basics that transfer directly to other imperative programming languages such as Java, C, and Python. We stick with the basics and explore ++ more advanced features of C only when necessary to handle the problem at hand. 1.4 Exercises 1. What is a compiler? 2. How is compiled code different from source code? ++ 3. What tool does a programmer use to produce C source code? ++ 4. What tool(s) does a programmer use to convert C source code into executable machine code? 5. What does the linker do? 6. Does the linker deal with files containing source code or or machine language code? 7. What does the preprocessor do to source code? 8. List several advantages developing software in a higher-level language has over developing software in machine language. 9. How can an IDE improve a programmer’s productivity? ++ 10. Name a popular C IDE is used by programmers developing for Microsoft Windows. ++ 11. Name a popular C IDE is used by programmers developing for Apple macOS. ©2017 Richard L. Halterman Draft date: June 2, 20177 Chapter 2 Writing a C++ Program ++ Properly written C programs have a particular structure. The syntax must be correct, or the compiler ++ will generate error messages and not produce executable machine language. This chapter introduces C by providing some simple example programs and associated fundamental concepts. Most of the concepts presented in this chapter are valid in many other programming languages as well. While other languages may implement the concepts using slightly different syntax, the ideas are directly transferable to other languages like C, Java, C, and Ada. 2.1 General Structure of a Simple C++ Program ++ Listing 2.1 (simple.cpp) is one of the simplest C programs that does something: Listing 2.1: simple.cpp include iostream int main() std::cout "This is a simple C++ program\n"; You can type the text as shown in Listing 2.1 (simple.cpp) into an editor and save it to a file named simple.cpp. The actual name of the file is irrelevant, but the name “simple” accurately describes the nature ++ of this program. The extension .cpp is a common extension used for C source code. After creating this file with a text editor and compiling it, you can run the program. The program prints the message This is a simple C++ program Listing 2.1 (simple.cpp) contains four non-blank lines of code: • include iostream ++ This line is a preprocessing directive. All preprocessing directives within C source code begin with a symbol. This one directs the preprocessor to add some predefined source code to our existing ©2017 Richard L. Halterman Draft date: June 2, 20172.2. EDITING, COMPILING, AND RUNNING THE PROGRAM 8 source code before the compiler begins to process it. This process is done automatically and is invisible to us. ++ Here we want to use an object from theiostream library, a collection precompiled C code that ++ C programs (like ours) can use. The iostream library contains elements that handle input and output (I/O)—printing to the display, getting user input from the keyboard, and dealing with files. ++ One of the items used in Listing 2.1 (simple.cpp),std::cout, is not part of the C language itself. ++ This item, along with other things related to input and output, were developed in C , compiled, and stored in the iostream library. The compiler needs to be aware of these iostream items so it can compile our program. The include directive specifies a file, called a header, that contains the specifications for the library code. The compiler checks how we use std::cout within our code against its specification in theiostream header to ensure that we are using the library code correctly. Most of the programs we write use this include iostream directive, and some programs we will write in the future willinclude other headers as well. • int main() This specifies the real beginning of our program. Here we are declaring a function namedmain. All ++ C programs must contain this function to be executable. Details about the meaning of int and the parentheses will appear in later chapters. More general information about functions appear in Chapter 8 and Chapter 9. The opening curly brace at the end of the line marks the beginning of the body of a function. The body of a function contains the statements the function is to execute. • std::cout "This is a simple C++ program\n"; The body of our main function contains only one statement. This statement directs the executing program to print the message This is a simple C++ program on the screen. A statement is the ++ fundamental unit of execution in a C program. Functions contain statements that the compiler ++ translates into executable machine language instructions. C has a variety of different kinds of statements, and the chapters that follow explore these various kinds of statements. All statements in ++ C end with a semicolon (;). A more detailed explanation of this statement appears below. • The closing curly brace marks the end of the body of a function. Both the open curly brace and close curly brace are required for every function definition. Note which lines in the program end with a semicolon (;) and which do not. Do not put a semicolon after the include preprocessor directive. Do not put a semicolon on the line containingmain, and do not put semicolons after the curly braces. 2.2 Editing, Compiling, and Running the Program ++ ++ C programmers have two options for C development environments. One option involves a command- line environment with a collection of independent tools. The other option is to use an IDE (see Section 1.2) which combines all the tools into a convenient package. Visual Studio is the dominant IDE on the Microsoft ©2017 Richard L. Halterman Draft date: June 2, 20172.3. VARIATIONS OF OUR SIMPLE PROGRAM 9 Windows platform, and Apple Mac developers often use the XCode IDE. Appendix A provides an overview ++ of how to use the Visual Studio 2015 IDE to develop a simple C program. The myriad of features and configuration options in these powerful IDEs can be bewildering to those learning how to program. In a command-line environment the programmer needs only type a few simple commands into a console window to edit, compile, and execute programs. Some developers prefer the simplicity and flexibility of command-line build environments, especially for less complex projects. One prominent command-line build system is the GNU Compiler Collection (http://gcc.gnu. ++ org), or GCC for short. The GCC C++ compiler, called g++, is one of most C standards conforming ++ compilers available. The GCC C compiler toolset is available for the Microsoft Windows, Apple Mac, and Linux platforms, and it is a free, open-source software project with a world-wide development team. ++ Appendix B provides an overview of how to use the GCC C compiler. Visual Studio and XCode offer command line development options as well. Appendix B provides an overview of the Visual Studio command line development process. 2.3 Variations of our simple program Listing 2.2 (simple2.cpp) shows an alternative way of writing Listing 2.1 (simple.cpp). Listing 2.2: simple2.cpp include iostream using std::cout; int main() cout "This is a simple C++ program\n"; The using directive in Listing 2.2 (simple2.cpp) allows us to use a shorter name for the std::cout printing object. We can omit thestd:: prefix and use the shorter name,cout. This directive is optional, but if we omit it, we must use the longer name. The namestd stands for “standard,” and thestd prefix indicates thatcout is part of a collection of names called the standard namespace. Thestd namespace ++ holds names for all the standard C types and functions that must be available to all standards-conforming ++ C development environments. Components outside the standard library provided by third-party develop- ers reside in their own separately-named namespaces. These include open-source projects and commercial libraries. ++ Listing 2.3 (simple3.cpp) shows another way to use the shorter name forcout within a C program. Listing 2.3: simple3.cpp include iostream using namespace std; int main() cout "This is a simple C++ program\n"; While Listing 2.2 (simple2.cpp) made the name cout known to the compiler via its focused using di- rective, Listing 2.3 (simple3.cpp) provides a blanket using directive that makes all names in the std ©2017 Richard L. Halterman Draft date: June 2, 2017