Enhanced descriptions from Syndetics:

C]+ is the primary language used in game development; however, game programming has a unique set of challenges, which general application development techniques and recommendations don't apply to. Written to address this issue, C++ for Game Programmers provides practical suggestions for what C++ features to use in game development and why. Many of the misconceptions of C++ are clarified, and programmers learn the most effective methods for using the language to create games. This is primarily a book about ideas and concepts: it is not just a source of C++ code to use in your game project. Instead, C++ for Game Programmers covers how things work from a game-development perspective, and provides practical rules to follow. It points out the most effective C++ practices and steers developers away from the potentially dangerous ones. It describes common C++ techniques to solve specific problems faced by most developers, and focuses on techniques that have been proven in real games. Additionally, specific new technologies such as STL are covered in detail, along with the challenges specific to different platforms such as PCs or game consoles. The techniques presented apply to all aspects of game programming, including graphics, physics, and AI. C++ for Game Programmers is the perfect resource for game programmers looking to perfect their C++ skills, and experienced programmers interested in entering the game industry. Graphics, embedded systems, and real-time systems programmers facing the same challenges as game programmers will also benefit from the ideas and techniques covered.

Table of contents provided by Syndetics

• Acknowledgments (p. xiii)
• Introduction (p. xv)
• Why This Book? (p. xvii)
• C++ for Game Development (p. xviii)
• Audience (p. xix)
• Some Ground Rules (p. xx)
• Source Code (p. xxii)
• Part I Tapping the Power of C++ (p. 1)
• Chapter 1 Inheritance (p. 3)
• Classes (p. 4)
• Inheritance (p. 5)
• Polymorphism and Virtual Functions (p. 8)
• To Inherit or Not to Inherit? (p. 11)
• When to Use and When to Avoid Inheritance (p. 13)
• Inheritance Implementation (Advanced) (p. 15)
• Cost Analysis (Advanced) (p. 17)
• Alternatives (Advanced) (p. 20)
• Program Architecture and Inheritance (Advanced) (p. 21)
• Conclusion (p. 23)
• Suggested Reading (p. 24)
• Chapter 2 Multiple Inheritance (p. 25)
• Using Multiple Inheritance (p. 26)
• Multiple Inheritance Problems (p. 30)
• Polymorphism (p. 34)
• When to Use Multiple Inheritance and When to Avoid It (p. 36)
• Multiple Inheritance Implementation (Advanced) (p. 37)
• Cost Analysis (Advanced) (p. 39)
• Conclusion (p. 42)
• Suggested Reading (p. 42)
• Chapter 3 Constness, References, and a Few Loose Ends (p. 43)
• Constness (p. 44)
• References (p. 52)
• Casting (p. 58)
• Conclusion (p. 62)
• Suggested reading (p. 63)
• Chapter 4 Templates (p. 65)
• The Search for Generic Code (p. 66)
• Templates (p. 72)
• Drawbacks (p. 76)
• When to Use Templates (p. 78)
• Template Specialization (Advanced) (p. 79)
• Conclusion (p. 82)
• Suggested Reading (p. 82)
• Chapter 5 Exception Handling (p. 83)
• Dealing with Errors (p. 84)
• Using Exceptions (p. 88)
• Exception-Safe Code (p. 95)
• Cost Analysis (p. 101)
• When to Use Exceptions (p. 102)
• Conclusion (p. 103)
• Suggested Reading (p. 104)
• Part II Performance and Memory (p. 105)
• Chapter 6 Performance (p. 107)
• Performance and Optimizations (p. 108)
• Function types (p. 112)
• Inlining (p. 117)
• More Function Overhead (p. 122)
• Avoiding Copies (p. 127)
• Constructors and Destructors (p. 133)
• Data Caches and Memory Alignment (Advanced) (p. 137)
• Conclusion (p. 142)
• Suggested Reading (p. 142)
• Chapter 7 Memory Allocation (p. 145)
• The Stack (p. 146)
• The Heap (p. 147)
• Static Allocation (p. 153)
• Dynamic Allocation (p. 156)
• Custom Memory Manager (p. 161)
• Memory Pools (p. 170)
• In Case of Emergency ... (p. 177)
• Conclusion (p. 178)
• Suggested reading (p. 179)
• Chapter 8 Standard Template Library--Containers (p. 181)
• STL Overview (p. 182)
• To STL, or Not to STL? (p. 184)
• Sequence Containers (p. 187)
• Associative Containers (p. 199)
• Container Adaptors (p. 212)
• Conclusion (p. 215)
• Suggested reading (p. 217)
• Chapter 9 STL--Algorithms and Advanced Topics (p. 219)
• Function Objects (Functors) (p. 220)
• Algorithms (p. 224)
• Strings (p. 234)
• Allocators (Advanced) (p. 242)
• When STL Is Not Enough (Advanced) (p. 244)
• Conclusion (p. 246)
• Suggested Reading (p. 246)
• Part III Special Techniques (p. 249)
• Chapter 10 Abstract Interfaces (p. 251)
• Abstract Interfaces (p. 252)
• General C++ Implementation (p. 254)
• Abstract Interfaces as a Barrier (p. 255)
• Abstract Interfaces as Class Characteristics (p. 261)
• All that Glitters is Not ... (p. 268)
• Conclusion (p. 269)
• Suggested Reading (p. 270)
• Chapter 11 Plug-Ins (p. 271)
• The Need for Plug-Ins (p. 272)
• Plug-In Architecture (p. 274)
• Putting It All Together (p. 284)
• Plug-Ins in the Real World (p. 285)
• Conclusion (p. 287)
• Suggested Reading (p. 287)
• Chapter 12 Runtime Type Information (p. 289)
• Working Without RTTI (p. 290)
• Uses and Abuses of RTTI (p. 291)
• Standard C++ RTTI (p. 293)
• Custom RTTI System (p. 299)
• Conclusion (p. 310)
• Suggested Reading (p. 311)
• Chapter 13 Object Creation and Management (p. 313)
• Object Creation (p. 314)
• Object Factories (p. 317)
• Shared Objects (p. 325)
• Conclusion (p. 338)
• Suggested Reading (p. 339)
• Chapter 14 Object Serialization (p. 341)
• Game Entity Serialization Implementation (p. 346)
• Putting It All Together (p. 356)
• Conclusion (p. 356)
• Suggested Reading (p. 358)
• Chapter 15 Dealing with Large Projects (p. 359)
• Logical vs. Physical Structure (p. 360)
• Classes and Files (p. 361)
• Header Files (p. 362)
• Libraries (p. 377)
• Configurations (p. 381)
• Conclusion (p. 382)
• Suggested Reading (p. 383)
• Chapter 16 Crash-Proofing Your Game (p. 385)
• Using Asserts (p. 386)
• Keep the Machine Fresh (p. 394)
• Deal with 'Bad' Data (p. 397)
• Conclusion (p. 401)
• Suggested Reading (p. 402)
• Appendix About the CD-ROM (p. 403)
• Index (p. 405)