Contents
1 The Context of Software Development 1
1.1 Software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Development Tools . . . . . . . . . . . . . . . . . . . . . .
...
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: April 16, 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: April 16, 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: April 16, 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 285
11.1 Vectors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
11.1.1 Declaring and Using Vectors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
11.1.2 Traversing a Vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291
11.1.3 Vector Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
11.1.4 Vectors and Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298
11.1.5 Multidimensional Vectors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303
11.2 Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307
11.2.1 Static Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307
11.2.2 Pointers and Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312
11.2.3 Dynamic Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318
11.2.4 Copying an Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322
11.2.5 Multidimensional Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326
11.2.6 C Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329
©2017 Richard L. Halterman Draft date: April 16, 2017CONTENTS v
11.2.7 Command-line Arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332
11.3 Vectors vs. Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334
11.4 Prime Generation with a Vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337
11.5 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 340
12 Sorting and Searching 347
12.1 Sorting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347
12.2 Flexible Sorting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350
12.3 Search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352
12.3.1 Linear Search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352
12.3.2 Binary Search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355
12.4 Vector Permutations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 365
12.5 Randomly Permuting a Vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371
12.6 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377
13 Standard C++ Classes 379
13.1 String Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380
13.2 Input/Output Streams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384
13.3 File Streams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387
13.4 Complex Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393
13.5 Better Pseudorandom Number Generation . . . . . . . . . . . . . . . . . . . . . . . . . . 394
14 Custom Objects 403
14.1 Object Basics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403
14.2 Instance Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405
14.3 Member Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411
14.4 Constructors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 418
14.5 Defining a New Numeric Type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 421
14.6 Encapsulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423
14.7 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426
15 Fine Tuning Objects 433
15.1 Passing Object Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433
15.2 Pointers to Objects and Object Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435
15.3 The this Pointer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438
15.4 const Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 441
©2017 Richard L. Halterman Draft date: April 16, 2017CONTENTS vi
15.5 Separating Method Declarations and Definitions . . . . . . . . . . . . . . . . . . . . . . . 442
15.6 Preventing Multiple Inclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 449
15.7 Overloaded Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 452
15.7.1 Operator Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 452
15.7.2 Operator Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455
15.8 static Members . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456
15.9 Classes vs. structs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 460
15.10Friends . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 461
15.11Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 466
16 Building some Useful Classes 467
16.1 A Better Rational Number Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 467
16.2 Stopwatch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 469
16.3 Sorting with Logging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 475
16.4 Automating Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 479
16.5 Convenient High-quality Pseudorandom Numbers . . . . . . . . . . . . . . . . . . . . . . 483
17 Inheritance and Polymorphism 487
17.1 I/O Stream Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487
17.2 Inheritance Mechanics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 489
17.3 Uses of Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 491
17.4 Polymorphism . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 499
17.5 Protected Members . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 505
17.6 Fine Tuning Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513
17.7 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 522
18 Memory Management 525
18.1 Memory Available to C++ Programs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 525
18.2 Manual Memory Management . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 526
18.3 Linked Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 531
18.4 Resource Management . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 540
18.5 Rvalue References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 560
18.6 Smart Pointers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 571
19 Generic Programming 589
19.1 Function Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 589
©2017 Richard L. Halterman Draft date: April 16, 2017CONTENTS vii
19.2 Class Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 600
19.3 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 613
20 The Standard Template Library 615
20.1 Containers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 615
20.2 Iterators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 617
20.3 Iterator Ranges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 621
20.4 Lambda Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 631
20.5 Algorithms in the Standard Library . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 637
20.6 Namespaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 655
21 Associative Containers 663
21.1 Associative Containers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 663
21.2 The std::set Data Type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 663
21.3 Tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 669
21.4 The std::map Data Type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 672
21.5 The std::unordered_map Data Type . . . . . . . . . . . . . . . . . . . . . . . . . . 676
21.6 Counting with Associative Containers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 678
21.7 Grouping with Associative Containers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 682
21.8 Memoization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 685
22 Handling Exceptions 693
22.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 693
22.2 Exception Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 694
22.3 Custom Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 702
22.4 Catching Multiple Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 704
22.5 Exception Mechanics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 707
22.6 Using Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 710
Appendices 715
A Using Visual Studio 2015 to Develop C++ Programs 715
B Command Line Development 721
B.0.1 Visual Studio Command Line Tools . . . . . . . . . . . . . . . . . . . . . . . . . 722
B.0.2 Developing C++ Programs with the GNU Tools . . . . . . . . . . . . . . . . . . . 724
©2017 Richard L. Halterman Draft date: April 16, 2017CONTENTS viii
Bibliography 726
Index 727
[Show More]
.png)
