C++ Templates: The Complete Guide (2nd Edition)

Templates are among the most powerful features of C++, but they remain misunderstood and underutilized, even as the C++ language and development community have advanced. In C++ Templates, Second Edition, three pioneering C++ experts show why, when, and how to use modern templates to build software that’s cleaner, faster, more efficient, and easier to maintain. Now extensively updated for the C++11, C++14, and C++17 standards, this new edition presents state-of-the-art techniques for a wider spectrum of applications. The authors provide authoritative explanations of all new language features that either improve templates or interact with them, including variadic templates, generic lambdas, class template argument deduction, compile-time if, forwarding references, and user-defined literals. They also deeply delve into fundamental language concepts (like value categories) and fully cover all standard type traits. The book starts with an insightful tutorial on basic concepts and relevant language features. The remainder of the book serves as a comprehensive reference, focusing first on language details and then on coding techniques, advanced applications, and sophisticated idioms. Throughout, examples clearly illustrate abstract concepts and demonstrate best practices for exploiting all that C++ templates can do. Understand exactly how templates behave, and avoid common pitfalls Use templates to write more efficient, flexible, and maintainable software Master today’s most effective idioms and techniques Reuse source code without compromising performance or safety Benefit from utilities for generic programming in the C++ Standard Library Preview the upcoming concepts feature The companion website, tmplbook.com, contains sample code and additional updates. Cover......Page 1 Title......Page 4 Copyright......Page 5 Contents......Page 8 Preface......Page 24 Acknowledgments for the Second Edition......Page 26 Doug’s Acknowledgments for the Second Edition......Page 27 Acknowledgments for the First Edition......Page 28 David’s Acknowledgments for the First Edition......Page 29 About This Book......Page 30 Overall Structure of the Book......Page 31 Some Remarks About Programming Style......Page 32 The C++11, C++14, and C++17 Standards......Page 34 Feedback......Page 35 Part I: The Basics......Page 36 1.1.1 Defining the Template......Page 38 1.1.2 Using the Template......Page 39 1.1.3 Two-Phase Translation......Page 41 1.2 Template Argument Deduction......Page 42 1.3 Multiple Template Parameters......Page 44 1.3.1 Template Parameters for Return Types......Page 45 1.3.2 Deducing the Return Type......Page 46 1.3.3 Return Type as Common Type......Page 47 1.4 Default Template Arguments......Page 48 1.5 Overloading Function Templates......Page 50 1.6.2 Why Not inline?......Page 55 1.7 Summary......Page 56 2.1 Implementation of Class Template Stack......Page 58 2.1.1 Declaration of Class Templates......Page 59 2.1.2 Implementation of Member Functions......Page 61 2.2 Use of Class Template Stack......Page 62 2.3.1 Concepts......Page 64 2.4 Friends......Page 65 2.5 Specializations of Class Templates......Page 66 2.6 Partial Specialization......Page 68 2.7 Default Class Template Arguments......Page 71 2.8 Type Aliases......Page 73 2.9 Class Template Argument Deduction......Page 75 2.10 Templatized Aggregates......Page 78 2.11 Summary......Page 79 3.1 Nontype Class Template Parameters......Page 80 3.2 Nontype Function Template Parameters......Page 83 3.3 Restrictions for Nontype Template Parameters......Page 84 3.4 Template Parameter Type auto......Page 85 3.5 Summary......Page 89 4.1.1 Variadic Templates by Example......Page 90 4.1.3 Operator sizeof.........Page 92 4.2 Fold Expressions......Page 93 4.3 Application of Variadic Templates......Page 95 4.4 Variadic Class Templates and Variadic Expressions......Page 96 4.4.1 Variadic Expressions......Page 97 4.4.3 Variadic Class Templates......Page 98 4.4.4 Variadic Deduction Guides......Page 99 4.4.5 Variadic Base Classes and using......Page 100 4.5 Summary......Page 101 5.1 Keyword typename......Page 102 5.2 Zero Initialization......Page 103 5.3 Using this->......Page 105 5.4 Templates for Raw Arrays and String Literals......Page 106 5.5 Member Templates......Page 109 5.5.1 The .templateConstruct......Page 114 5.6 Variable Templates......Page 115 5.7 Template Template Parameters......Page 118 5.8 Summary......Page 124 6.1 Perfect Forwarding......Page 126 6.2 Special Member Function Templates......Page 130 6.3 Disable Templates with enable_if......Page 133 6.4 Using enable_if......Page 134 6.5 Using Concepts to Simplify enable_ifExpressions......Page 138 6.6 Summary......Page 139 7. By Value or by Reference?......Page 140 7.1 Passing by Value......Page 141 7.2.1 Passing by Constant Reference......Page 143 7.2.2 Passing by Nonconstant Reference......Page 145 7.2.3 Passing by Forwarding Reference......Page 146 7.3 Using std::ref()and std::cref()......Page 147 7.4 Dealing with String Literals and Raw Arrays......Page 150 7.4.1 Special Implementations for String Literals and Raw Arrays......Page 151 7.5 Dealing with Return Values......Page 152 7.6 Recommended Template Parameter Declarations......Page 153 7.7 Summary......Page 156 8.1 Template Metaprogramming......Page 158 8.2 Computing with constexpr......Page 160 8.3 Execution Path Selection with Partial Specialization......Page 162 8.4 SFINAE (Substitution Failure Is Not An Error)......Page 164 8.4.1 Expression SFINAE with decltype......Page 168 8.5 Compile-Time if......Page 169 8.6 Summary......Page 170 9.1.1 Linker Errors......Page 172 9.1.2 Templates in Header Files......Page 174 9.2 Templates and inline......Page 175 9.3 Precompiled Headers......Page 176 9.4 Decoding the Error Novel......Page 178 9.5 Afternotes......Page 184 9.6 Summary......Page 185 10.1 “Class Template” or “Template Class”?......Page 186 10.2 Substitution, Instantiation, and Specialization......Page 187 10.3 Declarations versus Definitions......Page 188 10.4 The One-Definition Rule......Page 189 10.5 Template Arguments versus Template Parameters......Page 190 10.6 Summary......Page 191 11.1 Callables......Page 192 11.1.1 Supporting Function Objects......Page 193 11.1.2 Dealing with Member Functions and Additional Arguments......Page 195 11.1.3 Wrapping Function Calls......Page 197 11.2.1 Type Traits......Page 199 11.2.3 std::declval()......Page 201 11.4 References as Template Parameters......Page 202 11.5 Defer Evaluations......Page 206 11.6 Things to Consider When Writing Generic Libraries......Page 207 11.7 Summary......Page 208 Part II: Templates in Depth......Page 210 12.1 Parameterized Declarations......Page 212 12.1.2 Linkage of Templates......Page 217 12.1.3 Primary Templates......Page 219 12.2.1 Type Parameters......Page 220 12.2.2 Nontype Parameters......Page 221 12.2.3 Template Template Parameters......Page 222 12.2.4 Template Parameter Packs......Page 223 12.2.5 Default Template Arguments......Page 225 12.3.1 Function Template Arguments......Page 227 12.3.3 Nontype Arguments......Page 229 12.3.4 Template Template Arguments......Page 232 12.3.5 Equivalence......Page 234 12.4 Variadic Templates......Page 235 12.4.1 Pack Expansions......Page 236 12.4.2 Where Can Pack Expansions Occur?......Page 237 12.4.3 Function Parameter Packs......Page 239 12.4.4 Multiple and Nested Pack Expansions......Page 240 12.4.6 Fold Expressions......Page 242 12.5.1 Friend Classes of Class Templates......Page 244 12.5.2 Friend Functions of Class Templates......Page 246 12.6 Afternotes......Page 248 13.1 Name Taxonomy......Page 250 13.2 Looking Up Names......Page 252 13.2.1 Argument-Dependent Lookup......Page 254 13.2.2 Argument-Dependent Lookup of Friend Declarations......Page 255 13.2.3 Injected Class Names......Page 256 13.2.4 Current Instantiations......Page 258 13.3 Parsing Templates......Page 259 13.3.1 Context Sensitivity in Nontemplates......Page 260 13.3.2 Dependent Names of Types......Page 263 13.3.3 Dependent Names of Templates......Page 265 13.3.4 Dependent Names in Using Declarations......Page 266 13.3.6 Dependent Expressions......Page 268 13.4.1 Nondependent Base Classes......Page 271 13.4.2 Dependent Base Classes......Page 272 13.5 Afternotes......Page 275 14.1 On-Demand Instantiation......Page 278 14.2.1 Partial and Full Instantiation......Page 280 14.2.2 Instantiated Components......Page 281 14.3.1 Two-Phase Lookup......Page 284 14.3.2 Points of Instantiation......Page 285 14.3.3 The Inclusion Model......Page 289 14.4 Implementation Schemes......Page 290 14.4.1 Greedy Instantiation......Page 291 14.4.2 Queried Instantiation......Page 292 14.4.3 Iterated Instantiation......Page 294 14.5.1 Manual Instantiation......Page 295 14.5.2 Explicit Instantiation Declarations......Page 297 14.6 Compile-Time ifStatements......Page 298 14.7 In the Standard Library......Page 300 14.8 Afternotes......Page 301 15.1 The Deduction Process......Page 304 15.2 Deduced Contexts......Page 306 15.3 Special Deduction Situations......Page 308 15.4 Initializer Lists......Page 309 15.5 Parameter Packs......Page 310 15.6.1 Reference Collapsing Rules......Page 312 15.6.2 Forwarding References......Page 313 15.6.3 Perfect Forwarding......Page 315 15.6.4 Deduction Surprises......Page 318 15.7 SFINAE (Substitution Failure Is Not An Error)......Page 319 15.7.1 Immediate Context......Page 320 15.8 Limitations of Deduction......Page 321 15.8.1 Allowable Argument Conversions......Page 322 15.8.2 Class Template Arguments......Page 323 15.8.3 Default Call Arguments......Page 324 15.8.4 Exception Specifications......Page 325 15.9 Explicit Function Template Arguments......Page 326 15.10 Deduction from Initializers and Expressions......Page 328 15.10.1 The autoType Specifier......Page 329 15.10.2 Expressing the Type of an Expression with decltype......Page 333 15.10.3 decltype(auto)......Page 336 15.10.4 Special Situations for autoDeduction......Page 338 15.10.5 Structured Bindings......Page 341 15.10.6 Generic Lambdas......Page 344 15.11 Alias Templates......Page 347 15.12 Class Template Argument Deduction......Page 348 15.12.1 Deduction Guides......Page 349 15.12.2 Implicit Deduction Guides......Page 351 15.12.3 Other Subtleties......Page 353 15.13 Afternotes......Page 356 16.1 When “Generic Code” Doesn’t Quite Cut It......Page 358 16.1.1 Transparent Customization......Page 359 16.1.2 Semantic Transparency......Page 360 16.2 Overloading Function Templates......Page 361 16.2.1 Signatures......Page 363 16.2.2 Partial Ordering of Overloaded Function Templates......Page 365 16.2.3 Formal Ordering Rules......Page 366 16.2.4 Templates and Nontemplates......Page 367 16.2.5 Variadic Function Templates......Page 370 16.3.1 Full Class Template Specialization......Page 373 16.3.2 Full Function Template Specialization......Page 377 16.3.4 Full Member Specialization......Page 379 16.4 Partial Class Template Specialization......Page 382 16.5 Partial Variable Template Specialization......Page 386 16.6 Afternotes......Page 387 17. Future Directions......Page 388 17.2 Generalized Nontype Template Parameters......Page 389 17.3 Partial Specialization of Function Templates......Page 391 17.4 Named Template Arguments......Page 393 17.5 Overloaded Class Templates......Page 394 17.6 Deduction for Nonfinal Pack Expansions......Page 395 17.8 Type Checking for Templates......Page 396 17.9 Reflective Metaprogramming......Page 398 17.10 Pack Facilities......Page 400 17.11 Modules......Page 401 Part III: Templates and Design......Page 402 18.1 Dynamic Polymorphism......Page 404 18.2 Static Polymorphism......Page 407 18.3 Dynamic versus Static Polymorphism......Page 410 18.4 Using Concepts......Page 412 18.5 New Forms of Design Patterns......Page 414 18.6 Generic Programming......Page 415 18.7 Afternotes......Page 418 19.1 An Example: Accumulating a Sequence......Page 420 19.1.1 Fixed Traits......Page 421 19.1.2 Value Traits......Page 424 19.2 Traits versus Policies and Policy Classes......Page 429 19.2.1 Traits and Policies: What’s the Difference?......Page 432 19.2.2 Member Templates versus Template Template Parameters......Page 433 19.2.4 Accumulation with General Iterators......Page 434 19.3.1 Element Types......Page 436 19.3.2 Transformation Traits......Page 439 19.3.3 Predicate Traits......Page 445 19.3.4 Result Type Traits......Page 448 19.4.1 SFINAE Out Function Overloads......Page 451 19.4.2 SFINAE Out Partial Specializations......Page 455 19.4.3 Using Generic Lambdas for SFINAE......Page 456 19.4.4 SFINAE-Friendly Traits......Page 459 19.5 IsConvertibleT......Page 463 19.6.1 Detecting Member Types......Page 466 19.6.2 Detecting Arbitrary Member Types......Page 468 19.6.3 Detecting Nontype Members......Page 469 19.6.4 Using Generic Lambdas to Detect Members......Page 473 19.7.1 If-Then-Else......Page 475 19.7.2 Detecting Nonthrowing Operations......Page 478 19.7.3 Traits Convenience......Page 481 19.8.1 Determining Fundamental Types......Page 483 19.8.2 Determining Compound Types......Page 486 19.8.3 Identifying Function Types......Page 489 19.8.4 Determining Class Types......Page 491 19.8.5 Determining Enumeration Types......Page 492 19.9.1 Read-Only Parameter Types......Page 493 19.10 In the Standard Library......Page 496 19.11 Afternotes......Page 497 20.1 Algorithm Specialization......Page 500 20.2 Tag Dispatching......Page 502 20.3 Enabling/Disabling Function Templates......Page 504 20.3.1 Providing Multiple Specializations......Page 506 20.3.2 Where Does the EnableIfGo?......Page 507 20.3.3 Compile-Time if......Page 509 20.3.4 Concepts......Page 510 20.4.1 Enabling/Disabling Class Templates......Page 512 20.4.2 Tag Dispatching for Class Templates......Page 514 20.5 Instantiation-Safe Templates......Page 517 20.6 In the Standard Library......Page 522 20.7 Afternotes......Page 523 21.1 The Empty Base Class Optimization (EBCO)......Page 524 21.1.1 Layout Principles......Page 525 21.1.2 Members as Base Classes......Page 527 21.2 The Curiously Recurring Template Pattern (CRTP)......Page 530 21.2.1 The Barton-Nackman Trick......Page 532 21.2.2 Operator Implementations......Page 535 21.2.3 Facades......Page 536 21.3 Mixins......Page 543 21.3.2 Parameterized Virtuality......Page 545 21.4 Named Template Arguments......Page 547 21.5 Afternotes......Page 550 22.1 Function Objects, Pointers, and std::function......Page 552 22.2 Generalized Function Pointers......Page 554 22.3 Bridge Interface......Page 557 22.4 Type Erasure......Page 558 22.5 Optional Bridging......Page 560 22.6 Performance Considerations......Page 562 22.7 Afternotes......Page 563 23.1.1 Value Metaprogramming......Page 564 23.1.2 Type Metaprogramming......Page 566 23.1.3 Hybrid Metaprogramming......Page 567 23.1.4 Hybrid Metaprogramming for Unit Types......Page 569 23.2 The Dimensions of Reflective Metaprogramming......Page 572 23.3 The Cost of Recursive Instantiation......Page 574 23.3.1 Tracking All Instantiations......Page 575 Arguments......Page 577 23.6 Enumeration Values versus Static Constants......Page 578 23.7 Afternotes......Page 580 24.1 Anatomy of a Typelist......Page 584 24.2.1 Indexing......Page 586 24.2.2 Finding the Best Match......Page 587 24.2.3 Appending to a Typelist......Page 590 24.2.4 Reversing a Typelist......Page 592 24.2.5 Transforming a Typelist......Page 594 24.2.6 Accumulating Typelists......Page 595 24.2.7 Insertion Sort......Page 598 24.3 Nontype Typelists......Page 601 24.3.1 Deducible Nontype Parameters......Page 603 24.4 Optimizing Algorithms with Pack Expansions......Page 604 24.5 Cons-style Typelists......Page 606 24.6 Afternotes......Page 608 25. Tuples......Page 610 25.1.1 Storage......Page 611 25.1.2 Construction......Page 613 25.2.1 Comparison......Page 614 25.2.2 Output......Page 615 25.3.1 Tuples as Typelists......Page 616 25.3.2 Adding to and Removing from a Tuple......Page 617 25.3.3 Reversing a Tuple......Page 619 25.3.4 Index Lists......Page 620 25.3.5 Reversal with Index Lists......Page 621 25.3.6 Shuffle and Select......Page 623 25.4 Expanding Tuples......Page 627 25.5.1 Tuples and the EBCO......Page 628 25.5.2 Constant-time get()......Page 633 25.6 Tuple Subscript......Page 634 25.7 Afternotes......Page 636 26. Discriminated Unions......Page 638 26.1 Storage......Page 639 26.2 Design......Page 641 26.3 Value Query and Extraction......Page 645 26.4.1 Initialization......Page 646 26.4.2 Destruction......Page 647 26.4.3 Assignment......Page 648 26.5 Visitors......Page 652 26.5.1 Visit Result Type......Page 656 26.5.2 Common Result Type......Page 657 26.6 Variant Initialization and Assignment......Page 659 26.7 Afternotes......Page 663 27. Expression Templates......Page 664 27.1 Temporaries and Split Loops......Page 665 27.2 Encoding Expressions in Template Arguments......Page 670 27.2.1 Operands of the Expression Templates......Page 671 27.2.2 The ArrayType......Page 674 27.2.3 The Operators......Page 677 27.2.4 Review......Page 678 27.2.5 Expression Templates Assignments......Page 680 27.3 Performance and Limitations of Expression Templates......Page 681 27.4 Afternotes......Page 682 28. Debugging Templates......Page 686 28.1 Shallow Instantiation......Page 687 28.2 Static Assertions......Page 689 28.3 Archetypes......Page 690 28.4 Tracers......Page 692 28.6 Afternotes......Page 697 A.1 Translation Units......Page 698 A.2 Declarations and Definitions......Page 699 A.3.1 One-per-Program Constraints......Page 700 A.3.2 One-per-Translation Unit Constraints......Page 702 A.3.3 Cross-Translation Unit Equivalence Constraints......Page 704 B.1 Traditional Lvalues and Rvalues......Page 708 B.2 Value Categories Since C++11......Page 709 B.2.1 Temporary Materialization......Page 711 B.3 Checking Value Categories with decltype......Page 713 B.4 Reference Types......Page 714 C.1 When Does Overload Resolution Kick In?......Page 716 C.2 Simplified Overload Resolution......Page 717 C.2.1 The Implied Argument for Member Functions......Page 719 C.2.2 Refining the Perfect Match......Page 721 C.3.1 Prefer Nontemplates or More Specialized Templates......Page 723 C.3.3 Pointer Conversions......Page 724 C.3.4 Initializer Lists......Page 726 C.3.5 Functors and Surrogate Functions......Page 729 C.3.6 Other Overloading Contexts......Page 730 D.1 Using Type Traits......Page 732 D.1.1 std::integral_constantand std::bool_constant......Page 733 D.1.2 Things You Should Know When Using Traits......Page 735 D.2.1 Testing for the Primary Type Category......Page 737 D.2.2 Test for Composite Type Categories......Page 741 D.3.1 Other Type Properties......Page 744 D.3.2 Test for Specific Operations......Page 753 D.3.3 Relationships Between Types......Page 760 D.4 Type Construction......Page 763 D.5 Other Traits......Page 767 D.6 Combining Type Traits......Page 769 D.7 Other Utilities......Page 772 E.1 Using Concepts......Page 774 E.2 Defining Concepts......Page 777 E.3 Overloading on Constraints......Page 778 E.3.1 Constraint Subsumption......Page 779 E.3.2 Constraints and Tag Dispatching......Page 780 E.4.2 Concept Granularity......Page 781 E.4.3 Binary Compatibility......Page 782 Forums......Page 784 Books and Web Sites......Page 785 Glossary......Page 794 A......Page 806 B......Page 807 C......Page 808 D......Page 809 E......Page 810 F......Page 811 I......Page 812 L......Page 814 M......Page 815 O......Page 816 P......Page 817 R......Page 818 S......Page 819 T......Page 820 V......Page 822 Z......Page 823 Templates Are Among The Most Powerful Features Of C++, But They Are Too Often Neglected, Misunderstood, And Misused. C++ Templates: The Complete Guide Provides Software Architects And Engineers With A Clear Understanding Of Why, When, And How To Use Templates To Build And Maintain Cleaner, Faster, And Smarter Software More Efficiently. C++ Templates Begins With An Insightful Tutorial On Basic Concepts And Language Features. The Remainder Of The Book Serves As A Comprehensive Reference, Focusing First On Language Details, Then On A Wide Range Of Coding Techniques, And Finally On Advanced Applications For Templates. Examples Used Throughout The Book Illustrate Abstract Concepts And Demonstrate Best Practices. Readers Learn: The Exact Behaviors Of Templates -- How To Avoid The Pitfalls Associated With Templates -- Idioms And Techniques, From The Basic To The Previously Undocumented -- How To Reuse Source Code Without Threatening Performance Or Safety -- How To Increase The Efficiency Of C++ Programs -- How To Produce More Flexible And Maintainable Software -- This Practical Guide Shows Programmers How To Exploit The Full Power Of The Template Features In C++. -- Provided By Publisher.