C++ In Action: Industrial Strength Programming Techniques (With CD-ROM)

C++ in Action introduces state-of-the-art C++ programming and problem-solving techniques for developing efficient, powerful, scalable software systems. Renowned software architect Bartosz Milewski starts from two key premises. First, programs aren't written for computers: they're written for other programmers who will have to integrate and maintain them. Second, software development languages aren't ends in themselves: they're tools to solve problems. Starting from these principles, Milewski presents a comprehensive guide to C++ software engineering for maximum performance, reliability, and maintainability. He shows how to use resource management and exception management together to build more reliable code. Next, he introduces new techniques that simplify Windows development despite the complexity of the Windows API and libraries. The book also includes detailed coverage of large-scale software and scalability, encompassing development strategies and tactics as well as management, planning, and project dynamics. Modern guide to using C++ langugage, including how to apply it to Windows programming. Shows how to write programs for programmers, not computers. The CD-ROM features all of the source code and projects from the text. Also includes a companion Web site. System requirements not listed. .RO Release ( Contents......Page 1 Preface......Page 2 Language......Page 4 Techniques......Page 5 Software Project......Page 7 Language......Page 9 Global scope......Page 11 Local scope......Page 14 Embedded objects......Page 18 Inheritance......Page 20 Member functions and Interfaces......Page 22 Member function scope......Page 24 Types......Page 30 Exercises......Page 32 Abstract Data Types......Page 33 Exercises......Page 37 References......Page 39 Stack-based calculator......Page 43 Functional Specification......Page 44 Stubbed Implementation......Page 45 Calculator: Implementation......Page 47 Input: Implementation......Page 49 The Makefile......Page 52 Exercises......Page 53 Pointers......Page 55 Pointers vs. References......Page 56 Pointers and Arrays......Page 57 Pointers and Dynamic Memory Allocation......Page 60 Dynamic Data Structures......Page 62 Dynamic Stack......Page 63 Linked List......Page 65 String Table......Page 70 String Buffer......Page 71 Table Lookup......Page 74 Hash Table......Page 75 Test......Page 77 Exercises......Page 78 The Meaning of is-a......Page 79 Parse Tree......Page 80 Exercises......Page 83 Specification......Page 85 Stubbed Implementation......Page 87 Expanding Stubs......Page 89 Final Implementation. Not!......Page 91 Scanner......Page 92 Symbol Table......Page 97 Store......Page 99 Function Table......Page 102 Nodes......Page 109 Parser......Page 110 Main......Page 117 Initialization of Aggregates......Page 118 Exercises......Page 119 Operator overloading......Page 121 Passing by Value......Page 122 Value Semantics......Page 125 Techniques......Page 133 Techniques......Page 135 Improving Code Grouping......Page 137 Decoupling the Output......Page 138 Fighting Defensive Programming......Page 139 A Case of Paranoid Programming......Page 141 Fringes......Page 145 Improving Communication Between Classes......Page 147 Correcting Design Flaws......Page 151 Using Embedded Classes......Page 158 Combining Classes......Page 159 Combining Things using Namespaces......Page 160 Hiding Constants in Enumerations......Page 161 Hiding Constants in Local Variables......Page 164 Testing Boundary Conditions......Page 165 Templates......Page 168 Dynamic Array......Page 171 Separating Functionality into New Classes......Page 176 Standard Vector......Page 180 Code Review 5: Resource Management......Page 185 Exceptions......Page 186 Stack Unwinding......Page 187 Resources......Page 191 Ownership of Resources......Page 193 Smart Pointers......Page 194 Ownership Transfer: First Attempt......Page 195 Ownership Transfer: Second Attempt......Page 197 Safe Containers......Page 202 Iterators......Page 205 Error Propagation......Page 208 Conversion......Page 209 Conclusion......Page 211 Making Use of the Standard Template Library......Page 212 Reference Counting and Copy-On-Write......Page 215 End of Restrictions......Page 220 Exploring Streams......Page 223 The Calculator Object......Page 228 Command Parser......Page 230 Serialization and Deserialization......Page 232 In-Memory (De-) Serialization......Page 241 Multiple Inheritance......Page 243 Transactions......Page 244 Transient Transactions......Page 245 Persistent Transactions......Page 248 The Three-File Scheme......Page 250 The Mapping-File Scheme......Page 251 Caching......Page 254 Bulk Allocation......Page 256 Array new......Page 258 Macros......Page 260 Tracing Memory Leaks......Page 262 Debug Output......Page 265 Placement new......Page 267 Windows Techniques......Page 268 Of Macros and Wizards......Page 269 Programming Paradigm......Page 270 Hello Windows!......Page 272 Encapsulation......Page 277 Model-View-Controller......Page 278 Exception Specification......Page 284 Cleanup......Page 286 Application Icon......Page 287 Window Painting and the View Object......Page 290 The Canvas......Page 291 The WM_PAINT Message......Page 294 The Model......Page 296 Capturing the Mouse......Page 297 Adding Colors and Frills......Page 302 Stock Objects......Page 308 User Interface......Page 311 Child Windows......Page 312 Windows Controls......Page 313 Dialogs......Page 317 Commands and Menus......Page 321 Dynamic Menus......Page 322 Exercises......Page 327 Implementation Strategies......Page 328 Complexity......Page 329 The Fractal Nature of Software......Page 331 The Living Project......Page 333 The Living Programmer......Page 334 Top-Down Object Oriented Design......Page 336 Model-View-Controller......Page 337 Requirement Specification......Page 338 Architecture Specification......Page 339 Productivity......Page 340 Team Strategies......Page 342 Global Decisions......Page 344 Top-Down Object Oriented Implementation......Page 345 Multi-platform development......Page 346 Program Modifications......Page 347 Stress Testing......Page 348 .RO Release ( Contents 1 Preface 2 Introduction 4 Language 4 Techniques 5 Software Project 7 Language 9 Objects and Scopes 11 Global scope 11 Local scope 14 Embedded objects 18 Inheritance 20 Member functions and Interfaces 22 Member function scope 24 Types 30 Summary 32 Word of Caution 32 Exercises 32 Abstract Data Types 33 Exercises 37 Arrays and References 39 References 39 Stack-based calculator 43 Functional Specification 44 Design 45 Stubbed Implementation 45 Implementation 47 Calculator: Implementation 47 Input: Implementation 49 The Makefile 52 Exercises 53 Pointers 55 Pointers 55 Pointers vs. References 56 Pointers and Arrays 57 Exercises 60 Pointers and Dynamic Memory Allocation 60 Dynamic Data Structures 62 Dynamic Stack 63 Linked List 65 String Table 70 String Buffer 71 Table Lookup 74 Hash Table 75 Test 77 Exercises 78 Polymorphism 79 Polymorphism 79 The Meaning of is-a 79 Parse Tree 80 Exercises 83 Small Software Project 85 Software Project 85 Specification 85 Stubbed Implementation 87 Expanding Stubs 89 Final Implementation. Not! 91 Scanner 92 Symbol Table 97 Store 99 Function Table 102 Nodes 109 Parser 110 Main 117 Initialization of Aggregates 118 Exercises 119 Operator overloading 121 Passing by Value 122 Value Semantics 125 Techniques 133 Techniques 135 Code Review 1: The Cleanup 137 Improving Code Grouping 137 Decoupling the Output 138 Fighting Defensive Programming 139 A Case of Paranoid Programming 141 Fringes 145 Improving Communication Between Classes 147 Correcting Design Flaws 151 Code Review 2: Hiding Implementation Details 158 Using Embedded Classes 158 Combining Classes 159 Combining Things using Namespaces 160 Hiding Constants in Enumerations 161 Hiding Constants in Local Variables 164 Code Review 3: Sharing 165 Isolating Global Program Parameters 165 Testing Boundary Conditions 165 Templates 168 Code Review 4: Removing Limitations 171 Dynamic Array 171 Separating Functionality into New Classes 176 Standard Vector 180 Code Review 5: Resource Management 185 Exceptions 186 Stack Unwinding 187 Resources 191 Ownership of Resources 193 Access to Resources 194 Smart Pointers 194 Ownership Transfer: First Attempt 195 Ownership Transfer: Second Attempt 197 Safe Containers 202 Iterators 205 Error Propagation 208 Conversion 209 Conclusion 211 Making Use of the Standard Template Library 212 Reference Counting and Copy-On-Write 215 End of Restrictions 220 Exploring Streams 223 Code Review 7: Serialization and Deserialization 228 The Calculator Object 228 Command Parser 230 Serialization and Deserialization 232 In-Memory (De-) Serialization 241 Multiple Inheritance 243 Transactions 244 Transient Transactions 245 Persistent Transactions 248 The Three-File Scheme 250 The Mapping-File Scheme 251 Overloading operator new 254 Class-specific new 254 Caching 254 Bulk Allocation 256 Array new 258 Global new 260 Macros 260 Tracing Memory Leaks 262 Debug Output 265 Placement new 267 Windows Techniques 268 Introduction 269 Of Macros and Wizards 269 Programming Paradigm 270 Hello Windows! 272 Encapsulation 277 Controlling Windows through C++ 278 Creating a Namespace 278 Model-View-Controller 278 Exception Specification 284 Cleanup 286 Painting 287 Application Icon 287 Window Painting and the View Object 290 The Canvas 291 The WM_PAINT Message 294 The Model 296 Capturing the Mouse 297 Adding Colors and Frills 302 Stock Objects 308 Windows Application 311 Porting the Calculator to Windows 311 User Interface 311 Child Windows 312 Windows Controls 313 Dialogs 317 Commands and Menus 321 Dynamic Menus 322 Exercises 327 Software Project 328 About Software 328 Design Strategies 328 Team Work 328 Implementation Strategies 328 About Software 329 Complexity 329 The Fractal Nature of Software 331 The Living Project 333 The Living Programmer 334 Design Strategies 336 Top-Down Object Oriented Design 336 Model-View-Controller 337 Documentation 338 Requirement Specification 338 Architecture Specification 339 Team Work 340 Productivity 340 Team Strategies 342 Implementation Strategies 344 Global Decisions 344 Top-Down Object Oriented Implementation 345 Inheriting Somebody Else's Code 346 Multi-platform development 346 Program Modifications 347 Testing 348 Regression Testing 348 Stress Testing 348 (Pearson Education) Modern guide to using C++ langugage, including how to apply it to Windows programming. Shows how to write programs for programmers, not computers. The CD-ROM features all of the source code and projects from the text. Also includes a companion Web site. System requirements not listed. Softcover.