C++ In Action: Industrial-Strength Programming Techniques

C++ In Action: Industrial-Strength Programming Techniques picks up where the standard tutorial leaves off, providing a fresh perspective on the language for both the novice and seasoned C++ programmer. Focusing on programming technique, this book captures the essence of expression in C++, promoting a methodology that delivers robust, reliable, and elegant code.

This project-based tutorial begins with an overview of the language, stressing "conversational C++." Focusing on technique, C++ In Action describes how to avoid pitfalls and how to understand, modify, and debug C++. This book teaches the programmer how to write small, fast, reliable, and scalable programs within a sensible timeframe. In addition, it provides extensive coverage of Windows programming in C++ and the development of large-scale projects with the language.

Throughout this unique and comprehensive guide, the author offers tried and tested techniques for working with C++, including:

• How to make efficient use of the Standard Template Library in C++
• Implementation strategies in C++, including top-down object-oriented implementation
• Plusses and pitfalls of C++ for programmers with C or Java programming backgrounds
• Resource management and the use of exception handling in C++
• Windows programming in C++, including encapsulating the Windows API into C++ classes, namespaces, and templates
• How to refactor your program so that it can be ported from Windows to other platforms such as Linux
• The dynamics of large software project management–from conception to shipment
• How to coordinate the development of a team programming environment in C++

The accompanying CD-ROM contains all of the source code referenced in the book along with the Code Co-op™ serverless version control system (VCS), which will run all of the projects in this book. The companion Web site at http://www.relisoft.com/book contains updates and additional code samples.

Offering a unique perspective on C++, today’s language of choice for general-purpose programming, C++ In Action facilitates the transition from "weekend programmer" to "industrial-strength programmer" in a way no other tutorial can.

Sample Chapter(s)

Click below for Sample Chapter related to this title:
milewskich15 .pdf

Index

A
Abstract classes, pure virtual functions, 100
Abstract data types, 34–37
Abstraction layers, porting programs, 433–434
Abstraction method, program development, 405–406
Accelerators (Windows), 388
Acquisition Rules, resource management, 233–236
Active windows, 321–322
Addition (1) operators, 46
Aggregate data structures, initializing explicitly, 146–147
Allocating memory. See memory allocation
Amorphous data streams, 114
AND (&&) operators, 47–48
APIs (Windows), 322
&npsp:&npsp:&npsp&npsp:&npsp:&npspApplication icons, Windows programming, 345–349
Architectural specification, program development, 419–420
Arguments
&npsp:&npsp:&npspArithmetic operators, 46–47
Arithmetic tree nodes, polymorphism, 98–103
Array of characters, 28. See also strings
Arrays
&npsp:&npsp:&npspArrays of pointers, 73–74
Assertions, 35
Assignment (5) operators, 46, 154–156
&npsp:&npsp:&npspAssociative arrays, 257–261
Automatic objects, 9–16
B
Background color (Windows), 370–371
Base classes, 20
Big- and little-endian order, processors, 285
Binary bitwise operators, 49
Binary operators, 46
Bitwise AND (&) operators, 49
Bitwise complement (~) operators, 49
Bitwise exclusive OR (XOR) (^) operators, 49
Bitwise inclusive OR (|) operators, 49
Bitwise logic operators, 48–49
Bool (Boolean) type, 30
Boolean value arrays, 187
Brace-positioning convention, 15
Bugs. See debugging programs
(built-in types)
Built-in functions, calculator program, 127–134
Built-in types, 29–31
&npsp:&npsp:&npspC
C++ programming language, suggested readings, 66
Caching memory, 299–304
Calculator class, 277–280
Calculator program
&npsp:&npsp:&npspCalculator program (Windows)
&npsp:&npsp:&npspCalling conventions, 27
Calling member functions, 23–29
Canvas object (Windows), 350–354
Carriage return linefeed, 290
Casts
&npsp:&npsp:&npspChar (8-bit character) type, 30
Child windows (Windows), 375–377
Class definition, 6
  &npspClass-specific new operators
  &npspClasses
  &npspClient versus non-client areas, windows, 350
Clients of classes, 14
Closed hashing, 183
Collisions, hash table mapping, 90–91
Color, painting in Windows, 364–372
  &npspComma sequencing operators, 293–294
Commander object (Windows), 385–387
CommandParser class, 280–283
Commands (Windows), 384–387
Comments, double slash (//) convention, 17
Comparison operators, 47–48
Compilers (re-sort)
  &npspComplex type, 150–151
Complex numbers, 5
Complexity, program development
  &npspConstants, hiding
  &npspConstructors
  &npspContainers (safe), 246–250
  &npspControllers, 338–339
Controls (Windows), 322
  &npspConventions
  &npspConventions, C++ programming
  &npspConversion operator, HICON (Windows programming), 347
Copy constructors, 153–156
  &npspCopy-on-write (COW), 267–268
Countable nouns, 11
Counting serializers, 295
COW (copy-on-write), 267–268
CS_HREDRAW message, 356
CS_VREDRAW message, 356
D
DAG (directed acyclic graph), 382
Dangling pointers, 240
Data hiding, 175
  &npspData members, initializing, 17
Data structures
  &npspData types. See also types
  &npspDC (device context), Windows programming, 350–354
Debug builds, 35
Debugging programs, 203
  &npspDeclarations, rules for reading, 83-84, 130
Deep copies versus shallow copies, 154
Default constructors, 159
Defensive programming, 171–173
  &npspDeque, 356
Derived classes, 20, 101
Deserialization/serialilzation of data structures, 294–295
Design strategies
  &npspDestructors
  &npspDevice context (DC), Windows programming, 350–354
Dialog boxes (Windows), 322, 394–400
Directed acyclic graph (DAG), 382
Divide-and-conquer method, program development, 405–406, 408–410
Division (/) operators, 46
Division modulo (%) operators, 46
Do/while loops, 51–55
Double (floating point) type, 30
Double colon (::) convention for Windows API functions, 323
Double slash (//)comments, 17
Dynamic arrays, 210–219
Dynamic data structures
  &npspDynamic menus (Windows), 387–394
E
Edit controls (Windows), 378
  &npspEmbedded classes, 191–193
  &npspEmbedded objects, 16–18. See also objects
  &npspEncapsulation (Windows), 329–330
Enum integral type, 111
Enumerations, hiding constants, 196–198
Equal to (55) operators, 47–48
  &npspError checking
  &npspError handling
  &npspError propagation, 253–254
Escape characters (\), 110
Exception handling, 226–228
  &npspExplicit initialization, arrays and classes, 127–134, 146–147
Explicit keyword, 122–123
Expressions, 108
External Specification, program development, 418–419
F
Factors, terms, 108
Float (floating point) type, 30
Fonts, proportional (Windows), 356
  &npspFor loops, 12–14, 16
Formal parameters, 10
Formatting, importance in programming, 5
FORTRAN programming language, complex built-in type, 150–151
Forward declarations, 124–125
Free functions, 160–161
  &npspFunction calls, definition, 70
Function objects (functors), 258–259
Function tables
  &npspFunction templates, 206–207
Functions, 4. See also built-in functions; free functions; member functions
  &npspFunctors, 258–259
G
GDI objects, painting in Windows, 367
GetCapture API, 359–364
Global operator new, 307
  &npspGlobal scope, 3–9, 199–200
Graphics programming (Windows), 354–356
  &npspGreater than (>) operators, 47–48
Greater than or equal to (>5) operators, 47–48
GWL_USERDATA window long, 334–335
H
Handle to Device Context (HDC), 351
Has-a relationship, objects, 17–18
Has-access-to relationship, 39, 236
Hash functions, 90–93
Hash tables, 84, 90–93
  &npspHDC (Handle to Device Context), 351
Header files, interfaces of objects, 34
Hiding data, 175, 198
  &npspHierarchy of Node classes, 135
I
Icon editors (Windows), 322
Icons (Windows), 322
Icons for applications, Windows programming, 345–349
Identifiers, 116–122
IDs for resources (Windows programming), 346
  &npspImplementation files, member functions, 34
Implementors of classes, 14
Implicit conversions, 122–123, 159
Inline member functions, 36–37
Include directives, definition, 7
Include files, compilers, 343
Include statements, 35
Index implementations, versus pointer implementations, 67–69
Inheritance
  &npspInitializing
  &npspInput/output streams, 271–275
Instantiating templates, 203
Instrumenting programs, 203
Int (signed integral) type, 30
Integral types
  &npspInterfaces of objects, 22
  &npspInverting objects, 181
Is-a relationships, objects, 18–19, 95–98
Iterators, 220–222, 251–252
  &npspK
Key types, maps, 258–261
Explicit, keyword 122–123
L
Left shift by n bits (<<) operators, 49
Less than (<) operators, 47–48
Less than or equal to (#) operators, 47–48
LIFO (last in, first out) data structure, 357
Link class, embedding, 191–193
Linked lists, 77–84
  &npspList box controls (Windows), 380–381
Literal strings, 28
Little- and big-endian order, processors, 285
Local scope, 9–16
  &npspLocal variable, hiding constants in, 198
Logical operators, 42–43, 47–48
Long (signed integral) type, 30
Long double (signed floating point) type, 30
Loops
  &npspM
Macros, 308–310
  &npspMain function, calculator program, 144–146
Managing resources. See resource management
Manipulators, definition, 28
Map template (STL), 258–261
Mapping-file scheme persistent transactions, 470–471
Maps, key and value types, 258–261
Member functions, 20–22. See also functions
  &npspMember templates, 243–244
  &npspMemory
  &npspMemory allocation
  &npspMenus (Windows), 322, 384–387
  &npspMessage boxes (Windows), 322
Message loops (Windows), 321–322
Messages, Windows programming, WM_USER
  &NPSPMetacode, 127–129, 134
Metaprograms, 127–129
Methods. See member functions
Minus (–) operators, 46–47
Modal dialog boxes, 397
Model-View-Controller triad (Windows), 332–337
  &npspMouse capture (Windows), 359–364
MultiDerived class, 296–297
MultiNode class, dynamic array templates, 214–215
Multiple inheritance, 296–297
Multiplication (*) operators, 46
Multitasking operating systems, Windows, 321
Mutable references. See pointers
N
Named objects (Windows), 367
Namespaces, 195–196
Naming conventions, C++ programming
  &npspNaming conventions, C++ programming, 196
  &npspNDEBUG flags, 35
New operators (class-specific)
  &npspNew operators (global), 307
  &npspNew operators (placement), 315–316
Node class, 135–137, 138–144
Nodes, arithmetic trees, polymorphism, 98–103
Non-inline member functions, 36–37
NOT (!) operators, 47–48
Not equal to (!5) operators, 47–48
Not-equal-to relationship, 43
Notification sinks (Windows), 381–384
Null pointers, 78
Numbers, real and complex, 5
O
Object-oriented programming (OOP)
  &npspObjects. See also embedded objects
  &npspOffensive programming, 173
OOP (object-oriented programming)
  &npspOperators, 45
  &npspOR (||) operators, 47–48
Output/input streams, 271–275
Overloading methods, 72
Overloading operators, 150–151, 158–164
  &npspOwnership of resources, 235
  &npspOwns-a relationships, 235
Owns-a relationships, objects, 75
P
Painting (Windows), 354–356
  &npspParent windows (Windows), 375
Perfect hashing, 90
Persistent transactions, 466–468
  &npspPlacement new operator, 315–316
Plus (1) operators, 46–47
  &npspPointers
  &npspPolymorphism
  &npspPre- and post-increment operators, 65, 251
Preamble, constructors, 15
Prepending, linked lists 79
Preprocessor directives, 55
Private classes, definition, 14
Private inheritance, 101–102
Private methods, 138–139
Procedural programming, 149–150
Procedures (Windows), 321–322
  &npspProcessors, big- and little-endian order, 285
Program development
  &npspProgramming
  &npspProgramming (procedural), 149–150
Programs, porting
  &npspProportional fonts (Windows), 356
Protected inheritance, 101–102
Public classes,
definition, 14
Public inheritance, 101–102
R
Reading declarations, rules, 130
Real numbers, 5
Reference counting, 262–268
References
  &npspRelationships, objects
  &npspRelease builds, 35
ReleaseCapture API, 359–364
Remote Procedure Calls (RPCs), 121
Requirement Specification, program development, 418–419
Reserve versus resize methods, 288
Resource management, 233–235
  &npspResources, IDs (Windows programming), 346
Right shift by n bits (>>S) operators, 49
RPCs (Remote Procedure Calls), 121
Rules of Acquisition, resource management, 233–236
S
Safe containers, 246–250
  &npspSafe pointers, 236–237
  &npspScanner class, 116–122
Scope. See Global scope; Local scope
Scope-resolution prefixes, classes, 193
Sequencers, 41–42
  &npspSerialilzation/deserialization of data structures, 294–295
Serializable class, 296–297
SetCapture API, 359–364
Shallow copies versus deep copies, 154
Short (signed integral) type, 30
Signatures
  &npspSigned integral types, 30
Smalltalk programming language
  &npspSmart pointers, 236–237
  &npspSoftware development. See program development
Stack based calculator program
  &npspStack objects, 9–16
Stack unwinding, 229–233
Standard library (C++)
  &npspStandard template library (STL). See also templates
  &npspStandard vectors, 219–223
Statements, 45
  &npspStatic text (Windows), 378
STL (standard template library). See also templates
  &npspStockObject class (Windows), 365
Store class, 124–127, 217–219
Streams (input/output), 271–275
String buffers, dynamic data structures, 87–89
String tables, 84–87
StringBuffer class, 215–216
Strings. See also array of characters
  &npspSubclassing (Windows), 379–380
Subtraction (–) operators, 46
Switch statements, 114–115
SymbolTable class, 122–124
T
Table lookups, 60, 89–90
Team work, program development
  &npspTemplates. See also STL (standard template library)
  &npspTenary operators, 293
Terms, factors, 108
Text (static), 378
Three-file scheme persistent transactions, 468–470
Toolbars (Windows), 388
Top-down analysis, 7
Top-down design, 50–51, 415–416
Top-down implementation
  &npspTransactions, 461–462
  &npspTransfer semantics, resource ownership, 240
Transient transactions, 462–466
Troubleshooting
  &npspTypedef type, 30–31
  &npspTypes, 29–31. See also built-in types; data types; user-defined types
  &npspU
UM_MEMCLEAR message, 394
Unary bitwise operators, 49
Unary operators, 46–47
Unsigned integral types, 30
Unsigned long integral types. See typedef type
Up casting, 243
User interfaces
  &npspdependent parts versus independent parts (Windows programming), 332–337
  &npspUser preferences, 199–200
User-defined types, value semantics, 157–164
V
Value semantics, 157–164, 258–261
Value strings, 158–163
  &npspValue types, maps, 258–261
Vectors (standard), 219–223
Deque, double-ended queue, 356 (under D)
Version numbers, data structures, 285
View object, painting (Windows), 350
Virtual destructors, 100
Virtual functions, 99
  &npspVirtual tables, polymorphism, 96–97
W
Wchar_t (16-bit character) type, 30
Windows API
  &npspWindows programming
  &npspWizards, Windows programming, 320
WM_CAPTURECHANGED message, 361–362
WM_COMMAND message, 378, 385–387, 394
WM_DESTROY message, 335–336
WM_GETMINMAXINFO message, 335–336
WM_INITMENUPOPUP message, 391
WM_LBUTTONDOWN message, 361
WM_LBUTTONUP message, 361
WM_MENUSELECT message, 392
WM_MOUSEMOVE message, 335–336
WM_NCCREATE message, 335–336, 338
WM_NCDESTROY message, 335–336
WM_NOTIFY message, 378
WM_PAINT message, 350, 352, 354–356, 369
WM_SETFOCUS message, 377
WM_SIZE message, 377
WM_USER message, 394

Preface

Why This Book?

Indeed, why YABOC11 (Yet Another Book on C11)? There are already many excellent books describing all imaginable aspects of C11. As far as learning the language and all kinds of programming tricks, the market is pretty much saturated. This book is not a language reference or a collection of clever tricks and patterns. This book is about programming.

Teaching programming is very different from teaching a language. A programmer is usually faced with a problem that he or she has to solve by writing a program—not with a language feature whose use he or she wants to illustrate. In this book I try to show, as much as possible, how to use the language as a tool to solve programming problems.

I center the presentation around various software projects. In each project I first describe a problem to be solved. Then I discuss what the program should do, what it should look like, and how it should react to user input. Based on that I build a scaffolding that captures the structure of the program without implementing its functionality. Finally, I implement the functionality, component by component.

But programming doesn’t stop there. What follows in this book is a long series of code reviews each followed by a rewrite. "How can this be done better?" is a question a programmer asks himself or herself constantly. And then another question becomes more and more relevant, "How do I write code that can be easily revised?"

In programming, as in life, there is never a single way to do something. That’s why being able to argue about various solutions is extremely important. Programmers who don’t know how to argue end up bitter and frustrated. I remember my own frustrations when faced with an argument like, "Because it’s always been done like this." In this book I argue a lot. I try to find the pros and cons of every solution, and in many cases I manage to settle on something I consider "elegant." However, I never use elegance as an objective criterion. I believe that one can always uncover some very practical arguments that are hidden behind the subjective impression of "elegance." An elegant solution in many cases catches a very good abstraction or generalization. It results in code that is easy to understand, modify, and debug.

Finally, in this book I emphasize the human factor in programming. My credo is "programs are written for programmers, not computers." Programmers want to write better programs not in order to make them more understandable to computers, but to make them more readable to humans. Program maintenance is impossible without program understanding. This may seem like an obvious thing to say, but many programmers overlook this self-evident truth.

Who are you, the reader of this book? You might be a relative beginner who has picked up some programming but wants to learn C11. You might be a student who wants to supplement his or her college education. You might be a well-trained programmer who is trying to make a transition from the academic to the industrial environment. Or you might be a seasoned programmer in search of new ideas. I hope this book will satisfy you no matter which category you are in.

Why should I, of all people, write a book about programming in C11? You, the potential reader of this book, have the right to ask about my credentials, especially because I’m not a computer scientist by education.

I have a Ph.D. in theoretical physics—my thesis was about supersymmetric nonlinear sigma models. I used to be pretty good at calculating supersymmetric Feynman diagrams. Then, around 1986 I fell in love with computers, quit my postdoc position, and began programming.

A physicist is somebody who’s in between a mathematician and an engineer. A physicist is used to constantly moving between theory and practice. He or she is not expected to believe in a theory unless it has proven itself in practice, and will always try to generalize every aspect of experience in order to find an underlying principle. And, most of all, a physicist is not supposed to take anything for granted.

Unlike a mathematician, a physicist has to be more realistic and care more about the process than the formal theory. The process in physics is performing calculations. In programming, it’s software maintenance. So, since I’m a physicist, it should come as no surprise that this book focuses more on rewriting programs than on creating them.

I started teaching C11 and writing this book in 1994, while still working at Microsoft. I took a sabbatical to visit my alma mater, the University of Wroclaw in Poland. It turned out that I would visit that institution several more times, and each visit would prompt me to write a few more chapters. At some point I started converting the book to HTML and posting it on the web. Since C11 was still evolving, I had to rewrite many chapters over and over again. For example, when STL became part of the C11 standard library, I had to go back and rethink the implementation of most code examples in the book.

A lot of techniques described in this book were developed while I was working at Microsoft, designing and leading the development of the Index Server. After that, my new company, Reliable Software, turned out to be a great lab for testing new programming methodologies. All the techniques described in this book have been incorporated into our own products. In fact, we keep rewriting our code every time a new, better idea comes along.

Being a physicist makes me both a good programmer and a bad programmer. Good, because I constantly revise my techniques, search for new generalizations, and discuss every aspect of programming to death. Bad, because when I find a better solution I want to rewrite everything (I will try to convince you that it’s actually not such a bad idea). Managers on my previous jobs always had problems with me, because I questioned every decision, convention, and custom. I hope the same qualities will make me a good writer.

If you, the reader, find a better way of doing something described in this book, please let me know, so I can start rewriting this book for the nth time. My e-mail address is bartosz@relisoft.com.

I am most grateful to my students from the University of Wroclaw and from the Digipen Institute of Technology, because the best way to learn something is to teach it. Thanks go to Professor Jerzy Lukierski, who invited me back to the university to teach computer science. I am also indebted to my coworkers at Microsoft and Reliable Software, who were the first to try and improve many techniques described in this book. My wife, Pam, besides supporting me in all my endeavors, helped me edit the first chapter of this book, making it so much easier to understand. Many thanks to editors from Addison-Wesley, especially Debbie Lafferty.

Table of Contents

(NOTE: Most chapters include a Summary and Conclusion, and Exercises.)

Preface.

I. LANGUAGE.

II. TECHNIQUES.

III. WINDOWS.

IV. SCALING UP.

Errata

Click below for Errata related to this title:
Errata