C++ templates: the complete guide
Saved in:
| Main Authors: | , , |
|---|---|
| Format: | Book |
| Language: | English |
| Published: |
Boston [und 23 weitere]
Addison-Wesley
[2018]
|
| Edition: | Second edition |
| Subjects: | |
| Online Access: | Inhaltsverzeichnis |
| Item Description: | "Covers C++11, C++14, and C++17" - Auf dem Umschlag |
| Physical Description: | xxxiv, 788 Seiten Illustrationen, Diagramme |
| ISBN: | 9780321714121 0321714121 |
Staff View
MARC
| LEADER | 00000nam a2200000 c 4500 | ||
|---|---|---|---|
| 001 | BV042527424 | ||
| 003 | DE-604 | ||
| 005 | 20240126 | ||
| 007 | t | ||
| 008 | 150427s2018 a||| |||| 00||| eng d | ||
| 020 | |a 9780321714121 |c hbk |9 978-0-321-71412-1 | ||
| 020 | |a 0321714121 |c hbk |9 0-321-71412-1 | ||
| 035 | |a (OCoLC)1013589455 | ||
| 035 | |a (DE-599)BVBBV042527424 | ||
| 040 | |a DE-604 |b ger |e rda | ||
| 041 | 0 | |a eng | |
| 049 | |a DE-703 |a DE-M347 |a DE-706 |a DE-11 |a DE-355 |a DE-739 |a DE-91G |a DE-83 | ||
| 084 | |a ST 250 |0 (DE-625)143626: |2 rvk | ||
| 084 | |a DAT 358f |2 stub | ||
| 100 | 1 | |a Vandevoorde, David |0 (DE-588)136212972 |4 aut | |
| 245 | 1 | 0 | |a C++ templates |b the complete guide |c David Vandevoorde, Nicolai M. Josuttis, Douglas Gregor |
| 250 | |a Second edition | ||
| 264 | 1 | |a Boston [und 23 weitere] |b Addison-Wesley |c [2018] | |
| 264 | 4 | |c © 2018 | |
| 300 | |a xxxiv, 788 Seiten |b Illustrationen, Diagramme | ||
| 336 | |b txt |2 rdacontent | ||
| 337 | |b n |2 rdamedia | ||
| 338 | |b nc |2 rdacarrier | ||
| 500 | |a "Covers C++11, C++14, and C++17" - Auf dem Umschlag | ||
| 650 | 0 | 7 | |a STL |0 (DE-588)4411326-2 |2 gnd |9 rswk-swf |
| 650 | 0 | 7 | |a C++ |0 (DE-588)4193909-8 |2 gnd |9 rswk-swf |
| 689 | 0 | 0 | |a C++ |0 (DE-588)4193909-8 |D s |
| 689 | 0 | 1 | |a STL |0 (DE-588)4411326-2 |D s |
| 689 | 0 | |5 DE-604 | |
| 700 | 1 | |a Josuttis, Nicolai M. |d 1962- |0 (DE-588)113893469 |4 aut | |
| 700 | 1 | |a Gregor, Douglas |0 (DE-588)1148291415 |4 aut | |
| 856 | 4 | 2 | |m Digitalisierung UB Passau - ADAM Catalogue Enrichment |q application/pdf |u http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=027961722&sequence=000002&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA |3 Inhaltsverzeichnis |
| 999 | |a oai:aleph.bib-bvb.de:BVB01-027961722 | ||
Record in the Search Index
| _version_ | 1804153284614684672 |
|---|---|
| adam_text | Contents
Preface xxiii
Acknowledgments for the Second Edition xxv
Acknowledgments for the First Edition xxvii
About This Book xxix
What You Should Know Before Reading This Book......................... xxx
Overall Structure of the Book ........................................ xxx
How to Read This Book................................................... xxxi
Some Remarks About Programming Style.................................... xxxi
The C++11, C++14, and C++17 Standards .................................xxxiii
Example Code and Additional Information................................ xxxiv
Feedback............................................................... xxxiv
Part I: The Basics 1
1 Function Templates 3
1.1 A First Look at Function Templates..................................... 3
1.1.1 Defining the Template........................................... 3
1.1.2 Using the Template.............................................. 4
1.1.3 Two-Phase Translation........................................... 6
1.2 Template Argument Deduction............................................ 7
1.3 Multiple Template Parameters........................................... 9
1.3.1 Template Parameters for Return Types......................... . 10
1.3.2 Deducing the Return Type....................................... 11
vii
viii Contents
1.3.3 Return Type as Common Type........................................... 12
1.4 Default Template Arguments................................................... 13
1.5 Overloading Function Templates .............................................. 15
1.6 But, Shouldn’t We...?........................................................ 20
1.6.1 Pass by Value or by Reference?....................................... 20
1.6.2 Why Not inline?.................................................. .. 20
1.6.3 Why Not constexpr? .................................................. 21
1.7 Summary...................................................................... 21
2 Class Templates 23
2.1 Implementation of Class Template Stack....................................... 23
2.1.1 Declaration of Class Templates....................................... 24
2.1.2 Implementation of Member Functions................................... 26
2.2 Use of Class Template Stack.................................................. 27
2.3 Partial Usage of Class Templates ............................................ 29
2.3.1 Concepts............................................................. 29
2.4 Friends...................................................................... 30
2.5 Specializations of Class Templates........................................... 31
2.6 Partial Specialization....................................................... 33
2.7 Default Class Template Arguments............................................. 36
2.8 Type Aliases............................................i................. 38
2.9 Class Template Argument Deduction............................................ 40
2.10 Templatized Aggregates....................................................... 43
2.11 Summary...................................................................... 44
3 Nontype Template Parameters 45
3.1 Nontype Class Template Parameters............................................ 45
3.2 Nontype Function Template Parameters......................................... 48
3.3 Restrictions for Nontype Template Parameters................................. 49
3.4 Template Parameter Type auto................................................. 50
3.5 Summary...................................................................... 54
Contents
IX
4 Variadic Templates 55
4.1 Variadic Templates......................................................... 55
4.1.1 Variadic Templates by Example....................................... 55
4.1.2 Overloading Variadic and Nonvariadic Templates...................... 57
4.1.3 Operator sizeof..................................................... 57
4.2 Fold Expressions........................................................... 58
4.3 Application of Variadic Templates.......................................... 60
4.4 Variadic Class Templates and Variadic Expressions.......................... 61
4.4.1 Variadic Expressions ............................................... 62
4.4.2 Variadic Indices ................................................... 63
4.4.3 Variadic Class Templates............................................ 63
4.4.4 Variadic Deduction Guides........................................... 64
4.4.5 Variadic Base Classes and using..................................... 65
4.5 Summary.................................................................... 66
5 Tricky Basics 67
5.1 Keyword typename.......................................................... 67
5.2 Zero Initialization........................................................ 68
5.3 Using this- ............................................................... 70
5.4 Templates for Raw Arrays and String Literals............................... 71
5.5 Member Templates........................................................... 74
5.5.1 The .template Construct............................................. 79
5.5.2 Generic Lambdas and Member Templates................................ 80
5.6 Variable Templates......................................................... 80
5.7 Template Template Parameters............................................... 83
5.8 Summary.................................................................. . 89
6 Move Semantics and enable_if 91
6.1 Perfect Forwarding......................................................... 91
6.2 Special Member Function Templates.......................................... 95
6.3 Disable Templates with enable_if ......................................... 98
6.4 Using enable_if .......................................................... 99
6.5 Using Concepts to Simplify enable_if Expressions ....................... 103
104
105
106
108
108
110
111
112
115
116
117
118
121
123
123
125
127
129
133
134
135
137
137
137
139
140
141
143
149
150
6.6 Summary
By Value or by Reference?
7.1 Passing by Value...........................................
7.2 Passing by Reference ......................................
7.2.1 Passing by Constant Reference .....................
7.2.2 Passing by Nonconstant Reference...................
7.2.3 Passing by Forwarding Reference....................
7.3 Using std::ref 0 and std: :cref()..........................
7.4 Dealing with String Literals and Raw Arrays................
7.4.1 Special Implementations for String Literals and Raw Arrays
7.5 Dealing with Return Values.................................
7.6 Recommended Template Parameter Declarations................
7.7 Summary...................................................
Compile-Time Programming
8.1 Template Metaprogramming...................................
8.2 Computing with constexpr...................................
8.3 Execution Path Selection with Partial Specialization.......
8.4 SFINAE (Substitution Failure Is Not An Error)..............
8.4.1 Expression SFINAE with decltype....................
8.5 Compile-Time if............................................
8.6 Summary....................................................
Using Templates in Practice
9.1 The Inclusion Model........................................
9.1.1 Linker Errors......................................
9.1.2 Templates in Header Files..........................
9.2 Templates and inline.......................................
9.3 Precompiled Headers .......................................
9.4 Decoding the Error Novel...................................
9.5 Aftemotes..................................................
9.6 Summary....................................................
Contents
xi
10 Basic Template Terminology 151
10.1 “Class Template” or “Template Class”?....................................... 151
10.2 Substitution, Instantiation, and Specialization............................. 152
10.3 Declarations versus Definitions ............................................ 153
10.3.1 Complete versus Incomplete Types..................................... 154
10.4 The One-Definition Rule.................................................... 154
10.5 Template Arguments versus Template Parameters............................... 155
10.6 Summary..................................................................... 156
11 Generic Libraries 157
11.1 Callables................................................................... 157
11.1.1 Supporting Function Objects.......................................... 158
11.1.2 Dealing with Member Functions and Additional Arguments............... 160
11.1.3 Wrapping Function Calls.............................................. 162
11.2 Other Utilities to Implement Generic Libraries.............................. 164
11.2.1 Type Traits ......................................................... 164
11.2.2 std: :addressof () .................................................. 166
11.2.3 std: :declval()...................................................... 166
11.3 Perfect Forwarding Temporaries............................................. 167
11.4 References as Template Parameters........................................... 167
11.5 Defer Evaluations........................................................... 171
11.6 Things to Consider When Writing Generic Libraries . ........................ 172
11.7 Summary................................................................... 173
Part II: Templates in Depth 175
12 Fundamentals in Depth 177
12.1 Parameterized Declarations.................................................. 177
12.1.1 Virtual Member Functions............................................. 182
12.1.2 Linkage of Templates................................................. 182
12.1.3 Primary Templates................................................... 184
12.2 Template Parameters . ...................................................... 185
12.2.1 Type Parameters...................................................... 185
Xll
Contents
12.2.2 Nontype Parameters...............
12.2.3 Template Template Parameters
12.2.4 Template Parameter Packs.........
12.2.5 Default Template Arguments.......
12.3 Template Arguments......................
12.3.1 Function Template Arguments......
12.3.2 Type Arguments...................
12.3.3 Nontype Arguments................
12.3.4 Template Template Arguments
12.3.5 Equivalence......................
12.4 Variadic Templates......................
12.4.1 Pack Expansions..................
12.4.2 Where Can Pack Expansions Occur? .
12.4.3 Function Parameter Packs.........
12.4.4 Multiple and Nested Pack Expansions
12.4.5 Zero-Length Pack Expansions......
12.4.6 Fold Expressions.................
12.5 Friends.................................
12.5.1 Friend Classes of Class Templates . .
12.5.2 Friend Functions of Class Templates .
12.5.3 Friend Templates.................
12.6 Aftemotes...............................
186
187
188
190
192
192
194
194
197
199
200
201
202
204
205
207
207
209
209
211
213
213
13 Names in Templates 215
13.1 Name Taxonomy............................................................. 215
13.2 Looking Up Names.......................................................... 217
13.2.1 Argument-Dependent Lookup......................................... 219
13.2.2 Argument-Dependent Lookup of Friend Declarations.................. 220
13.2.3 Injected Class Names.............................................. 221
13.2.4 Current Instantiations............................................ 223
13.3 Parsing Templates......................................................... 224
13.3.1 Context Sensitivity in Nontemplates............................... 225
13.3.2 Dependent Names of Types ......................................... 228
13.3.3 Dependent Names of Templates..................................... 230
Contents
xiu
13.3.4 Dependent Names in Using Declarations..................................... 231
13.3.5 ADL and Explicit Template Arguments...................................... 233
13.3.6 Dependent Expressions..................................................... 233
13.3.7 Compiler Errors........................................................... 236
13.4 Inheritance and Class Templates................................................... 236
13.4.1 Nondependent Base Classes................................................. 236
13.4.2 Dependent Base Classes.................................................. 237
13.5 Aftemotes......................................................................... 240
14 Instantiation 243
14.1 On-Demand Instantiation........................................................... 243
14.2 Lazy Instantiation................................................................ 245
14.2.1 Partial and Full Instantiation............................................ 245
14.2.2 Instantiated Components................................................... 246
14.3 The C++ Instantiation Model....................................................... 249
14.3.1 Two-Phase Lookup ....................................................... 249
14.3.2 Points of Instantiation................................................... 250
14.3.3 The Inclusion Model....................................................... 254
14.4 Implementation Schemes............................................................ 255
14.4.1 Greedy Instantiation..................................................... 256
14.4.2 Queried Instantiation .................................................... 257
14.4.3 Iterated Instantiation.................................................... 259
14.5 Explicit Instantiation.......................................................... 260
14.5.1 Manual Instantiation...................................................... 260
14.5.2 Explicit Instantiation Declarations....................................... 262
14.6 Compile-Time if Statements....................................................... 263
14.7 In the Standard Library........................................................... 265
14.8 Aftemotes...................................................................... 266 15
15 Template Argument Deduction 269
15.1 The Deduction Process ............................................................ 269
15.2 Deduced Contexts ................................................................ 271
15.3 Special Deduction Situations...................................................... 273
15.4 Initializer Lists................................................................. 274
XIV
Contents
15.5 Parameter Packs ............................................................. 275
15.5.1 Literal Operator Templates............................................. 277
15.6 Rvalue References.............................................................. 277
15.6.1 Reference Collapsing Rules............................................. 277
15.6.2 Forwarding References.................................................. 278
15.6.3 Perfect Forwarding..................................................... 280
15.6.4 Deduction Surprises.................................................... 283
15.7 SFINAE (Substitution Failure Is Not An Error).................................. 284
15.7.1 Immediate Context...................................................... 285
15.8 Limitations of Deduction....................................................... 286
15.8.1 Allowable Argument Conversions ........................................ 287
15.8.2 Class Template Arguments............................................... 288
15.8.3 Default Call Arguments................................................. 289
15.8.4 Exception Specifications............................................... 290
15.9 Explicit Function Template Arguments........................................... 291
15.10 Deduction from Initializers and Expressions .................................. 293
15.10.1 The auto type Specifier................................................ 294
15.10.2 Expressing the Type of an Expression with decltype ................. 298
15.10.3 decltype (auto)..................................................... 301
15.10.4 Special Situations for auto Deduction................... 303
15.10.5 Structured Bindings................................................... 306
15.10.6 Generic Lambdas....................................................... 309
15.11 Alias Templates.............................................. . . .......... 312
15.12 Class Template Argument Deduction............................................. 313
15.12.1 Deduction Guides....................................................... 314
15.12.2 Implicit Deduction Guides............................................. 316
15.12.3 Other Subtleties ..................................................... 318
15.13 Aftemotes..................................................................... 321
16 Specialization and Overloading 323
16.1 When “Generic Code” Doesn’t Quite Cut It....................................... 323
16.1.1 Transparent Customization . . . ...................................... 324
16.1.2 Semantic Transparency................................................. 325
Contents
xv
16.2 Overloading Function Templates .............................................. 326
16.2.1 Signatures............................................................ 328
16.2.2 Partial Ordering of Overloaded Function Templates..................... 330
16.2.3 Formal Ordering Rules................................................. 331
16.2.4 Templates and Nontemplates............................................ 332
16.2.5 Variadic Function Templates........................................... 335
16.3 Explicit Specialization...................................................... 338
16.3.1 Full Class Template Specialization................................... 338
16.3.2 Full Function Template Specialization................................. 342
16.3.3 Full Variable Template Specialization................................. 344
16.3.4 Full Member Specialization............................................ 344
16.4 Partial Class Template Specialization........................................ 347
16.5 Partial Variable Template Specialization..................................... 351
16.6 Aftemotes.................................................................... 352
17 Future Directions 353
17.1 Relaxed typename Rules....................................................... 354
17.2 Generalized Nontype Template Parameters...................................... 354
17.3 Partial Specialization of Function Templates................................. 356
17.4 Named Template Arguments..................................................... 358
17.5 Overloaded Class Templates................................................... 359
17.6 Deduction for Nonfinal Pack Expansions ...................................... 360
17.7 Regularization of void..................................................... 361
17.8 Type Checking for Templates ................................................. 361
17.9 Reflective Metaprogramming................................................... 363
17.10 Pack Facilities............................................................. 365
17.11 Modules.................................................................... 366
Part III: Templates and Design 367
18 The Polymorphic Power of Templates 369
18.1 Dynamic Polymorphism......................................................... 369
18.2 Static Polymorphism......................................................... 372
XVI
Contents
18.3 Dynamic versus Static Polymorphism............................................ 375
18.4 Using Concepts............................................................... 377
18.5 New Forms of Design Patterns................................................. 379
18.6 Generic Programming........................................................... 380
18.7 Aftemotes.................................................................... 383
19 Implementing Traits 385
19.1 An Example: Accumulating a Sequence........................................... 385
19.1.1 Fixed Traits.......................................................... 386
19.1.2 Value Traits.......................................................... 389
19.1.3 Parameterized Traits.................................................. 394
19.2 Traits versus Policies and Policy Classes..................................... 394
19.2.1 Traits and Policies: What’s the Difference?........................... 397
19.2.2 Member Templates versus Template Template Parameters.................. 398
19.2.3 Combining Multiple Policies and/or Traits............................. 399
19.2.4 Accumulation with General Iterators.................., , . ......... 399
19.3 Type Functions............................................................... 401
19.3.1 Element Types........................................................ 401
19.3.2 Transformation Traits................................................. 404
19.3.3 Predicate Traits.................................................... 410
19.3.4 Result Type Traits.................................................... 413
19.4 SFINAE-Based Traits........................................................... 416
19.4.1 SFINAE Out Function Overloads......................................... 416
19.4.2 SFINAE Out Partial Specializations.................................... 420
19.4.3 Using Generic Lambdas for SFINAE...................................... 421
19.4.4 SFINAE-Friendly Traits ............................................... 424
19.5 IsConvertibleT................................................................ 428
19.6 Detecting Members ............................................................ 431
19.6.1 Detecting Member Types................................................ 431
19.6.2 Detecting Arbitrary Member Types...................................... 433
19.6.3 Detecting Nontype Members............................................. 434
19.6.4 Using Generic Lambdas to Detect Members............................... 438
19.7 Other Traits Techniques....................................................... 440
19.7.1 If-Then-Else.......................................................... 440
Contents
XVII
19.7.2 Detecting Nonthrowing Operations...................................... 443
19.7.3 Traits Convenience.................................................... 446
19.8 Type Classification.......................................................... 448
19.8.1 Determining Fundamental Types......................................... 448
19.8.2 Determining Compound Types ......................................... 451
19.8.3 Identifying Function Types........................................... 454
19.8.4 Determining Class Types.............................................‘. 456
19.8.5 Determining Enumeration Types......................................... 457
19.9 Policy Traits................................................................ 458
19.9.1 Read-Only Parameter Types............................................. 458
19.10 In the Standard Library.................................................... 461
19.11 Aftemotes................................................................... 462
20 Overloading on Type Properties 465
20.1 Algorithm Specialization..................................................... 465
- 20.2 Tag Dispatching.............................................................. 467
20.3 Enabling/Disabling Function Templates........................................ 469
20.3.1 Providing Multiple Specializations.................................... 471
20.3.2 Where Does the Enablelf Go?........................................... 472
20.3.3 Compile-Time if ...................................................... 474
20.3.4 Concepts.............................................................. 475
20.4 Class Specialization........................................................ 477
20.4.1 Enabling/Disabling Class Templates.................................... 477
20.4.2 Tag Dispatching for Class Templates................................... 479
20.5 Instantiation-Safe Templates................................................. 482
20.6 In the Standard Library.................................................... 487
20.7 Aftemotes.................................................................... 488
21 Templates and Inheritance 489
21.1 The Empty Base Class Optimization (EBCO)................................... 489
21.1.1 Layout Principles..................................................... 490
21.1.2 Members as Base Classes............................................... 492
21.2 The Curiously Recurring Template Pattern (CRTP)............................ 495
21.2.1 The Barton-Nackman Trick.............................................. 497
xviii Contents
21.2.2 Operator Implementations........................................... 500
21.2.3 Facades .......................................................... 501
21.3 Mixins.................................................................... 508
21.3.1 Curious Mixins.................................................... 510
21.3.2 Parameterized Virtuality........................................... 510
21.4 Named Template Arguments................................................ 512
21.5 Aftemotes................................................................. 515
22 Bridging Static and Dynamic Polymorphism 517
22.1 Function Objects, Pointers, and std: :function ..............■.......... 517
22.2 Generalized Function Pointers............................................. 519
22.3 Bridge Interface.......................................................... 522
22.4 Type Erasure.............................................................. 523
22.5 Optional Bridging ........................................................ 525
22.6 Performance Considerations................................................ 527
22.7 Aftemotes................................................................. 528
23 Metaprogramming 529
23.1 The State of Modem C++Metaprogramming..................................... 529
23.1.1 Value Metaprogramming.............................................. 529
23.1.2 Type Metaprogramming .............................................. 531
23.1.3 Hybrid Metaprogramming............................................. 532
23.1.4 Hybrid Metaprogramming for Unit Types.............................. 534
23.2 The Dimensions of Reflective Metaprogramming.............................. 537
23.3 The Cost of Recursive Instantiation....................................... 539
• 23.3.1 Tracking All Instantiations........................................ 540
23.4 Computational Completeness ............................................... 542
23.5 Recursive Instantiation versus Recursive Template Arguments .............. 542
23.6 Enumeration Values versus Static Constants................................ 543
23.7 Aftemotes................................................................. 545
24 Typelists 549
24.1 Anatomy of a Typelist..................................................... 549
Contents
xix
24.2 Typelist Algorithms........................................................ 551
24.2.1 Indexing............................................................. 551
24.2.2 Finding the Best Match............................................... 552
24.2.3 Appending to a Typelist............................................. 555
24.2.4 Reversing a Typelist................................................. . 557
24.2.5 Transforming a Typelist.............................................. 559
24.2.6 Accumulating Typelists............................................. . 560
24.2.7 Insertion Sort....................................................... 563
24.3 Nontype Typelists ........................................................... 566
24.3.1 Deducible Nontype Parameters......................................... 568
24.4 Optimizing Algorithms with Pack Expansions................................... 569
24.5 Cons-style Typelists......................................................... 571
24.6 Aftemotes..........,......................................................... 573
25 Tuples 575
25.1 Basic Tuple Design........................................................... 576
25.1.1 Storage............................................................ 576
25.1.2 Construction ....................................................... 578
25.2 Basic Tuple Operations....................................................... 579
25.2.1 Comparison........................................................... 579
25.2.2 Output............................................................... 580
25.3 Tuple Algorithms........................................................... 581
25.3.1 Tuples as Typelists.................................................. 581
25.3.2 Adding to and Removing from a Tuple ................................. 582
25.3.3 Reversing a Tuple.................................................... 584
25.3.4 Index Lists........................................................ 585
25.3.5 Reversal with Index Lists............................................ 586
25.3.6 Shuffle and Select.................................................. 588
25.4 Expanding Tuples ............................................................ 592
25.5 Optimizing Tuple...................................■........................ 593
25.5.1 Tuples and the EBCO................................................. 593
25.5.2 Constant-time get () ................................................ 598
25.6 Tuple Subscript.............................................................. 599
25.7 Aftemotes.................................................................... 601
XX
Contents
26 Discriminated Unions 603
26.1 Storage.................................................................... . . . 604
26.2 Design.......................................................................... 606
26.3 Value Query and Extraction...................................................... 610
26.4 Element Initialization, Assignment and Destruction.............................. 611
26.4.1 Initialization.......................................................... 611
26.4.2 Destruction............................................................. 612
26.4.3 Assignment.............................................................. 613
26.5 Visitors........................................................................ 617
26.5.1 Visit Result Type....................................................... 621
26.5.2 Common Result TVpe...................................................... 622
26.6 Variant Initialization and Assignment........................................... 624
26.7 Aftemotes....................................................................... 628
27 Expression Templates 629
27.1 Temporaries and Split Loops.................................................... 630
27.2 Encoding Expressions in Template Arguments..................................... 635
27.2.1 Operands of the Expression Templates................................... 636
27.2.2 The Array Type.......................................................... 639
27.2.3 The Operators........................................................... 642
27.2.4 Review.................................................................. 643
27.2.5 Expression Templates Assignments....................................... 645
27.3 Performance and Limitations of Expression Templates............................. 646
27.4 Aftemotes...................................................................... 647
28 Debugging Templates 651
28.1 Shallow Instantiation........................................................... 652
28.2 Static Assertions............................................................... 654
28.3 Archetypes...................................................................... 655
28.4 Tracers......................................................................... 657
28.5 Oracles......................................................................... 662
28.6 Aftemotes....................................................................... 662
Contents
xxi
Appendixes 663
A The One-Definition Rule 663
A.l Translation Units........................................................... 663
A.2 Declarations and Definitions................................................. 664
A. 3 The One-Definition Rule in Detail........................................... 665
A.3.1 One-per-Program Constraints........................................... 665
A.3.2 One-per-Translation Unit Constraints ................................. 667
A. 3.3 Cross-Translation Unit Equivalence Constraints........................ 669
B Value Categories 673
B. l Traditional Lvalues and Rvalues............................................... 673
B. 1.1 Lvalue-to-Rvalue Conversions.......................................... 674
B.2 Value Categories Since C++11................................................. 674
B. 2.1 Temporary Materialization............................................. 676
B.3 Checking Value Categories with decltype...................................... 678
B. 4 Reference Types ............................................................. 679
C Overload Resolution 681
C. 1 When Does Overload Resolution Kick In?....................................... 681
C.2 Simplified Overload Resolution............................................... 682
C. 2.1 The Implied Argument for Member Functions............................. 684
C.2.2 Refining the Perfect Match.............................................. 686
C. 3 Overloading Details.......................................................... 688
C.3.1 Prefer Nontemplates or More Specialized Templates .................... 688
C.3.2 Conversion Sequences.................................................. 689
C.3.3 Pointer Conversions................................................... 689
C.3.4 Initializer Lists................................................... 691
C.3.5 Functors and Surrogate Functions...................................... 694
C. 3.6 Other Overloading Contexts............................................ 695
D Standard Type Utilities 697
D. l Using Type Traits............................................................. 697
D. 1.1 std: :integral_constant and std: :bool_constant....................... 698
D.1.2 Things You Should Know When Using Traits ............................. 700
xxii Contents
D.2 Primary and Composite Type Categories....................................... .. 702
D.2.1 Testing for the Primary Type Category.................................. 702
D.2.2 Test for Composite Type Categories.................................... 706
D.3 Type Properties and Operations.............................................. 709
D.3.1 Other Type Properties............................................... 709
D.3.2 Test for Specific Operations......................................... 718
D. 3.3 Relationships Between Types............................................ 725
D.4 Type Construction............................................................ 728
D.5 Other Traits................................................................ 732
D.6 Combining Type Traits........................................................ 734
D. 7 Other Utilities................................................................ 737
E Concepts 739
E. l Using Concepts................................................................. 739
E.2 Defining Concepts.............................................................. 742
E.3 Overloading on Constraints..................................................... . 743
E. 3.1 Constraint Subsumption................................................. 744
E.3.2 Constraints and Tag Dispatching...................................... 745
E.4 Concept Tips ................................................................... 746
E.4.1 Testing Concepts.................................................... 746
E.4.2 Concept Granularity.................................................... 746
E.4.3 Binary Compatibility.................................................. 747
Bibliography 749
Forums.............................................................................. 749
Books and Web Sites................................................................. 750
Glossary 759
Index
771
|
| any_adam_object | 1 |
| author | Vandevoorde, David Josuttis, Nicolai M. 1962- Gregor, Douglas |
| author_GND | (DE-588)136212972 (DE-588)113893469 (DE-588)1148291415 |
| author_facet | Vandevoorde, David Josuttis, Nicolai M. 1962- Gregor, Douglas |
| author_role | aut aut aut |
| author_sort | Vandevoorde, David |
| author_variant | d v dv n m j nm nmj d g dg |
| building | Verbundindex |
| bvnumber | BV042527424 |
| classification_rvk | ST 250 |
| classification_tum | DAT 358f |
| ctrlnum | (OCoLC)1013589455 (DE-599)BVBBV042527424 |
| discipline | Informatik |
| edition | Second edition |
| format | Book |
| fullrecord | <?xml version="1.0" encoding="UTF-8"?><collection xmlns="http://www.loc.gov/MARC21/slim"><record><leader>01723nam a2200421 c 4500</leader><controlfield tag="001">BV042527424</controlfield><controlfield tag="003">DE-604</controlfield><controlfield tag="005">20240126 </controlfield><controlfield tag="007">t</controlfield><controlfield tag="008">150427s2018 a||| |||| 00||| eng d</controlfield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">9780321714121</subfield><subfield code="c">hbk</subfield><subfield code="9">978-0-321-71412-1</subfield></datafield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">0321714121</subfield><subfield code="c">hbk</subfield><subfield code="9">0-321-71412-1</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(OCoLC)1013589455</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(DE-599)BVBBV042527424</subfield></datafield><datafield tag="040" ind1=" " ind2=" "><subfield code="a">DE-604</subfield><subfield code="b">ger</subfield><subfield code="e">rda</subfield></datafield><datafield tag="041" ind1="0" ind2=" "><subfield code="a">eng</subfield></datafield><datafield tag="049" ind1=" " ind2=" "><subfield code="a">DE-703</subfield><subfield code="a">DE-M347</subfield><subfield code="a">DE-706</subfield><subfield code="a">DE-11</subfield><subfield code="a">DE-355</subfield><subfield code="a">DE-739</subfield><subfield code="a">DE-91G</subfield><subfield code="a">DE-83</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">ST 250</subfield><subfield code="0">(DE-625)143626:</subfield><subfield code="2">rvk</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">DAT 358f</subfield><subfield code="2">stub</subfield></datafield><datafield tag="100" ind1="1" ind2=" "><subfield code="a">Vandevoorde, David</subfield><subfield code="0">(DE-588)136212972</subfield><subfield code="4">aut</subfield></datafield><datafield tag="245" ind1="1" ind2="0"><subfield code="a">C++ templates</subfield><subfield code="b">the complete guide</subfield><subfield code="c">David Vandevoorde, Nicolai M. Josuttis, Douglas Gregor</subfield></datafield><datafield tag="250" ind1=" " ind2=" "><subfield code="a">Second edition</subfield></datafield><datafield tag="264" ind1=" " ind2="1"><subfield code="a">Boston [und 23 weitere]</subfield><subfield code="b">Addison-Wesley</subfield><subfield code="c">[2018]</subfield></datafield><datafield tag="264" ind1=" " ind2="4"><subfield code="c">© 2018</subfield></datafield><datafield tag="300" ind1=" " ind2=" "><subfield code="a">xxxiv, 788 Seiten</subfield><subfield code="b">Illustrationen, Diagramme</subfield></datafield><datafield tag="336" ind1=" " ind2=" "><subfield code="b">txt</subfield><subfield code="2">rdacontent</subfield></datafield><datafield tag="337" ind1=" " ind2=" "><subfield code="b">n</subfield><subfield code="2">rdamedia</subfield></datafield><datafield tag="338" ind1=" " ind2=" "><subfield code="b">nc</subfield><subfield code="2">rdacarrier</subfield></datafield><datafield tag="500" ind1=" " ind2=" "><subfield code="a">"Covers C++11, C++14, and C++17" - Auf dem Umschlag</subfield></datafield><datafield tag="650" ind1="0" ind2="7"><subfield code="a">STL</subfield><subfield code="0">(DE-588)4411326-2</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="650" ind1="0" ind2="7"><subfield code="a">C++</subfield><subfield code="0">(DE-588)4193909-8</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="689" ind1="0" ind2="0"><subfield code="a">C++</subfield><subfield code="0">(DE-588)4193909-8</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="0" ind2="1"><subfield code="a">STL</subfield><subfield code="0">(DE-588)4411326-2</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="0" ind2=" "><subfield code="5">DE-604</subfield></datafield><datafield tag="700" ind1="1" ind2=" "><subfield code="a">Josuttis, Nicolai M.</subfield><subfield code="d">1962-</subfield><subfield code="0">(DE-588)113893469</subfield><subfield code="4">aut</subfield></datafield><datafield tag="700" ind1="1" ind2=" "><subfield code="a">Gregor, Douglas</subfield><subfield code="0">(DE-588)1148291415</subfield><subfield code="4">aut</subfield></datafield><datafield tag="856" ind1="4" ind2="2"><subfield code="m">Digitalisierung UB Passau - ADAM Catalogue Enrichment</subfield><subfield code="q">application/pdf</subfield><subfield code="u">http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=027961722&sequence=000002&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA</subfield><subfield code="3">Inhaltsverzeichnis</subfield></datafield><datafield tag="999" ind1=" " ind2=" "><subfield code="a">oai:aleph.bib-bvb.de:BVB01-027961722</subfield></datafield></record></collection> |
| id | DE-604.BV042527424 |
| illustrated | Illustrated |
| indexdate | 2024-07-10T01:24:10Z |
| institution | BVB |
| isbn | 9780321714121 0321714121 |
| language | English |
| oai_aleph_id | oai:aleph.bib-bvb.de:BVB01-027961722 |
| oclc_num | 1013589455 |
| open_access_boolean | |
| owner | DE-703 DE-M347 DE-706 DE-11 DE-355 DE-BY-UBR DE-739 DE-91G DE-BY-TUM DE-83 |
| owner_facet | DE-703 DE-M347 DE-706 DE-11 DE-355 DE-BY-UBR DE-739 DE-91G DE-BY-TUM DE-83 |
| physical | xxxiv, 788 Seiten Illustrationen, Diagramme |
| publishDate | 2018 |
| publishDateSearch | 2018 |
| publishDateSort | 2018 |
| publisher | Addison-Wesley |
| record_format | marc |
| spelling | Vandevoorde, David (DE-588)136212972 aut C++ templates the complete guide David Vandevoorde, Nicolai M. Josuttis, Douglas Gregor Second edition Boston [und 23 weitere] Addison-Wesley [2018] © 2018 xxxiv, 788 Seiten Illustrationen, Diagramme txt rdacontent n rdamedia nc rdacarrier "Covers C++11, C++14, and C++17" - Auf dem Umschlag STL (DE-588)4411326-2 gnd rswk-swf C++ (DE-588)4193909-8 gnd rswk-swf C++ (DE-588)4193909-8 s STL (DE-588)4411326-2 s DE-604 Josuttis, Nicolai M. 1962- (DE-588)113893469 aut Gregor, Douglas (DE-588)1148291415 aut Digitalisierung UB Passau - ADAM Catalogue Enrichment application/pdf http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=027961722&sequence=000002&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA Inhaltsverzeichnis |
| spellingShingle | Vandevoorde, David Josuttis, Nicolai M. 1962- Gregor, Douglas C++ templates the complete guide STL (DE-588)4411326-2 gnd C++ (DE-588)4193909-8 gnd |
| subject_GND | (DE-588)4411326-2 (DE-588)4193909-8 |
| title | C++ templates the complete guide |
| title_auth | C++ templates the complete guide |
| title_exact_search | C++ templates the complete guide |
| title_full | C++ templates the complete guide David Vandevoorde, Nicolai M. Josuttis, Douglas Gregor |
| title_fullStr | C++ templates the complete guide David Vandevoorde, Nicolai M. Josuttis, Douglas Gregor |
| title_full_unstemmed | C++ templates the complete guide David Vandevoorde, Nicolai M. Josuttis, Douglas Gregor |
| title_short | C++ templates |
| title_sort | c templates the complete guide |
| title_sub | the complete guide |
| topic | STL (DE-588)4411326-2 gnd C++ (DE-588)4193909-8 gnd |
| topic_facet | STL C++ |
| url | http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=027961722&sequence=000002&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA |
| work_keys_str_mv | AT vandevoordedavid ctemplatesthecompleteguide AT josuttisnicolaim ctemplatesthecompleteguide AT gregordouglas ctemplatesthecompleteguide |