├── .gitattributes ├── .gitignore ├── CppTemplateTutorial.cpp ├── CppTemplateTutorial.sln ├── CppTemplateTutorial.vcxproj ├── CppTemplateTutorial.vcxproj.filters ├── ReadMe.md ├── stdafx.cpp ├── stdafx.h └── targetver.h /.gitattributes: -------------------------------------------------------------------------------- 1 | # Auto detect text files and perform LF normalization 2 | * text=auto 3 | 4 | # Custom for Visual Studio 5 | *.cs diff=csharp 6 | *.sln merge=union 7 | *.csproj merge=union 8 | *.vbproj merge=union 9 | *.fsproj merge=union 10 | *.dbproj merge=union 11 | 12 | # Standard to msysgit 13 | *.doc diff=astextplain 14 | *.DOC diff=astextplain 15 | *.docx diff=astextplain 16 | *.DOCX diff=astextplain 17 | *.dot diff=astextplain 18 | *.DOT diff=astextplain 19 | *.pdf diff=astextplain 20 | *.PDF diff=astextplain 21 | *.rtf diff=astextplain 22 | *.RTF diff=astextplain 23 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | ################# 2 | ## Eclipse 3 | ################# 4 | 5 | *.pydevproject 6 | .project 7 | .metadata 8 | bin/ 9 | tmp/ 10 | *.tmp 11 | *.bak 12 | *.swp 13 | *~.nib 14 | local.properties 15 | .classpath 16 | .settings/ 17 | .loadpath 18 | 19 | # External tool builders 20 | .externalToolBuilders/ 21 | 22 | # Locally stored "Eclipse launch configurations" 23 | *.launch 24 | 25 | # CDT-specific 26 | .cproject 27 | 28 | # PDT-specific 29 | .buildpath 30 | 31 | 32 | ################# 33 | ## Visual Studio 34 | ################# 35 | 36 | ## Ignore Visual Studio temporary files, build results, and 37 | ## files generated by popular Visual Studio add-ons. 38 | 39 | # User-specific files 40 | *.suo 41 | *.user 42 | *.sln.docstates 43 | 44 | # Build results 45 | [Dd]ebug/ 46 | [Rr]elease/ 47 | *_i.c 48 | *_p.c 49 | *.ilk 50 | *.meta 51 | *.obj 52 | *.pch 53 | *.pdb 54 | *.pgc 55 | *.pgd 56 | *.rsp 57 | *.sbr 58 | *.tlb 59 | *.tli 60 | *.tlh 61 | *.tmp 62 | *.vspscc 63 | .builds 64 | *.dotCover 65 | 66 | ## TODO: If you have NuGet Package Restore enabled, uncomment this 67 | #packages/ 68 | 69 | # Visual C++ cache files 70 | ipch/ 71 | *.aps 72 | *.ncb 73 | *.opensdf 74 | *.sdf 75 | 76 | # Visual Studio profiler 77 | *.psess 78 | *.vsp 79 | 80 | # ReSharper is a .NET coding add-in 81 | _ReSharper* 82 | 83 | # Installshield output folder 84 | [Ee]xpress 85 | 86 | # DocProject is a documentation generator add-in 87 | DocProject/buildhelp/ 88 | DocProject/Help/*.HxT 89 | DocProject/Help/*.HxC 90 | DocProject/Help/*.hhc 91 | DocProject/Help/*.hhk 92 | DocProject/Help/*.hhp 93 | DocProject/Help/Html2 94 | DocProject/Help/html 95 | 96 | # Click-Once directory 97 | publish 98 | 99 | # Others 100 | [Bb]in 101 | [Oo]bj 102 | sql 103 | TestResults 104 | *.Cache 105 | ClientBin 106 | stylecop.* 107 | ~$* 108 | *.dbmdl 109 | Generated_Code #added for RIA/Silverlight projects 110 | 111 | # Backup & report files from converting an old project file to a newer 112 | # Visual Studio version. Backup files are not needed, because we have git ;-) 113 | _UpgradeReport_Files/ 114 | Backup*/ 115 | UpgradeLog*.XML 116 | 117 | 118 | 119 | ############ 120 | ## Windows 121 | ############ 122 | 123 | # Windows image file caches 124 | Thumbs.db 125 | 126 | # Folder config file 127 | Desktop.ini 128 | 129 | 130 | ############# 131 | ## Python 132 | ############# 133 | 134 | *.py[co] 135 | 136 | # Packages 137 | *.egg 138 | *.egg-info 139 | dist 140 | build 141 | eggs 142 | parts 143 | bin 144 | var 145 | sdist 146 | develop-eggs 147 | .installed.cfg 148 | 149 | # Installer logs 150 | pip-log.txt 151 | 152 | # Unit test / coverage reports 153 | .coverage 154 | .tox 155 | 156 | #Translations 157 | *.mo 158 | 159 | #Mr Developer 160 | .mr.developer.cfg 161 | 162 | # Mac crap 163 | .DS_Store 164 | -------------------------------------------------------------------------------- /CppTemplateTutorial.cpp: -------------------------------------------------------------------------------- 1 | #include "stdafx.h" 2 | #include 3 | #include 4 | 5 | #define WRONG_CODE_ENABLED 0 6 | 7 | // 0. Basic Form 8 | namespace _0 9 | { 10 | template // Old fasion: template 11 | class ClassA 12 | { 13 | T a; 14 | T* b; 15 | T foo(); 16 | void foo2(T const&); 17 | }; 18 | 19 | template 20 | class ClassB 21 | { 22 | int arr[Sz]; 23 | }; 24 | 25 | size_t a = sizeof(ClassB<3>); 26 | size_t b = sizeof(ClassB<7>); 27 | 28 | template void FunctionA(T const& param) 29 | { 30 | } 31 | 32 | template T FunctionB() 33 | { 34 | return T(); 35 | } 36 | } 37 | 38 | // 1.1 Nested in Class 39 | namespace _1_1 40 | { 41 | template // Old fasion: template 42 | class ClassA 43 | { 44 | T a; 45 | T* b; 46 | T foo(); 47 | template void foo2(T const&, U const&); 48 | }; 49 | } 50 | 51 | // 1.2 Instanciating 1 52 | namespace _1_2 53 | { 54 | _1_1::ClassA a; 55 | 56 | #if WRONG_CODE_ENABLED 57 | _1_1::ClassA b; // Wrong 58 | _1_1::ClassA c; // Wrong 59 | #endif 60 | } 61 | 62 | // 1.2.2 63 | 64 | namespace _1_2_2 65 | { 66 | template T Add(T a, T b) 67 | { 68 | return a + b; 69 | } 70 | 71 | template DstT c_style_cast(SrcT v) 72 | { 73 | return (DstT)(v); 74 | } 75 | 76 | #if WRONG_CODE_ENABLED 77 | void foo() 78 | { 79 | int a = 0; 80 | int b = 0; 81 | char c = 0; 82 | Add(b, c); 83 | } 84 | 85 | void foo2() 86 | { 87 | int v = 0; 88 | float i = c_style_cast(v); 89 | } 90 | #endif 91 | } 92 | 93 | // 1.3 Instanciating 2 94 | namespace _1_3 95 | { 96 | template class A 97 | { 98 | public: 99 | void foo() 100 | { 101 | } 102 | }; 103 | template class B {}; 104 | template class C {}; 105 | template ::*a)()> class D {}; 106 | 107 | #if WRONG_CODE_ENABLED 108 | template class E {}; 109 | #endif 110 | 111 | void foo() 112 | { 113 | A<5> a; 114 | B<7, A<5>, nullptr> b; 115 | C<&foo> c; 116 | D<&A<3>::foo> d; 117 | #if WRONG_CODE_ENABLED 118 | int x = 3; 119 | A b; 120 | #endif 121 | } 122 | 123 | #if WRONG_CODE_ENABLED 124 | const char* s = "abc"; 125 | template class S 126 | { 127 | }; 128 | 129 | void foo2() 130 | { 131 | S<"abc"> i; 132 | } 133 | #endif 134 | 135 | template 136 | class ClassB 137 | { 138 | T* a; 139 | }; 140 | 141 | template 142 | class ClassC 143 | { 144 | T a; 145 | }; 146 | 147 | struct StructA; // Declared but not be defined 148 | ClassB d; // Right 149 | #if WRONG_CODE_ENABLED 150 | ClassC e; // Wrong 151 | #endif 152 | } 153 | 154 | namespace _2_2_2 155 | { 156 | template class AddFloatOrMulInt 157 | { 158 | static T Do(T a, T b) 159 | { 160 | // 在这个例子里面一般形式里面是什么内容不重要，因为用不上 161 | // 这里就随便给个0吧。 162 | return T(0); 163 | } 164 | }; 165 | 166 | // 其次，我们要指定T是int时候的代码，这就是特化： 167 | template <> class AddFloatOrMulInt 168 | { 169 | public: 170 | static int Do(int a, int b) 171 | { 172 | return a * b; 173 | } 174 | }; 175 | 176 | // 再次，我们要指定T是float时候的代码： 177 | template <> class AddFloatOrMulInt 178 | { 179 | public: 180 | static float Do(float a, float b) 181 | { 182 | return a * b; 183 | } 184 | }; 185 | 186 | void foo() 187 | { 188 | float a(0), b(1); 189 | float c = AddFloatOrMulInt::Do(a, b); 190 | } 191 | } 192 | 193 | namespace _2_2_3 194 | { 195 | template class TypeToID 196 | { 197 | public: 198 | static int const ID = -1; 199 | }; 200 | 201 | class B {}; 202 | 203 | template <> class TypeToID; // 函数的TypeID 204 | template <> class TypeToID; // 数组的TypeID 205 | template <> class TypeToID; // 这是以数组为参数的函数的TypeID 206 | template <> class TypeToID; // 我也不知道这是什么了，自己看着办吧。 207 | 208 | template <> class TypeToID; 209 | } 210 | 211 | namespace _2_2_4 212 | { 213 | template struct X {}; 214 | 215 | template struct Y 216 | { 217 | typedef X ReboundType; 218 | #if WRONG_CODE_ENABLED 219 | typedef typename X::MemberType MemberType; 220 | typedef WTF MemberType3; 221 | #endif 222 | 223 | static void foo() 224 | { 225 | X instance0; 226 | typename X::MemberType instance1; 227 | WTF instance2 228 | 大王叫我来巡山 - + & 229 | } 230 | }; 231 | 232 | void foo() 233 | { 234 | #if WRONG_CODE_ENABLED 235 | Y::foo(); 236 | Y::foo(); 237 | #endif 238 | } 239 | } 240 | 241 | namespace _2_3_3 { 242 | struct A; 243 | template 244 | struct X 245 | { 246 | void foo(T v) { 247 | A a; 248 | a.v = v; 249 | } 250 | }; 251 | 252 | struct A 253 | { 254 | int v; 255 | }; 256 | 257 | int foo2() 258 | { 259 | X x; 260 | x.foo(5); 261 | return 0; 262 | } 263 | } 264 | 265 | // 1.4 Specialization, Partial Specialization, Full Specialization 266 | namespace _1_4 267 | { 268 | // Prototype of Templates I: Single Parameter 269 | template class ClassD 270 | { 271 | int a; 272 | }; 273 | 274 | // Specialization: Write a pattern for matching 275 | template <> class ClassD // 1. template <> 2. ClassD 276 | { 277 | int b; 278 | }; 279 | 280 | template <> class ClassD 281 | { 282 | int c; 283 | }; 284 | 285 | // Partial-Specialization: A partial pattern for matching 286 | template class ClassD // 1. template 2. ClassD 287 | { 288 | int d; 289 | }; 290 | 291 | template <> class ClassD // 1. template <> 2. ClassD 292 | { 293 | int e; 294 | }; 295 | 296 | // Question: 297 | 298 | // ClassD::? 299 | // ClassD::? 300 | // ClassD::? 301 | // ClassD::? 302 | // ClassD::? 303 | // ClassD::? 304 | 305 | // Prototype of Templates II: Multiple Parameter 306 | template class ClassE 307 | { 308 | int a; 309 | }; 310 | 311 | template class ClassE 312 | { 313 | int b; 314 | }; 315 | 316 | template class ClassE 317 | { 318 | int c; 319 | }; 320 | 321 | template class ClassE 322 | { 323 | int d; 324 | }; 325 | 326 | template class ClassE 327 | { 328 | int e; 329 | }; 330 | 331 | template <> class ClassE 332 | { 333 | int f; 334 | }; 335 | 336 | // Question: 337 | 338 | // ClassE::? 339 | // ClassE::? 340 | // ClassE::? 341 | // ClassE::? 342 | // ClassE::? 343 | 344 | // Member function specialization 345 | template 346 | class ClassF 347 | { 348 | public: 349 | void foo(); 350 | }; 351 | 352 | template 353 | void ClassF::foo() 354 | { 355 | } 356 | 357 | template <> 358 | void ClassF::foo() 359 | { 360 | } 361 | 362 | void foo() 363 | { 364 | ClassF().foo(); 365 | ClassF().foo(); 366 | } 367 | } 368 | 369 | // 2.1 Function Specialization 370 | namespace _2_1 371 | { 372 | // Overload is enabled but no partial-specialization 373 | template void foo(T const& x) {} 374 | template void foo(T& y) {} 375 | void foo(int&) {} 376 | void foo(int) {} 377 | 378 | // Specialization or Overloading 379 | template <> void foo(bool const& x) {} 380 | 381 | // Overloading 382 | template void foo(T const*) {} 383 | 384 | template void foo2(T const&, U const&); 385 | 386 | #if WRONG_CODE_ENABLED 387 | template void foo2(int const&, U const&); 388 | template void foo2(int const&, U const&); 389 | #endif 390 | 391 | // Overloading - Looks like partial specification 392 | template void foo2(int const&, U const&); 393 | template void foo2(T const*, U const&); 394 | 395 | // Don't forgot 396 | // T foo(...); 397 | 398 | // Specialize types which cannot be inferred by parameter 399 | template 400 | UninferableT foo3(InferableT const&) { return UninferableT(); } 401 | 402 | void test() 403 | { 404 | 405 | int x = 5; 406 | float y = 10.0f; 407 | foo(y); 408 | int const z = 5; 409 | foo(z); 410 | foo(true); 411 | foo3(0.0f); // Specialize types which is uninferable. 412 | 413 | #if WRONG_CODE_ENABLED 414 | foo(3); // Ambigous 415 | foo(x); // Ambigous 416 | #endif 417 | } 418 | } 419 | 420 | // 2.2 Example: Derived from template. 421 | namespace _2_2 422 | { 423 | template 424 | class ClassA 425 | { 426 | T x; 427 | }; 428 | 429 | template 430 | class ClassB 431 | { 432 | T* x; 433 | }; 434 | 435 | template 436 | class ClassC: public ClassB 437 | { 438 | T* x; 439 | }; 440 | 441 | ClassC a; 442 | 443 | #if WRONG_CODE_ENABLED 444 | class ClassC: public ClassA 445 | { 446 | }; 447 | #endif 448 | 449 | class ClassD: public ClassB 450 | { 451 | }; 452 | 453 | // ClassC =??= ClassD 454 | } 455 | 456 | // 3.1 Meta Switch-Case/If-Then-Else via Specialization 457 | namespace _3_1 458 | { 459 | bool equal(int a, int b) 460 | { 461 | return a == b; 462 | } 463 | 464 | // meta functions: 465 | // bool equal0(TypeA, TypeB) 466 | // { 467 | // return false; 468 | // } 469 | // bool equal1(TypeA, TypeA) 470 | // { 471 | // return true; 472 | // } 473 | // equal(A, A) == equal1(A, A) == true 474 | // euqla(A, B) == equal0(A, B) == false 475 | template 476 | class Equal 477 | { 478 | public: 479 | static bool const value = false; 480 | }; 481 | 482 | template 483 | class Equal 484 | { 485 | public: 486 | static bool const value = true; 487 | }; 488 | 489 | bool x = Equal::value; 490 | bool y = Equal::value; 491 | } 492 | 493 | // 3.2 SFINAE: Substitution Failure Is Not An Error. 494 | namespace _3_2 495 | { 496 | class ClassA 497 | { 498 | }; 499 | 500 | template struct Mark 501 | { 502 | char _[Sz]; 503 | }; 504 | 505 | #if WRONG_CODE_ENABLED 506 | template 507 | Mark<1> TestIncrementAdd(T const& v) 508 | { 509 | T tmp = v; 510 | ++tmp; 511 | return Mark<1>(); 512 | } 513 | 514 | template 515 | Mark<2> TestIncrementAdd(T const& v) 516 | { 517 | return Mark<2>(); 518 | } 519 | 520 | bool a = TestIncrementAdd( ClassA() ) ) == sizeof(Mark<1>); 521 | #endif 522 | 523 | // Right case: From Wiki 524 | class ClassB 525 | { 526 | public: 527 | typedef int Marker; 528 | }; 529 | 530 | template void test(typename T::Marker) { } 531 | template void test(T) { } 532 | 533 | void DoTest() 534 | { 535 | test(10); // Call #1. 536 | test(10); // Call #2. SFINAE for test(T::Marker). 537 | } 538 | } 539 | 540 | // 3.3 Application: Type Traits 541 | namespace _3_3 542 | { 543 | template class is_same; 544 | 545 | 546 | template class is_base_of; 547 | // is_base_of 548 | // 1. B is class, D is also class. 549 | // 2. D* could be convert to B* 550 | // 3. B != D 551 | 552 | // Fundamentals 553 | typedef char Accepted; 554 | typedef int Rejected; 555 | 556 | class B 557 | { 558 | }; 559 | 560 | class D: public B 561 | { 562 | }; 563 | 564 | class D2: public D 565 | { 566 | }; 567 | 568 | // Type is a class 569 | template 570 | class is_class 571 | { 572 | private: 573 | // SFINAE 574 | template static Accepted test( int U::* ); 575 | template static Rejected test(...); 576 | 577 | public: 578 | static const bool value = sizeof( test(0) ) == sizeof(Accepted); 579 | }; 580 | 581 | bool a = is_class::value; 582 | bool b = is_class::value; 583 | 584 | // B* could be convert to D* 585 | template 586 | class Convertible 587 | { 588 | private: 589 | // Not SFINAE 590 | static Accepted test(Dest*); 591 | static Rejected test(...); 592 | public: 593 | static const bool value = sizeof( test(static_cast(NULL)) ) == sizeof(Accepted); 594 | }; 595 | 596 | bool c = Convertible::value; 597 | bool d = Convertible::value; 598 | bool e = Convertible::value; 599 | 600 | // B != D 601 | using _3_1::Equal; 602 | 603 | template 604 | class is_base_of 605 | { 606 | public: 607 | static bool const value = 608 | is_class::value && 609 | is_class::value && 610 | Convertible::value && 611 | !Equal::value; 612 | }; 613 | 614 | bool f = is_base_of::value; 615 | bool g = is_base_of::value; 616 | bool h = is_base_of::value; 617 | bool i = is_base_of::value; 618 | 619 | // Questions: 620 | // remove_reference 621 | // remove_pointer 622 | // remove all qualifiers 623 | } 624 | 625 | // 3.4 Application: "Recursive" and Meta-Programming 626 | namespace _3_4 627 | { 628 | // sum a, a+1, ..., b-1, b 629 | int basic_algo(int a, int b) 630 | { 631 | int result = 0; 632 | for (int i = a; i <= b; ++i) 633 | { 634 | result += i; 635 | } 636 | return result; 637 | } 638 | 639 | // Template could not support variable 640 | 641 | // sum [a, b] without variable 642 | int recursive_algo(int a, int b) 643 | { 644 | if (a == b) 645 | { 646 | return b; 647 | } 648 | return a + recursive_algo(a+1, b); 649 | } 650 | 651 | // Translate to meta-programming 652 | template 653 | class MetaSum 654 | { 655 | public: 656 | static int const value = MetaSum::value + a; 657 | }; 658 | 659 | template 660 | class MetaSum 661 | { 662 | public: 663 | static int const value = a; 664 | }; 665 | 666 | int a = MetaSum<1, 10>::value; 667 | } 668 | 669 | // 3.5 Application: Meta-Fibonacci 670 | namespace _3_5 671 | { 672 | template 673 | class Fibonacci 674 | { 675 | public: 676 | static int const value = Fibonacci::value + Fibonacci::value; 677 | }; 678 | 679 | template <> 680 | class Fibonacci<0> 681 | { 682 | public: 683 | static int const value = 0; 684 | }; 685 | 686 | template <> 687 | class Fibonacci<1> 688 | { 689 | public: 690 | static int const value = 1; 691 | }; 692 | 693 | int a = Fibonacci<8>::value; 694 | } 695 | 696 | // 4 Directive word: typename and template 697 | namespace _4 698 | { 699 | // typename T::type x; 700 | // ??? typename ??? 701 | 702 | // typename T::template U x; 703 | // ??? template ??? 704 | 705 | class ClassA 706 | { 707 | public: 708 | typedef int NestedType; 709 | }; 710 | 711 | class ClassB 712 | { 713 | public: 714 | typedef ClassA::NestedType NestedType; 715 | }; 716 | 717 | template 718 | class ClassC 719 | { 720 | public: 721 | #if WRONG_CODE_ENABLED 722 | typedef T::NestedType NestedType; 723 | #endif 724 | typedef typename T::NestedType NestedType; 725 | typedef typename std::vector::iterator iterator; 726 | }; 727 | 728 | class ClassD 729 | { 730 | public: 731 | template class NestedType; 732 | }; 733 | 734 | template 735 | class ClassE 736 | { 737 | public: 738 | template class NestedType; 739 | }; 740 | 741 | template 742 | class ClassF 743 | { 744 | #if WRONG_CODE_ENABLED 745 | typedef typename T::NestedType NestedType; 746 | #endif 747 | typedef typename T::template NestedType NestedType; 748 | typedef typename ClassE::template NestedType NestedType2; 749 | }; 750 | 751 | ClassC a; 752 | ClassF b; 753 | } 754 | 755 | // 5.1 How to Construct Meta Operators 756 | namespace _5_1 757 | { 758 | // Expression = Value/Data Structure + Operator/Operations 759 | 760 | // Value in Templates: 761 | // Integral Constant (bool, char, unsigned, ...) 762 | // Type (typename) 763 | 764 | // 1. Trick: Constant <--> Type 765 | template 766 | class int_ 767 | { 768 | public: 769 | static int const value = i; 770 | }; 771 | 772 | int a = int_<5>::value; 773 | 774 | // This trick could work with overloading 775 | template 776 | void Do(T* obj, int_<2>) 777 | { 778 | } 779 | 780 | template 781 | void Do(T* obj, int_<1>) 782 | { 783 | } 784 | 785 | void foo() 786 | { 787 | Do( static_cast(nullptr), int_<1>() ); 788 | } 789 | 790 | template void DoAnotherWay(T* obj) 791 | { 792 | } 793 | 794 | // Boolean is more useful than integral in general. 795 | template 796 | class bool_ 797 | { 798 | public: 799 | static bool const value = v; 800 | }; 801 | 802 | typedef bool_ true_; 803 | typedef bool_ false_; 804 | 805 | #if WRONG_CODE_ENABLED 806 | // Aha, function cannot support partial specialization. 807 | template void DoAnotherWay(T* obj) {} 808 | template void DoAnotherWay(T* obj) {} 809 | #endif 810 | 811 | // 2. Operators: 812 | // add 813 | 814 | template 815 | class add_ 816 | { 817 | public: 818 | typedef int_ type; 819 | static int const value = type::value; 820 | }; 821 | 822 | #if WRONG_CODE_ENABLED 823 | // conflict 824 | template 825 | class add_ 826 | { 827 | public: 828 | typedef int_ type; 829 | static int const value = type::value; 830 | }; 831 | #endif 832 | template 833 | class add_c 834 | { 835 | public: 836 | typedef int_ type; 837 | static int const value = type::value; 838 | }; 839 | 840 | typedef add_< int_<2>, int_<3> >::type sum; 841 | int b = sum::value; 842 | 843 | typedef add_< int_<2>, int_<3> >::type sum_c; 844 | int c = sum_c::value; 845 | 846 | // another solution 847 | template 848 | class add2_: public int_ 849 | { 850 | }; 851 | int d = add2_< int_<2>, int_<3> >::value; 852 | 853 | // Other operators: sub, not, or, and ... 854 | } 855 | 856 | // 5.2 Example of Meta Programming: Meta-Vector 857 | namespace _5_2 858 | { 859 | // Array: elem[count] 860 | // Meta Array ? 861 | 862 | // Recursively Definition 863 | // 'Null' terminated 864 | template 865 | class pair_ 866 | { 867 | typedef HeadT head; 868 | typedef TailT tail; 869 | }; 870 | 871 | class Nil; 872 | 873 | // Try Use It to Definition 874 | typedef pair_< int, pair_ > > vector_3; 875 | 876 | template 877 | class make_vector_ 878 | { 879 | typedef pair_< T0, make_vector_ > type; 880 | }; 881 | 882 | template <> 883 | class make_vector_ 884 | { 885 | typedef Nil type; 886 | }; 887 | 888 | template 889 | class vector_: public make_vector_::type 890 | { 891 | }; 892 | 893 | typedef vector_ vector3; 894 | 895 | // Let's meta-program further 896 | // 897 | // push_back ? tip: push_back::type 898 | // pop ? 899 | // find ? 900 | // size ? 901 | } 902 | 903 | // 6.1 Template-Template Class 904 | 905 | // 6.2 High order function, closure and STL allocator rebind 906 | 907 | int _tmain(int argc, _TCHAR* argv[]) 908 | { 909 | return 0; 910 | } 911 | 912 | -------------------------------------------------------------------------------- /CppTemplateTutorial.sln: -------------------------------------------------------------------------------- 1 |  2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio 2012 4 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "CppTemplateTutorial", "CppTemplateTutorial.vcxproj", "{E86AB3E9-316E-4D00-BBA3-B7CEDFA99D62}" 5 | EndProject 6 | Global 7 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 8 | Debug|Win32 = Debug|Win32 9 | Release|Win32 = Release|Win32 10 | EndGlobalSection 11 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 12 | {E86AB3E9-316E-4D00-BBA3-B7CEDFA99D62}.Debug|Win32.ActiveCfg = Debug|Win32 13 | {E86AB3E9-316E-4D00-BBA3-B7CEDFA99D62}.Debug|Win32.Build.0 = Debug|Win32 14 | {E86AB3E9-316E-4D00-BBA3-B7CEDFA99D62}.Release|Win32.ActiveCfg = Release|Win32 15 | {E86AB3E9-316E-4D00-BBA3-B7CEDFA99D62}.Release|Win32.Build.0 = Release|Win32 16 | EndGlobalSection 17 | GlobalSection(SolutionProperties) = preSolution 18 | HideSolutionNode = FALSE 19 | EndGlobalSection 20 | EndGlobal 21 | -------------------------------------------------------------------------------- /CppTemplateTutorial.vcxproj: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | Debug 6 | Win32 7 | 8 | 9 | Release 10 | Win32 11 | 12 | 13 | 14 | {E86AB3E9-316E-4D00-BBA3-B7CEDFA99D62} 15 | Win32Proj 16 | CppTemplateTutorial 17 | 18 | 19 | 20 | Application 21 | true 22 | v140 23 | Unicode 24 | 25 | 26 | Application 27 | false 28 | v140 29 | true 30 | Unicode 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | true 44 | 45 | 46 | false 47 | 48 | 49 | 50 | 51 | 52 | Level3 53 | Disabled 54 | WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) 55 | 56 | 57 | Console 58 | true 59 | 60 | 61 | 62 | 63 | Level3 64 | 65 | 66 | MaxSpeed 67 | true 68 | true 69 | WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) 70 | 71 | 72 | Console 73 | true 74 | true 75 | true 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | -------------------------------------------------------------------------------- /CppTemplateTutorial.vcxproj.filters: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | {4FC737F1-C7A5-4376-A066-2A32D752A2FF} 6 | cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx 7 | 8 | 9 | {93995380-89BD-4b04-88EB-625FBE52EBFB} 10 | h;hpp;hxx;hm;inl;inc;xsd 11 | 12 | 13 | {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} 14 | rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms 15 | 16 | 17 | 18 | 19 | Header Files 20 | 21 | 22 | Header Files 23 | 24 | 25 | 26 | 27 | Source Files 28 | 29 | 30 | Source Files 31 | 32 | 33 | 34 | 35 | 36 | -------------------------------------------------------------------------------- /ReadMe.md: -------------------------------------------------------------------------------- 1 |  2 | # C++ Template 进阶指南 3 | 4 | ## 0. 前言 5 | 6 | ###0.1 C++另类简介：比你用的复杂，但比你想的简单 7 | 8 | C++似乎从他为世人所知的那天开始便成为天然的话题性编程语言。在它在周围有着形形色色的赞美与贬低之词。当我在微博上透露欲写此文的意愿时，也收到了很多褒贬不一的评论。作为一门语言，能拥有这么多使用并恨着它、使用并畏惧它的用户，也算是语言丛林里的奇观了。 9 | 10 | C++之所以变成一门层次丰富、结构多变、语法繁冗的语言，是有着多层次的原因的。Bjarne在《The Design and Evolution of C++》一书中，详细的解释了C++为什么会变成如今（C++98/03）的模样。这本书也是我和陈梓瀚一直对各位已经入门的新手强烈推荐的一本书。通过它你多少可以明白，C++的诸多语法要素之所以变成如今的模样，实属迫不得已。 11 | 12 | 模板作为C++中最有特色的语言特性，它堪称玄学的语法和语义，理所应当的成为初学者的梦魇。甚至很多工作多年的人也对C++的模板部分保有充分的敬畏。在多数的编码标准中，Template俨然和多重继承一样，成为了一般程序员（非程序库撰写者）的禁区。甚至运用模板较多的Boost，也成为了“众矢之的”。 13 | 14 | 但是实际上C++模板远没有想象的那么复杂。我们只需要换一个视角：在C++03的时候，模板本身就可以独立成为一门“语言”。它有“值”，有“函数”，有“表达式”和“语句”。除了语法比较蹩脚外，它既没有指针也没有数组，更没有C++里面复杂的继承和多态。可以说，它要比C语言要简单的多。如果我们把模板当做是一门语言来学习，那只需要花费学习OO零头的时间即可掌握。按照这样的思路，可以说在各种模板书籍中出现的多数技巧，都可以被轻松理解。 15 | 16 | 简单回顾一下模板的历史。87年的时候，泛型（Generic Programming）便被纳入了C++的考虑范畴，并直接导致了后来模板语法的产生。可以说模板语法一开始就是为了在C++中提供泛型机制。92年的时候，Alexander Stepanov开始研究利用模板语法制作程序库，后来这一程序库发展成STL，并在93年被接纳入标准中。 17 | 18 | 此时不少人以为STL已经是C++模板的集大成之作，C++模板技止于此。但是在95年的《C++ Report》上，John Barton和Lee Nackman提出了一个矩阵乘法的模板示例。可以说元编程在那个时候开始被很多人所关注。自此篇文章发表之后，很多大牛都开始对模板产生了浓厚的兴趣。其中对元编程技法贡献最大的当属Alexandrescu的《Modern C++ Design》及模板程序库Loki。这一2001年发表的图书间接地导致了模板元编程库的出现。书中所使用的Typelist等泛型组件，和Policy等设计方法令人耳目一新。但是因为全书用的是近乎Geek的手法来构造一切设施，因此使得此书阅读起来略有难度。 19 | 20 | 2002年出版的另一本书《C++ Templates》，可以说是在Template方面的集大成之作。它详细阐述了模板的语法、提供了和模板有关的语言细节信息，举了很多有代表性例子。但是对于模板新手来说，这本书细节如此丰富，让他们随随便便就打了退堂鼓缴械投降。 21 | 22 | 本文的写作初衷，就是通过“编程语言”的视角，介绍一个简单、清晰的“模板语言”。我会尽可能的将模板的诸多要素连串起来，用一些简单的例子帮助读者学习这门“语言”，让读者在编写、阅读模板代码的时候，能像 `if(exp) { dosomething(); }`一样的信手拈来，让“模板元编程”技术成为读者牢固掌握、可举一反三的有用技能。 23 | 24 | ###0.2 适宜读者群 25 | 26 | 因为本文并不是用于C++入门，例子中也多少会牵涉一些其它知识，因此如果读者能够具备以下条件，会读起来更加轻松： 27 | 28 | * 熟悉C++的基本语法； 29 | * 使用过STL； 30 | * 熟悉一些常用的算法，以及递归等程序设计方法。 31 | 32 | 此外，尽管第一章会介绍一些Template的基本语法，但是还是会略显单薄。因此也希望读者能对C++ Template最基本语法形式有所了解和掌握；如果会编写基本的模板函数和模板类那就更好了。 33 | 34 | 诚如上节所述，本文并不是《C++ Templates》的简单重复，与《Modern C++ Design》交叠更少。从知识结构上，我建议大家可以先读本文，再阅读《C++ Templates》获取更丰富的语法与实现细节，以更进一步；《Modern C++ Design》除了元编程之外，还有很多的泛型编程示例，原则上泛型编程的部分与我所述的内容交叉不大，读者在读完1-3章了解模板的基本规则之后便可阅读《MCD》的相应章节；元编程部分（如Typelist）建议在阅读完本文之后再行阅读，或许会更易理解。 35 | 36 | ###0.3 版权 37 | 38 | 本文是随写随即同步到Github上，因此在行文中难免会遗漏引用。本文绝大部分内容应是直接承出我笔，但是也不定会有他山之石。所有指涉内容我会尽量以引号框记，或在上下文和边角注记中标示，如有遗漏烦请不吝指出。 39 | 40 | 全文所有为我所撰写的部分，作者均保留所有版权。如果有需要转帖或引用，还请注明出处并告知于我。 41 | 42 | ###0.4 意见、建议、喷、补遗、写作计划 43 | 44 | * 需增加： 45 | * 模板的使用动机。 46 | * 建议： 47 | * 比较模板和函数的差异性 48 | * 蓝色：C++14 Return type deduction for normal functions 的分析 49 | 50 | ## 1. Template的基本语法 51 | 52 | ###1.1 Template Class基本语法 53 | 54 | ####1.1.1 Template Class的与成员变量定义 55 | 我们来回顾一下最基本的Template Class声明和定义形式： 56 | 57 | Template Class声明： 58 | ```C++ 59 | template class ClassA; 60 | ``` 61 | 62 | Template Class定义： 63 | ```C++ 64 | template class ClassA 65 | { 66 | T member; 67 | }; 68 | ``` 69 | 70 | `template` 是C++关键字，意味着我们接下来将定义一个模板。和函数一样，模板也有一系列参数。这些参数都被囊括在template之后的`< >`中。在上文的例子中， `typename T`便是模板参数。回顾一下与之相似的函数参数的声明形式： 71 | 72 | ``` C++ 73 | void foo(int a); 74 | ``` 75 | 76 | `T`则可以类比为函数形参`a`，这里的“模板形参”`T`，也同函数形参一样取成任何你想要的名字；`typename`则类似于例子中函数参数类型`int`，它表示模板参数中的`T`将匹配一个类型。除了 `typename` 之外，我们再后面还要讲到，整型也可以作为模板的参数。 77 | 78 | 在定义完模板参数之后，便可以定义你所需要的类。不过在定义类的时候，除了一般类可以使用的类型外，你还可以使用在模板参数中使用的类型 `T`。可以说，这个 `T`是模板的精髓，因为你可以通过指定模板实参，将T替换成你所需要的类型。 79 | 80 | 例如我们用`ClassA`来实例化模板类ClassA，那么`ClassA`可以等同于以下的定义： 81 | 82 | ``` C++ 83 | // 注意：这并不是有效的C++语法，只是为了说明模板的作用 84 | typedef class { 85 | int member; 86 | } ClassA; 87 | ``` 88 | 89 | 可以看出，通过模板参数替换类型，可以获得很多形式相同的新类型，有效减少了代码量。这种用法，我们称之为“泛型”（Generic Programming），它最常见的应用，即是STL中的容器模板类。 90 | 91 | ####1.1.2 模板的使用 92 | 93 | 对于C++来说，类型最重要的作用之一就是用它去产生一个变量。例如我们定义了一个动态数组（列表）的模板类`vector`，它对于任意的元素类型都具有push_back和clear的操作，我们便可以如下定义这个类： 94 | 95 | ```C++ 96 | template 97 | class vector 98 | { 99 | public: 100 | void push_back(T const&); 101 | void clear(); 102 | 103 | private: 104 | T* elements; 105 | }; 106 | ``` 107 | 108 | 此时我们的程序需要一个整型和一个浮点型的列表，那么便可以通过以下代码获得两个变量： 109 | 110 | ```C++ 111 | vector intArray; 112 | vector floatArray; 113 | ``` 114 | 115 | 此时我们就可以执行以下的操作，获得我们想要的结果： 116 | 117 | ```C++ 118 | intArray.push_back(5); 119 | floatArray.push_back(3.0f); 120 | ``` 121 | 122 | 变量定义的过程可以分成两步来看：第一步，`vector`将`int`绑定到模板类`vector`上，获得了一个“普通的类`vector`”；第二步通过“vector”定义了一个变量。 123 | 与“普通的类”不同，模板类是不能直接用来定义变量的。例如 124 | 125 | ```C++ 126 | vector unknownVector; // 错误示例 127 | ``` 128 | 129 | 这样就是错误的。我们把通过类型绑定将模板类变成“普通的类”的过程，称之为模板实例化（Template Instantiate）。实例化的语法是： 130 | 131 | ``` 132 | 模板名 < 模板实参1 [，模板实参2，...] > 133 | ``` 134 | 135 | 看几个例子： 136 | ```C++ 137 | vector 138 | ClassA 139 | 140 | template class ClassB 141 | { 142 | // Class body ... 143 | }; 144 | 145 | ClassB 146 | ``` 147 | 148 | 当然，在实例化过程中，被绑定到模板参数上的类型（即模板实参）需要与模板形参正确匹配。 149 | 就如同函数一样，如果没有提供足够并匹配的参数，模板便不能正确的实例化。 150 | 151 | ####1.1.3 模板类的成员函数定义 152 | 153 | 由于C++11正式废弃“模板导出”这一特性，因此在模板类的变量在调用成员函数的时候，需要看到完整的成员函数定义。因此现在的模板类中的成员函数，通常都是以内联的方式实现。 154 | 例如： 155 | 156 | ``` C++ 157 | template 158 | class vector 159 | { 160 | public: 161 | void clear() 162 | { 163 | // Function body 164 | } 165 | 166 | private: 167 | T* elements; 168 | }; 169 | ``` 170 | 171 | 当然，我们也可以将`vector::clear`的定义部分放在类型之外，只不过这个时候的语法就显得蹩脚许多： 172 | 173 | ```C++ 174 | template 175 | class vector 176 | { 177 | public: 178 | void clear(); // 注意这里只有声明 179 | private: 180 | T* elements; 181 | }; 182 | 183 | template 184 | void vector::clear() // 函数的实现放在这里 185 | { 186 | // Function body 187 | } 188 | ``` 189 | 190 | 函数的实现部分看起来略微拗口。我第一次学到的时候，觉得 191 | 192 | ``` C++ 193 | void vector::clear() 194 | { 195 | // Function body 196 | } 197 | ``` 198 | 199 | 这样不就行了吗？但是简单想就会知道，`clear`里面是找不到泛型类型`T`的符号的。 200 | 201 | 因此，在成员函数实现的时候，必须要提供模板参数。此外，为什么类型名不是`vector`而是`vector`呢？ 202 | 如果你了解过模板的偏特化与特化的语法，应该能看出，这里的vector在语法上类似于特化/偏特化。实际上，这里的函数定义也确实是成员函数的偏特化。特化和偏特化的概念，本文会在第二部分详细介绍。 203 | 204 | 综上，正确的成员函数实现如下所示： 205 | 206 | ``` C++ 207 | template // 模板参数 208 | void vector /*看起来像偏特化*/ ::clear() // 函数的实现放在这里 209 | { 210 | // Function body 211 | } 212 | ``` 213 | 214 | ###1.2 Template Function的基本语法 215 | 216 | ####1.2.1 Template Function的声明和定义 217 | 218 | 模板函数的语法与模板类基本相同，也是以关键字`template`和模板参数列表作为声明与定义的开始。模板参数列表中的类型，可以出现在参数、返回值以及函数体中。比方说下面几个例子 219 | 220 | ```C++ 221 | template void foo(T const& v); 222 | 223 | template T foo(); 224 | 225 | template U foo(T const&); 226 | 227 | template void foo() 228 | { 229 | T var; 230 | // ... 231 | } 232 | ``` 233 | 234 | 无论是函数模板还是类模板，在实际代码中看起来都是“千变万化”的。这些“变化”，主要是因为类型被当做了参数，导致代码中可以变化的部分更多了。 235 | 236 | 归根结底，模板无外乎两点： 237 | 238 | 1. 函数或者类里面，有一些类型我们希望它能变化一下，我们用标识符来代替它，这就是“模板参数”； 239 | 240 | 2. 在需要这些类型的地方，写上相对应的标识符（“模板参数”）。 241 | 242 | 当然，这里的“可变”实际上在代码编译好后就固定下来了，可以称之为编译期的可变性。 243 | 244 | 这里多啰嗦一点，主要也是想告诉大家，模板其实是个很简单的东西。 245 | 246 | 下面这个例子，或许可以帮助大家解决以下两个问题： 247 | 248 | 1. 什么样的需求会使用模板来解决？ 249 | 250 | 2. 怎样把脑海中的“泛型”变成真正“泛型”的代码？ 251 | 252 | ``` 253 | 举个例子：generic typed function ‘add’ 254 | ``` 255 | 256 | 在我遇到的朋友中，即便如此对他解释了模板，即便他了解了模板，也仍然会对模板产生畏难情绪。毕竟从形式上来说，模板类和模板函数都要较非模板的版本更加复杂，阅读代码所需要理解的内容也有所增多。 257 | 258 | 如何才能克服这一问题，最终视模板如平坦代码呢？ 259 | 260 | 答案只有一个：无他，唯手熟尔。 261 | 262 | 在学习模板的时候，要反复做以下的思考和练习： 263 | 264 | 1. 提出问题：我的需求能不能用模板来解决？ 265 | 266 | 2. 怎么解决？ 267 | 268 | 3. 把解决方案用代码写出来。 269 | 270 | 4. 如果失败了，找到原因。是知识有盲点（例如不知道怎么将 `T&` 转化成 `T`），还是不可行（比如试图利用浮点常量特化模板类，但实际上这样做是不可行的）？ 271 | 272 | 通过重复以上的练习，应该可以对模板的语法和含义都有所掌握。如果提出问题本身有困难，或许下面这个经典案例可以作为你思考的开始： 273 | 274 | 1. 写一个泛型的数据结构：例如，线性表，数组，链表，二叉树； 275 | 276 | 2. 写一个可以在不同数据结构、不同的元素类型上工作的泛型函数，例如求和； 277 | 278 | 当然和“设计模式”一样，模板在实际应用中，也会有一些固定的需求和解决方案。比较常见的场景包括：泛型（最基本的用法）、通过类型获得相应的信息（型别萃取）、编译期间的计算、类型间的推导和变换（从一个类型变换成另外一个类型，比如boost::function）。这些本文在以后的章节中会陆续介绍。 279 | 280 | ####1.2.2 模板函数的使用 281 | 282 | 我们先来看一个简单的函数模板，两个数相加： 283 | 284 | ``` C++ 285 | template T Add(T a, T b) 286 | { 287 | return a + b; 288 | } 289 | ``` 290 | 291 | 函数模板的调用格式是： 292 | 293 | ``` C++ 294 | 函数模板名 < 模板参数列表 > ( 参数 ) 295 | ``` 296 | 297 | 例如，我们想对两个 `int` 求和，那么套用类的模板实例化方法，我们可以这么写： 298 | 299 | ``` C++ 300 | int a = 5; 301 | int b = 3; 302 | int result = Add(a, b); 303 | ``` 304 | 305 | 这时我们等于拥有了一个新函数： 306 | 307 | ``` C++ 308 | int Add(int a, int b) { return a + b; } 309 | ``` 310 | 311 | 这时在另外一个偏远的程序角落，你也需要求和。而此时你的参数类型是 `float` ，于是你写下： 312 | 313 | ``` C++ 314 | Add(a, b); 315 | ``` 316 | 317 | 一切看起来都很完美。但如果你具备程序员的最佳美德——懒惰——的话，你肯定会这样想，我在调用 `Add(a, b)` 的时候， `a` 和 `b` 匹配的都是那个 `T`。编译器就应该知道那个 `T` 实际上是 `int` 呀？为什么还要我多此一举写 `Add` 呢？ 318 | 唔，我想说的是，编译器的作者也是这么想的。所以实际上你在编译器里面写下以下片段： 319 | 320 | ``` C++ 321 | int a = 5; 322 | int b = 3; 323 | int result = Add(a, b); 324 | ``` 325 | 326 | 编译器会心领神会的将 `Add` 变成 `Add`。但是编译器不能面对模棱两可的答案。比如你这么写的话呢？ 327 | 328 | ``` C++ 329 | int a = 5; 330 | char b = 3; 331 | int result = Add(a, b); 332 | ``` 333 | 334 | 第一个参数 `a` 告诉编译器，这个 `T` 是 `int`。编译器点点头说，好。但是第二个参数 `b` 不高兴了，告诉编译器说，你这个 `T`，其实是 `char`。 335 | 两个参数各自指导 `T` 的类型，编译器就不知道怎么做了。在Visual Studio 2012下，会有这样的提示： 336 | 337 | ``` 338 | error C2782: 'T _1_2_2::Add(T,T)' : template parameter 'T' is ambiguous 339 | ``` 340 | 341 | 好吧，"ambigous"，这个提示再明确不过了。 342 | 343 | 不过，只要你别逼得编译器精神分裂的话，编译器其实是非常聪明的，它可以从很多的蛛丝马迹中，猜测到你真正的意图，有如下面的例子： 344 | 345 | ``` C++ 346 | template class A {}; 347 | 348 | template T foo( A v ); 349 | 350 | A v; 351 | foo(v); // 它能准确的猜到 T 是 int. 352 | ``` 353 | 354 | 咦，编译器居然绕过了A这个外套，猜到了 `T` 匹配的是 `int`。编译器是怎么完成这一“魔法”的，我们暂且不表，2.2节时再和盘托出。 355 | 356 | 下面轮到你的练习时间了。你试着写了很多的例子，但是其中一个你还是犯了疑惑： 357 | 358 | ``` C++ 359 | float data[1024]; 360 | 361 | template T GetValue(int i) 362 | { 363 | return static_cast(data[i]); 364 | } 365 | 366 | float a = GetValue(0); // 出错了！ 367 | int b = GetValue(1); // 也出错了！ 368 | ``` 369 | 370 | 为什么会出错呢？你仔细想了想，原来编译器是没办法去根据返回值推断类型的。函数调用的时候，返回值被谁接受还不知道呢。如下修改后，就一切正常了： 371 | 372 | ``` C++ 373 | float a = GetValue(0); 374 | int b = GetValue(1); 375 | ``` 376 | 377 | 嗯，是不是so easy啊？嗯，你又信心满满的做了一个练习： 378 | 379 | 你要写一个模板函数叫 `c_style_cast`，顾名思义，执行的是C风格的转换。然后出于方便起见，你希望它能和 `static_cast` 这样的内置转换有同样的写法。于是你写了一个use case。 380 | 381 | ``` C++ 382 | DstT dest = c_style_cast(src); 383 | ``` 384 | 385 | 根据调用形式你知道了，有 `DstT` 和 `SrcT` 两个模板参数。参数只有一个， `src`，所以函数的形参当然是这么写了： `(SrcT src)`。实现也很简单， `(DstT)v`。 386 | 387 | 我们把手上得到的信息来拼一拼，就可以编写自己的函数模板了： 388 | 389 | ``` C++ 390 | template DstT c_style_cast(SrcT v) 391 | { 392 | return (DstT)(v); 393 | } 394 | 395 | int v = 0; 396 | float i = c_style_cast(v); 397 | ``` 398 | 399 | 嗯，很Easy嘛！我们F6一下…咦！这是什么意思！ 400 | 401 | ``` C++ 402 | error C2783: 'DstT _1_2_2::c_style_cast(SrcT)' : could not deduce template argument for 'DstT' 403 | ``` 404 | 405 | 然后你仔细的比较了一下，然后发现 … 模板参数有两个，而参数里面能得到的只有 `SrcT` 一个。结合出错信息看来关键在那个 `DstT` 上。这个时候，你死马当活马医，把模板参数写完整了： 406 | 407 | ``` C++ 408 | float i = c_style_cast(v); 409 | ``` 410 | 411 | 嗯，很顺利的通过了。难道C++不能支持让参数推导一部分模板参数吗？ 412 | 413 | 当然是可以的。只不过在部分推导、部分指定的情况下，编译器对模版参数的顺序是有限制的：先写需要指定的模板参数，再把能推导出来的模板参数放在后面。 414 | 415 | 在这个例子中，能推导出来的是 `SrcT`，需要指定的是 `DstT`。把函数模板写成下面这样就可以了： 416 | 417 | ``` C++ 418 | template DstT c_style_cast(SrcT v) // 模版参数 DstT 需要人肉指定，放前面。 419 | { 420 | return (DstT)(v); 421 | } 422 | 423 | int v = 0; 424 | float i = c_style_cast(v); // 形象地说，DstT会先把你指定的参数吃掉，剩下的就交给编译器从函数参数列表中推导啦。 425 | ``` 426 | 427 | ###1.3 整型也可是Template参数 428 | 429 | 模板参数除了类型外（包括基本类型、结构、类类型等），也可以是一个整型数（Integral Number）。这里的整型数比较宽泛，包括布尔、不同位数、有无符号的整型，甚至包括指针。我们将整型的模板参数和类型作为模板参数来做一个对比： 430 | 431 | ``` C++ 432 | template class TemplateWithType; 433 | template class TemplateWithValue; 434 | ``` 435 | 436 | 我想这个时候你也更能理解 `typename` 的意思了：它相当于是模板参数的“类型”，告诉你 `T` 是一个 `typename`。 437 | 438 | 按照C++ Template最初的想法，模板不就是为了提供一个类型安全、易于调试的宏吗？有类型就够了，为什么要引入整型参数呢？考虑宏，它除了代码替换，还有一个作用是作为常数出现。所以整型模板参数最基本的用途，也是定义一个常数。例如这段代码的作用： 439 | 440 | ``` C++ 441 | template struct Array 442 | { 443 | T data[Size]; 444 | }; 445 | 446 | Array arr; 447 | ``` 448 | 449 | 便相当于下面这段代码： 450 | 451 | ``` C++ 452 | class IntArrayWithSize16 453 | { 454 | int data[16]; // int 替换了 T, 16 替换了 Size 455 | }; 456 | 457 | IntArrayWithSize16 arr; 458 | ``` 459 | 460 | 其中有一点要注意的是，因为模板的匹配是在编译的时候完成的，所以实例化模板的时候所使用的参数，也必须要在编译期就能确定。例如以下的例子编译器就会报错： 461 | 462 | ``` C++ 463 | template class A {}; 464 | 465 | void foo() 466 | { 467 | int x = 3; 468 | A<5> a; // 正确！ 469 | A b; // error C2971: '_1_3::A' : template parameter 'i' : 'x' : a local variable cannot be used as a non-type argument 470 | } 471 | ``` 472 | 因为x不是一个编译期常量，所以 `A` 就会告诉你，x是一个局部变量，不能作为一个模板参数出现。 473 | 474 | 嗯，这里我们再来写几个相对复杂的例子： 475 | 476 | ``` C++ 477 | template class A 478 | { 479 | public: 480 | void foo(int) 481 | { 482 | } 483 | }; 484 | template class B {}; 485 | template class C {}; 486 | template ::*a)(int)> class D {}; 487 | 488 | template int Add(int a) // 当然也能用于函数模板 489 | { 490 | return a + i; 491 | } 492 | 493 | void foo() 494 | { 495 | A<5> a; 496 | B< 497 | 7, A<5>, nullptr 498 | > b; // 模板参数可以是一个无符号八位整数，可以是模板生成的类；可以是一个指针。 499 | C c; // 模板参数可以是一个bool类型的常量，甚至可以是一个函数指针。 500 | D<&A<3>::foo> d; // 丧心病狂啊！它还能是一个成员函数指针！ 501 | int x = Add<3>(5); // x == 8。因为整型模板参数无法从函数参数获得，所以只能是手工指定啦。 502 | } 503 | 504 | template class E {}; // ERROR: 别闹！早说过只能是整数类型的啦！ 505 | ``` 506 | 507 | 当然，除了单纯的用作常数之外，整型参数还有一些其它的用途。这些“其它”用途最重要的一点是让类型也可以像整数一样运算。《Modern C++ Design》给我们展示了很多这方面的例子。不过你不用急着去阅读那本天书，我们会在做好足够的知识铺垫后，让你轻松学会这些招数。 508 | 509 | ###1.4 模板形式与功能是统一的 510 | 511 | 第一章走马观花的带着大家复习了一下C++ Template的基本语法形式，也解释了包括 `typename` 在内，类/函数模板写法中各个语法元素的含义。形式是功能的外在体现，介绍它们也是为了让大家能理解到，模板之所以写成这种形式是有必要的，而不是语言的垃圾成分。 512 | 513 | 从下一章开始，我们便进入了更加复杂和丰富的世界：讨论模板的匹配规则。其中有令人望而生畏的特化与偏特化。但是，请相信我们在序言中所提到的：将模板作为一门语言来看待，它会变得有趣而简单。 514 | 515 | ## 2. 模板元编程基础 516 | ###2.1 编程，元编程，模板元编程 517 | 518 | 技术的学习是一个登山的过程。第一章是最为平坦的山脚道路。而从这一章开始，则是正式的爬坡。无论是我写作还是你阅读，都需要付出比第一章更多的代价。那么问题就是，付出更多的精力学习模板是否值得？ 519 | 520 | 这个问题很功利，但是一阵见血。因为技术的根本目的在于解决需求。那C++的模板能做什么？ 521 | 522 | 一个高（树）大（新）上（蜂）的回答是，C++里面的模板，犹如C中的宏、C#和Java中的自省（restropection）和反射（reflection）一样，是一个改变语言内涵，拓展语言外延的存在。 523 | 524 | 程序最根本的目的是什么？复现真实世界或人所构想的规律，减少重复工作的成本，或通过提升规模完成人所不能及之事。但是世间之事万千，有限的程序如何重现复杂的世界呢？ 525 | 526 | 答案是“抽象”。论及具体手段，无外乎“求同”与“存异”：概括一般规律，处理特殊情况。这也是软件工程所追求的目标。一般规律概括的越好，我们所付出的劳动也就越少。 527 | 528 | 同样的，作为脑力劳动的产品，程序本身也是有规律性的。《Modern C++ Design》中的前言就抛出了一连串有代表性的问题： 529 | 530 | ``` 531 | 如何撰写更高级的C++程式？ 532 | 如何应付即使在很干净的设计中仍然像雪崩一样的不相干细节？ 533 | 如何构建可复用组件，使得每次在不同程式中应用组件时无需大动干戈？ 534 | ``` 535 | 536 | 我们以数据结构举例。在程序里，你需要一些堆栈。这个堆栈的元素可能是整数、浮点或者别的什么类型。一份整型堆栈的代码可能是： 537 | 538 | ``` C++ 539 | class StackInt 540 | { 541 | public: 542 | void push(Int v); 543 | Int pop(); 544 | Int Find(Int x) 545 | { 546 | for(Int i = 1; i <= size; ) 547 | { 548 | if(data[i] == x) { return i; } 549 | } 550 | } 551 | // ... 其他代码 ... 552 | }; 553 | ``` 554 | 555 | 如果你要支持浮点了，那么你只能将代码再次拷贝出来，并作如下修改： 556 | 557 | ``` C++ 558 | class StackFloat 559 | { 560 | public: 561 | void push(Float v); 562 | Float pop(); 563 | Int Find(Float x) 564 | { 565 | for(Int i = 1; i <= size; ) 566 | { 567 | if(data[i] == x) { return i; } 568 | } 569 | } 570 | // ... 其他代码 ... 571 | }; 572 | ``` 573 | 574 | 当然也许你觉得这样做能充分体会代码行数增长的成就感。但是有一天，你突然发现：呀，`Find` 函数实现有问题了。怎么办？这个时候也许你只有两份这样的代码，那好说，一一去修正就好了。如果你有十个呢？二十个？五十个？ 575 | 576 | 时间一长，你就厌倦了这样的生活。你觉得每个堆栈都差不多，但是又有点不一样。为了这一点点不一样，你付出了太多的时间。吃饭的时间，泡妞的时间，睡觉的时间，看岛国小电影顺便练习小臂力量的时间。 577 | 578 | 于是便诞生了新的技术，来消解我们的烦恼。 579 | 580 | 这个技术的名字，并不叫“模板”，而是叫“元编程”。 581 | 582 | 元（meta）无论在中文还是英文里，都是个很“抽象（abstract）”的词。因为它的本意就是“抽象”。元编程，也可以说就是“编程的抽象”。用更好理解的说法，元编程意味着你撰写一段程序A，程序A会运行后生成另外一个程序B，程序B才是真正实现功能的程序。那么这个时候程序A可以称作程序B的元程序，撰写程序A的过程，就称之为“元编程”。 583 | 584 | 回到我们的堆栈的例子。真正执行功能的，其实仍然是浮点的堆栈、整数的堆栈、各种你所需要的类型的堆栈。但是因为这些堆栈之间太相似了，仅仅有着些微的不同，我们为什么不能有一个将相似之处囊括起来，同时又能分别体现出不同之处的程序呢？很多语言都提供了这样的机会。C中的宏，C++中的模板，Python中的Duck Typing，广义上将都能够实现我们的思路。 585 | 586 | 我们的目的，是找出程序之间的相似性，进行“元编程”。而在C++中，元编程的手段，可以是宏，也可以是模板。 587 | 588 | 宏的例子姑且不论，我们来看一看模板： 589 | 590 | ``` C++ 591 | template 592 | class Stack 593 | { 594 | public: 595 | void push(T v); 596 | T pop(); 597 | Int Find(T x) 598 | { 599 | for(Int i = 0; i <= size; ++i) 600 | { 601 | if(data[i] == x) { return i; } 602 | } 603 | } 604 | // ... 其他代码 ... 605 | }; 606 | 607 | typedef Stack StackInt; 608 | typedef Stack StackFloat; 609 | ``` 610 | 611 | 通过模板，我们可以将形形色色的堆栈代码分为两个部分，一个部分是不变的接口，以及近乎相同的实现；另外一部分是元素的类型，它们是需要变化的。因此同函数类似，需要变化的部分，由模板参数来反应；不变的部分，则是模板内的代码。可以看到，使用模板的代码，要比不使用模板的代码简洁许多。 612 | 613 | 如果元编程中所有的变化的量（或者说元编程的参数），都是类型，那么这样的编程，我们有个特定的称呼，叫“泛型”。 614 | 615 | 但是你会问，模板的发明，仅仅是为了做和宏几乎一样的替换工作吗？可以说是，也可以说不是。一方面，很多时候模板就是为了替换类型，这个时候作用上其实和宏没什么区别。只是宏是基于文本的替换，被替换的文本本身没有任何语义。只有替换完成，编译器才能进行接下来的处理。而模板会在分析模板时以及实例化模板时时候都会进行检查，而且源代码中也能与调试符号一一对应，所以无论是编译时还是运行时，排错都相对简单。 616 | 617 | 但是模板也和宏有很大的不同，否则此文也就不能成立了。模板最大的不同在于它是“可以运算”的。我们来举一个例子，不过可能有点牵强。考虑我们要写一个向量逐分量乘法。只不过这个向量，它非常的大。所以为了保证速度，我们需要使用SIMD指令进行加速。假设我们有以下指令可以使用： 618 | 619 | ``` 620 | Int8,16: N/A 621 | Int32 : VInt32Mul(int32 * 4, int32 * 4) 622 | Int64 : VInt64Mul(int64 * 2, int64 * 2) 623 | Float : VInt64Mul(float * 2, float * 2) 624 | ``` 625 | 所以对于Int8和Int16，我们需要提升到Int32，而Int32和Int64，各自使用自己的指令。所以我们需要实现下的逻辑： 626 | 627 | ``` C++ 628 | for(v4a, v4b : vectorsA, vectorsB) 629 | { 630 | if type is Int8, Int16 631 | VInt32Mul( ConvertToInt32(v4a), ConvertToInt32(v4b) ) 632 | elif type is Int32 633 | VInt32Mul( v4a, v4b ) 634 | elif type is Float 635 | ... 636 | } 637 | ``` 638 | 639 | 这里的问题就在于，如何根据 `type` 分别提供我们需要的实现？这里有两个难点。首先， `if(type == xxx) {}` 是不存在于C++中的。第二，即便存在根据 `type` 的分配方法，我们也不希望它在运行时branch，这样会变得很慢。我们希望它能按照类型直接就把代码编译好，就跟直接写的一样。 640 | 641 | 嗯，聪明你果然想到了，重载也可以解决这个问题。 642 | 643 | ``` C++ 644 | GenericMul(int8 * 4, int8 * 4); 645 | GenericMul(int16 * 4, int16 * 4); 646 | GenericMul(int32 * 4, int32 * 4); 647 | GenericMul(int64 * 4, int64 * 4); 648 | // 其它 Generic Mul ... 649 | 650 | for(v4a, v4b : vectorsA, vectorsB) 651 | { 652 | GenericMul(v4a, v4b); 653 | } 654 | 655 | ``` 656 | 657 | 这样不就可以了吗？ 658 | 659 | 唔，你赢了，是这样没错。但是问题是，我这个平台是你可没见过，它叫 `Deep Thought`， 特别缺心眼儿，不光有 `int8`，还有更奇怪的 `int9`, `int11`，以及可以代表世间万物的 `int42`。你总不能为之提供所有的重载吧？这简直就像你枚举了所有程序的输入，并为之提供了对应的输出一样。 660 | 661 | 好吧，我承认这个例子还是太牵强了。不过相信我，在你阅读完第二章和第三章之后，你会将这些特性自如地运用到你的程序之中。你的程序将会变成体现模板“可运算”威力的最好例子。 662 | 663 | ###2.2 模板世界的If-Then-Else：类模板的特化与偏特化 664 | 665 | ####2.2.1 根据类型执行代码 666 | 前一节的示例提出了一个要求：需要做出根据类型执行不同代码。要达成这一目的，模板并不是唯一的途径。比如之前我们所说的重载。如果把眼界放宽一些，虚函数也是根据类型执行代码的例子。此外，在C语言时代，也会有一些技法来达到这个目的，比如下面这个例子，我们需要对两个浮点做加法， 或者对两个整数做乘法： 667 | 668 | ``` C 669 | struct Variant 670 | { 671 | union 672 | { 673 | int x; 674 | float y; 675 | } data; 676 | uint32 typeId; 677 | }; 678 | 679 | Variant addFloatOrMulInt(Variant const* a, Variant const* b) 680 | { 681 | Variant ret; 682 | assert(a->typeId == b->typeId); 683 | if (a->typeId == TYPE_INT) 684 | { 685 | ret.x = a->x * b->x; 686 | } 687 | else 688 | { 689 | ret.y = a->y + b->y; 690 | } 691 | return ret; 692 | } 693 | 694 | ``` 695 | 696 | 更常见的是 `void*`: 697 | 698 | ``` C++ 699 | #define BIN_OP(type, a, op, b, result) (*(type const *)(result)) = (*(type const *)(a)) op (*(type const*)(b)) 700 | void doDiv(void* out, void const* data0, void const* data1, DATA_TYPE type) 701 | { 702 | if(type == TYPE_INT) 703 | { 704 | BIN_OP(int, data0, *, data1, out); 705 | } 706 | else 707 | { 708 | BIN_OP(float, data0, +, data1, out); 709 | } 710 | } 711 | ``` 712 | 713 | 在C++中比如在 `Boost.Any` 的实现中，运用了 `typeid` 来查询类型信息。和 `typeid` 同属于RTTI机制的 `dynamic_cast`，也经常会用来做类型判别的工作。我想你应该写过类似于下面的代码： 714 | 715 | ``` C++ 716 | IAnimal* animal = GetAnimalFromSystem(); 717 | 718 | IDog* maybeDog = dynamic_cast(animal); 719 | if(maybeDog) 720 | { 721 | maybeDog->Wangwang(); 722 | } 723 | ICat* maybeCat = dynamic_cast(animal); 724 | if(maybeCat) 725 | { 726 | maybeCat->Moemoe(); 727 | } 728 | ``` 729 | 730 | 当然，在实际的工作中，我们建议把需要 `dynamic_cast` 后执行的代码，尽量变成虚函数。不过这个已经是另外一个问题了。我们看到，不管是哪种方法都很难避免 `if` 的存在。而且因为输入数据的类型是模糊的，经常需要强制地、没有任何检查的转换成某个类型，因此很容易出错。 731 | 732 | 但是模板与这些方法最大的区别并不在这里。模板无论其参数或者是类型，它都是一个编译期分派的办法。编译期就能确定的东西既可以做类型检查，编译器也能进行优化，砍掉任何不必要的代码执行路径。例如在上例中， 733 | 734 | ``` C++ 735 | template T addFloatOrMulInt(T a, T b); 736 | 737 | // 迷之代码1：用于T是float的情况 738 | 739 | // 迷之代码2：用于T是int时的情况 740 | ``` 741 | 742 | 如果你运用了模板来实现，那么当传入两个不同类型的变量，或者不是 `int` 和 `float` 变量，编译器就会提示错误。但是如果使用了我们前述的 `Variant` 来实现，编译器可就管不了那么多了。但是，成也编译期，败也编译期。最严重的“缺点”，就是你没办法根据用户输入或者别的什么在运行期间可能发生变化的量来决定它产生、或执行什么代码。比如下面的代码段，它是不成立的。 743 | 744 | ``` C++ 745 | 746 | template 747 | int foo() { return i + j; } 748 | int main() 749 | { 750 | cin >> x >> y; 751 | return foo(); 752 | } 753 | 754 | ``` 755 | 756 | 这点限制也粉碎了妄图用模板来包办工厂（Factory）甚至是反射的梦想。尽管在《Modern C++ Design》中（别问我为什么老举这本书，因为《C++ Templates》和《Generic Programming》我只是囫囵吞枣读过，基本不记得了)大量运用模板来简化工厂方法；同时C++11和14中的一些机制如Vardric Template更是让这一问题的解决更加彻底。但无论如何，光靠模板你就是写不出依靠类名或者ID变量产生类型实例的代码。 757 | 758 | 所以说，从能力上来看，模板能做的事情都是编译期完成的。编译期完成的意思就是，当你编译一个程序的时候，所有的量就都已经确定了。比如下面的这个例子： 759 | 760 | ``` C++ 761 | int a = 3, b = 5; 762 | Variant aVar, bVar; 763 | aVar.setInt(a); // 我们新加上的方法，怎么实现的无所谓，大家明白意思就行了。 764 | bVar.setInt(b); 765 | Variant result = addFloatOrMulInt(aVar, bVar); 766 | ``` 767 | 768 | 除非世界末日，否则这个例子里不管你怎么蹦跶，单看代码我们就能知道， `aVar` 和 `bVar` 都一定会是整数。所以如果有合适的机制，编译器就能知道此处的 `addFloatOrMulInt` 中只需要执行 `Int` 路径上的代码，而且编译器在此处也能单独为 `Int` 路径生成代码，从而去掉那个不必要的 `if`。 769 | 770 | 在模板代码中，这个“合适的机制”就是指“特化”和“部分特化（Partial Specialization）”，后者也叫“偏特化”。 771 | 772 | ####2.2.2 特化 773 | 774 | 我的高中物理老师对我说过一句令我受用至今的话：把自己能做的事情做好。编写模板程序也是一样。当你试图用模板解决问题之前，先撇开那些复杂的语法要素，用最直观的方式表达你的需求： 775 | 776 | ``` C++ 777 | // 这里是伪代码，意思一下 778 | 779 | int|float addFloatOrMulInt(a, b) 780 | { 781 | if(type is Int) 782 | { 783 | return a * b; 784 | } 785 | else if (type is Float) 786 | { 787 | return a + b; 788 | } 789 | } 790 | 791 | void foo() 792 | { 793 | float a, b, c; 794 | c = addFloatOrMulInt(a, b); // c = a + b; 795 | 796 | int x, y, z; 797 | z = addFloatOrMulInt(x, y); // z = x * y; 798 | } 799 | ``` 800 | 801 | 因为这一节是讲类模板有关的特化和偏特化机制，所以我们不用普通的函数，而是用类的静态成员函数来做这个事情（这就是典型的没事找抽型）： 802 | 803 | ``` C++ 804 | // 这里仍然是伪代码，意思一下，too。 805 | class AddFloatOrMulInt 806 | { 807 | static int|float Do(a, b) 808 | { 809 | if(type is Int) 810 | { 811 | return a * b; 812 | } 813 | else if (type is Float) 814 | { 815 | return a + b; 816 | } 817 | } 818 | }; 819 | 820 | void foo() 821 | { 822 | float a, b, c; 823 | c = AddFloatOrMulInt::Do(a, b); // c = a + b; 824 | 825 | int x, y, z; 826 | z = AddFloatOrMulInt::Do(x, y); // z = x * y; 827 | } 828 | ``` 829 | 830 | 好，意思表达清楚了。我们先从调用方的角度，把这个形式改写一下： 831 | 832 | ``` C++ 833 | void foo() 834 | { 835 | float a, b, c; 836 | c = AddFloatOrMulInt::Do(a, b); // c = a + b; 837 | 838 | int x, y, z; 839 | z = AddFloatOrMulInt::Do(x, y); // z = x * y; 840 | } 841 | ``` 842 | 也许你不明白为什么要改写成现在这个样子。看不懂不怪你，怪我讲的不好。但是你别急，先看看这样改写以后能不能跟我们的目标接近一点。如果我们把 `AddFloatOrMulInt::Do` 看作一个普通的函数，那么我们可以写两个实现出来： 843 | 844 | ``` C++ 845 | float AddFloatOrMulInt::Do(float a, float b) 846 | { 847 | return a + b; 848 | } 849 | 850 | int AddFloatOrMulInt::Do(int a, int b) 851 | { 852 | return a * b; 853 | } 854 | 855 | void foo() 856 | { 857 | float a, b, c; 858 | c = AddFloatOrMulInt::Do(a, b); // c = a + b; 859 | 860 | int x, y, z; 861 | z = AddFloatOrMulInt::Do(x, y); // z = x * y; 862 | } 863 | ``` 864 | 865 | 这样是不是就很开心了？我们更进一步，把 `AddFloatOrMulInt::Do` 换成合法的类模板： 866 | 867 | ``` C++ 868 | // 这个是给float用的。 869 | template class AddFloatOrMulInt 870 | { 871 | T Do(T a, T b) 872 | { 873 | return a + b; 874 | } 875 | }; 876 | 877 | // 这个是给int用的。 878 | template class AddFloatOrMulInt 879 | { 880 | T Do(T a, T b) 881 | { 882 | return a * b; 883 | } 884 | }; 885 | 886 | void foo() 887 | { 888 | float a, b, c; 889 | 890 | // 嗯，我们需要 c = a + b; 891 | c = AddFloatOrMulInt::Do(a, b); 892 | // ... 觉得哪里不对劲 ... 893 | // ... 894 | // ... 895 | // ... 896 | // 啊！有两个AddFloatOrMulInt，class看起来一模一样，要怎么区分呢！ 897 | } 898 | ``` 899 | 好吧，问题来了！如何要让两个内容不同，但是模板参数形式相同的类进行区分呢？特化！特化（specialization）是根据一个或多个特殊的整数或类型，给出模板实例化时的一个指定内容。我们先来看特化是怎么应用到这个问题上的。 900 | ``` C++ 901 | // 首先，要写出模板的一般形式（原型） 902 | template class AddFloatOrMulInt 903 | { 904 | static T Do(T a, T b) 905 | { 906 | // 在这个例子里面一般形式里面是什么内容不重要，因为用不上 907 | // 这里就随便给个0吧。 908 | return T(0); 909 | } 910 | }; 911 | 912 | // 其次，我们要指定T是int时候的代码，这就是特化： 913 | template <> class AddFloatOrMulInt 914 | { 915 | public: 916 | static int Do(int a, int b) // 917 | { 918 | return a * b; 919 | } 920 | }; 921 | 922 | // 再次，我们要指定T是float时候的代码： 923 | template <> class AddFloatOrMulInt 924 | { 925 | public: 926 | static float Do(float a, float b) 927 | { 928 | return a + b; 929 | } 930 | }; 931 | 932 | void foo() 933 | { 934 | // 这里面就不写了 935 | } 936 | ``` 937 | 我们再把特化的形式拿出来一瞧：这货有点怪啊： `template <> class AddFloatOrMulInt`。别急，我给你解释一下。 938 | 939 | ``` C++ 940 | // 我们这个模板的基本形式是什么？ 941 | template class AddFloatOrMulInt; 942 | 943 | // 但是这个类，是给T是Int的时候用的，于是我们写作 944 | class AddFloatOrMulInt 945 | // 当然，这里编译是通不过的。 946 | 947 | // 但是它又不是个普通类，而是类模板的一个特化（特例）。 948 | // 所以前面要加模板关键字template， 949 | // 以及模板参数列表 950 | template class AddFloatOrMulInt; 951 | 952 | // 最后，模板参数列表里面填什么？因为原型的T已经被int取代了。所以这里就不能放任何额外的参数了。 953 | // 所以这里要放空。 954 | template <> class AddFloatOrMulInt 955 | { 956 | // ... 针对Int的实现 ... 957 | } 958 | 959 | // Bingo! 960 | ``` 961 | 962 | 哈，这样就好了。我们来做一个练习。我们有一些类型，然后你要用模板做一个对照表，让类型对应上一个数字。我先来做一个示范： 963 | 964 | ``` C++ 965 | 966 | template class TypeToID 967 | { 968 | public: 969 | static int const ID = -1; 970 | }; 971 | 972 | template <> class TypeToID 973 | { 974 | public: 975 | static int const ID = 0; 976 | }; 977 | ``` 978 | 979 | 然后呢，你的任务就是，要所有无符号的整数类型的特化（其实就是`uint8_t`到`uint64_t`啦），把所有的基本类型都赋予一个ID（当然是不一样的啦）。当你做完后呢，可以把类型所对应的ID打印出来，我仍然以 `uint8_t` 为例： 980 | 981 | ``` C++ 982 | void PrintID() 983 | { 984 | cout << "ID of uint8_t: " << TypeToID::ID << endl; 985 | } 986 | ``` 987 | 嗯，看起来挺简单的，是吧。但是这里透露出了一个非常重要的信号，我希望你已经能察觉出来了： `TypeToID` 如同是一个函数。这个函数只能在编译期间执行。它输入一个类型，输出一个ID。 988 | 989 | 如果你体味到了这一点，那么恭喜你，你的模板元编程已经开悟了。 990 | 991 | ####2.2.3 特化：一些其它问题 992 | 993 | 在上一节结束之后，你一定做了许多的练习。我们再来做三个练习。第一，给`float`一个ID；第二，给`void*`一个ID；第三，给任意类型的指针一个ID。先来做第一个: 994 | 995 | ``` C++ 996 | // ... 997 | // TypeToID 的模板“原型” 998 | // ... 999 | 1000 | template class TypeToID 1001 | { 1002 | static int const ID = 0xF10A7; 1003 | }; 1004 | ``` 1005 | 1006 | 嗯， 这个你已经了然于心了。那么`void*`呢？你想了想，这已经是一个复合类型了。不错你还是战战兢兢的写了下来： 1007 | 1008 | ``` C++ 1009 | template <> class TypeToID 1010 | { 1011 | static int const ID = 0x401d; 1012 | }; 1013 | 1014 | void PrintID() 1015 | { 1016 | cout << "ID of uint8_t: " << TypeToID::ID << endl; 1017 | } 1018 | ``` 1019 | 1020 | 遍译运行一下，对了。模板不过如此嘛。然后你觉得自己已经完全掌握了，并试图将所有C++类型都放到模板里面，开始了自我折磨的过程： 1021 | 1022 | ``` C++ 1023 | class ClassB {}; 1024 | 1025 | template <> class TypeToID; // 函数的TypeID 1026 | template <> class TypeToID; // 数组的TypeID 1027 | template <> class TypeToID; // 这是以数组为参数的函数的TypeID 1028 | template <> class TypeToID< 1029 | int (ClassB::*[3])(void*, float[2])>; // 我也不知道这是什么了，自己看着办吧。 1030 | ``` 1031 | 1032 | 甚至连 `const` 和 `volatile` 都能装进去 1033 | 1034 | ``` C++ 1035 | template <> class TypeToID; 1036 | ``` 1037 | 1038 | 此时就很明白了，只要 `<>` 内填进去的是一个C++能解析的合法类型，模板都能让你特化。不过这个时候如果你一点都没有写错的话， `PrintID` 中只打印了我们提供了特化的类型的ID。那如果我们没有为之提供特化的类型呢？比如说double？OK，实践出真知，我们来尝试着运行一下： 1039 | 1040 | ``` C++ 1041 | void PrintID() 1042 | { 1043 | cout << "ID of double: " << TypeToID::ID << endl; 1044 | } 1045 | ``` 1046 | 1047 | 嗯，它输出的是-1。我们顺藤摸瓜会看到， `TypeToID`的类模板“原型”的ID是值就是-1。通过这个例子可以知道，当模板实例化时提供的模板参数不能匹配到任何的特化形式的时候，它就会去匹配类模板的“原型”形式。 1048 | 1049 | 不过这里有一个问题要厘清一下。和继承不同，类模板的“原型”和它的特化类在实现上是没有关系的，并不是在类模板中写了 `ID` 这个Member，那所有的特化就必须要加入 `ID` 这个Member，或者特化就自动有了这个成员。完全没这回事。我们把类模板改成以下形式，或许能看的更清楚一点： 1050 | 1051 | ``` C++ 1052 | template class TypeToID 1053 | { 1054 | public: 1055 | static int const NotID = -2; 1056 | }; 1057 | 1058 | template <> class TypeToID 1059 | { 1060 | public: 1061 | static int const ID = 1; 1062 | }; 1063 | 1064 | void PrintID() 1065 | { 1066 | cout << "ID of float: " << TypeToID::ID << endl; // Print "1" 1067 | cout << "NotID of float: " << TypeToID::NotID << endl; // Error! TypeToID使用的特化的类，这个类的实现没有NotID这个成员。 1068 | cout << "ID of double: " << TypeToID::ID << endl; // Error! TypeToID是由模板类实例化出来的，它只有NotID，没有ID这个成员。 1069 | } 1070 | ``` 1071 | 1072 | 这样就明白了。类模板和类模板的特化的作用，仅仅是指导编译器选择哪个编译，但是特化之间、特化和它原型的类模板之间，是分别独立实现的。所以如果多个特化、或者特化和对应的类模板有着类似的内容，很不好意思，你得写上若干遍了。 1073 | 1074 | 第三个问题，是写一个模板匹配任意类型的指针。对于C语言来说，因为没有泛型的概念，因此它提供了无类型的指针`void*`。它的优点是，所有指针都能转换成它。它的缺点是，一旦转换称它后，你就再也不知道这个指针到底是指向`float`或者是`int`或者是`struct`了。 1075 | 1076 | 比如说`copy`。 1077 | 1078 | ``` C 1079 | void copy(void* dst, void const* src, size_t elemSize, size_t elemCount, void (*copyElem)(void* dstElem, void const* srcElem)) 1080 | { 1081 | void const* reader = src; 1082 | void const* writer = dst; 1083 | for(size_t i = 0; i < elemCount; ++i) 1084 | { 1085 | copyElem(writer, reader); 1086 | advancePointer(reader, elemSize); // 把Reader指针往后移动一些字节 1087 | advancePointer(writer, elemSize); 1088 | } 1089 | } 1090 | ``` 1091 | 1092 | 为什么要提供copyElem，是因为可能有些struct需要深拷贝，所以得用特殊的copy函数。这个在C++98/03里面就体现为拷贝构造和赋值函数。 1093 | 但是不管怎么搞，因为这个函数的参数只是`void*`而已，当你使用了错误的elemSize，或者传入了错误的copyElem，就必须要到运行的时候才有可能看出来。注意，这还只是有可能而已。 1094 | 1095 | 1096 | 那么C++有了模板后，能否既能匹配任意类型的指针，同时又保留了类型信息呢？答案是显然的。至于怎么写，那就得充分发挥你的直觉了： 1097 | 1098 | 首先，我们需要一个`typename T`来指代“任意类型”这四个字： 1099 | 1100 | ``` C++ 1101 | template 1102 | ``` 1103 | 1104 | 接下来，我们要写函数原型: 1105 | 1106 | ``` C++ 1107 | void copy(?? dest, ?? src, size_t elemCount); 1108 | ``` 1109 | 1110 | 这里的 `？？` 要怎么写呢？既然我们有了模板类型参数T，那我们不如就按照经验，写 `T*` 看看。 1111 | 1112 | ``` C++ 1113 | template 1114 | void copy(T* dst, T const* src, size_t elemCount); 1115 | ``` 1116 | 1117 | 编译一下，咦，居然通过了。看来这里的语法与我们以前学到的知识并没有什么不同。这也是语言设计最重要的一点原则：一致性。它可以让你辛辛苦苦体验到的规律不至于白费。 1118 | 最后就是实现： 1119 | 1120 | ``` C++ 1121 | template 1122 | void copy(T* dst, T const* src, size_t elemCount) 1123 | { 1124 | for(size_t i = 0; i < elemCount; ++i) 1125 | { 1126 | dst[i] = src[i]; 1127 | } 1128 | } 1129 | ``` 1130 | 1131 | 是不是简洁了许多？你不需要再传入size；只要你有正确的赋值函数，也不需要提供定制的copy；也不用担心dst和src的类型不匹配了。 1132 | 1133 | 最后，我们把函数模板学到的东西，也应用到类模板里面： 1134 | 1135 | ``` C++ 1136 | template // 嗯，需要一个T 1137 | class TypeToID // 我要对所有的指针类型特化，所以这里就写T* 1138 | { 1139 | public: 1140 | static int const ID = 0x80000000; // 用最高位表示它是一个指针 1141 | }; 1142 | ``` 1143 | 1144 | 最后写个例子来测试一下，看看我们的 `T*` 能不能搞定 `float*` 1145 | 1146 | ``` C++ 1147 | void PrintID() 1148 | { 1149 | cout << "ID of float*: " << TypeToID::ID << endl; 1150 | } 1151 | ``` 1152 | 1153 | 哈哈，大功告成。嗯，别急着高兴。待我问一个问题：你知道 `TypeToID` 后，这里的T是什么吗？换句话说，你知道下面这段代码打印的是什么吗？ 1154 | 1155 | ``` C++ 1156 | // ... 1157 | // TypeToID 的其他代码，略过不表 1158 | // ... 1159 | 1160 | template // 嗯，需要一个T 1161 | class TypeToID // 我要对所有的指针类型特化，所以这里就写T* 1162 | { 1163 | public: 1164 | typedef T SameAsT; 1165 | static int const ID = 0x80000000; // 用最高位表示它是一个指针 1166 | }; 1167 | 1168 | void PrintID() 1169 | { 1170 | cout << "ID of float*: " << TypeToID< TypeToID::SameAsT >::ID << endl; 1171 | } 1172 | ``` 1173 | 1174 | 别急着运行，你先猜。 1175 | 1176 | ------------------------- 这里是给勤于思考的码猴的分割线 ------------------------------- 1177 | 1178 | OK，猜出来了吗，T是`float`。为什么呢？因为你用 `float *` 匹配了 `T *`，所以 `T` 就对应 `float` 了。没想清楚的自己再多体会一下。 1179 | 1180 | 嗯，所以实际上，我们可以利用这个特性做一件事情：把指针类型的那个指针给“干掉”： 1181 | 1182 | ``` C++ 1183 | template 1184 | class RemovePointer 1185 | { 1186 | // 啥都不干，你要放一个不是指针的类型进来，我就让你死的难看。 1187 | }; 1188 | 1189 | template 1190 | class RemovePointer // 祖传牛皮藓，专治各类指针 1191 | { 1192 | public: 1193 | typedef T Result; 1194 | }; 1195 | 1196 | void Foo() 1197 | { 1198 | RemovePointer::Result x = 5.0f; // 喏，用RemovePointer后，那个Result就是把float*的指针处理掉以后的结果：float啦。 1199 | std::cout << x << std::endl; 1200 | } 1201 | ``` 1202 | 1203 | OK，如果这个时候，我需要给 `int*` 提供一个更加特殊的特化，那么我还得都多提供一个： 1204 | 1205 | ``` C++ 1206 | // ... 1207 | // TypeToID 的其他代码，略过不表 1208 | // ... 1209 | 1210 | template // 嗯，需要一个T 1211 | class TypeToID // 我要对所有的指针类型特化，所以这里就写T* 1212 | { 1213 | public: 1214 | typedef T SameAsT; 1215 | static int const ID = 0x80000000; // 用最高位表示它是一个指针 1216 | }; 1217 | 1218 | template <> // 嗯，int* 已经是个具体的不能再具体的类型了，所以模板不需要额外的类型参数了 1219 | class TypeToID // 嗯，对int*的特化。在这里呢，要把int*整体看作一个类型。 1220 | { 1221 | public: 1222 | static int const ID = 0x12345678; // 给一个缺心眼的ID 1223 | }; 1224 | 1225 | void PrintID() 1226 | { 1227 | cout << "ID of int*: " << TypeToID::ID << endl; 1228 | } 1229 | ``` 1230 | 1231 | 嗯，这个时候它会输出0x12345678的十进制（大概？）。 1232 | 可能会有较真的人说，`int*` 去匹配 `T` 或者 `T*`，也是合法的。就和你说22岁以上能结婚，那24岁当然也能结婚一样。 1233 | 那为什么 `int*` 就会找 `int*`，`float *`因为没有合适的特化就去找 `T*`，更一般的就去找 `T` 呢？废话，有专门为你准备的东西的不用，人干事？这就是直觉。 1234 | 但是呢，直觉对付更加复杂的问题还是没用的（也不是没用，主要是你没这个直觉了）。我们要把这个直觉，转换成合理的规则——即模板的匹配规则。 1235 | 当然，这个匹配规则是对复杂问题用的，所以我们会到实在一眼看不出来的时候才会动用它。一开始我们只要把握：模板是从最特殊到最一般形式进行匹配就可以了。 1236 | 1237 | ###2.3 即用即推导 1238 | 1239 | ####2.3.1 视若无睹的语法错误 1240 | 这一节我们将讲述模板一个非常重要的行为特点：那就是什么时候编译器会对模板进行推导，推导到什么程度。 1241 | 1242 | 这一知识，对于理解模板的编译期行为、以及修正模板编译错误都非常重要。 1243 | 1244 | 我们先来看一个例子： 1245 | 1246 | ``` C++ 1247 | template struct X {}; 1248 | 1249 | template struct Y 1250 | { 1251 | typedef X ReboundType; // 类型定义1 1252 | typedef typename X::MemberType MemberType; // 类型定义2 1253 | typedef UnknownType MemberType3; // 类型定义3 1254 | 1255 | void foo() 1256 | { 1257 | X instance0; 1258 | typename X::MemberType instance1; 1259 | WTF instance2 1260 | 大王叫我来巡山 - + & 1261 | } 1262 | }; 1263 | ``` 1264 | 1265 | 把这段代码编译一下，类型定义3出错，其它的都没问题。不过到这里你应该会有几个问题： 1266 | 1267 | 1. 不是`struct X`的定义是空的吗？为什么在`struct Y`内的类型定义2使用了 `X::MemberType` 编译器没有报错？ 1268 | 2. 类型定义2中的`typename`是什么鬼？为什么类型定义1就不需要？ 1269 | 3. 为什么类型定义3会导致编译错误？ 1270 | 4. 为什么`void foo()`在MSVC下什么错误都没报？ 1271 | 1272 | 这时我们就需要请出C++11标准 —— 中的某些概念了。这是我们到目前为止第一次参阅标准。我希望能尽量减少直接参阅标准的次数，因此即便是极为复杂的模板匹配决议我都暂时没有引入标准中的描述。 1273 | 然而，Template引入的“双阶段名称查找（Two phase name lookup）”堪称是C++中最黑暗的角落 —— 这是LLVM的团队自己在博客上说的 —— 因此在这里，我们还是有必要去了解标准中是如何规定的。 1274 | 1275 | ####2.3.2 名称查找：I am who I am 1276 | 在C++标准中对于“名称查找（name lookup）”这个高大上的名词的诠释，主要集中出现在三处。第一处是3.4节，标题名就叫“Name Lookup”；第二处在10.2节，继承关系中的名称查找；第三处在14.6节，名称解析（name resolution）。 1277 | 1278 | 名称查找/名称解析，是编译器的基石。对编译原理稍有了解的人，都知道“符号表”的存在即重要意义。考虑一段最基本的C代码： 1279 | ``` C 1280 | int a = 0; 1281 | int b; 1282 | b = (a + 1) * 2; 1283 | printf("Result: %d", b); 1284 | ``` 1285 | 在这段代码中，所有出现的符号可以分为以下几类： 1286 | 1287 | * `int`：类型标识符，代表整型； 1288 | * `a`,`b`,`printf`：变量名或函数名； 1289 | * `=`,`+`,`*`：运算符； 1290 | * `,`,`;`,`(`,`)`：分隔符； 1291 | 1292 | 那么，编译器怎么知道`int`就是整数类型，`b=(a+1)*2`中的`a`和`b`就是整型变量呢？这就是名称查找/名称解析的作用：它告诉编译器，这个标识符（identifer）是在哪里被声明或定义的，它究竟是什么意思。 1293 | 1294 | 也正因为这个机制非常基础，所以它才会面临各种可能的情况，编译器也要想尽办法让它在大部分场合都表现的合理。比如我们常见的作用域规则，就是为了对付名称在不同代码块中传播、并且遇到重名要如何处理的问题。下面是一个最简单的、大家在语言入门过程中都会碰到的一个例子： 1295 | ``` C++ 1296 | int a = 0; 1297 | void f() { 1298 | int a = 0; 1299 | a += 2; 1300 | printf("Inside : %d\n", a); 1301 | } 1302 | void g() { 1303 | printf("Outside : %d\n", a); 1304 | } 1305 | int main() { 1306 | f(); 1307 | g(); 1308 | } 1309 | 1310 | /* ------------ Console Output ----------------- 1311 | Inside : 2 1312 | Outside : 0 1313 | --------------- Console Output -------------- */ 1314 | ``` 1315 | 1316 | 我想大家尽管不能处理所有名称查找中所遇到的问题，但是对一些常见的名称查找规则也有了充分的经验，可以解决一些常见的问题。 1317 | 但是模板的引入，使得名称查找这一本来就不简单的基本问题变得更加复杂了。 1318 | 考虑下面这个例子： 1319 | ``` C++ 1320 | struct A { int a; }; 1321 | struct AB { int a, b; }; 1322 | struct C { int c; }; 1323 | 1324 | template foo(T& v0, C& v1){ 1325 | v0.a = 1; 1326 | v1.a = 2; 1327 | v1.c = 3; 1328 | } 1329 | ``` 1330 | 简单分析上述代码很容易得到以下结论： 1331 | 1332 | 1. 函数`foo`中的变量`v1`已经确定是`struct C`的实例，所以，`v1.a = 2;`会导致编译错误，`v1.c = 3;`是正确的代码； 1333 | 2. 对于变量`v0`来说，这个问题就变得很微妙。如果`v0`是`struct A`或者`struct AB`的实例，那么`foo`中的语句`v0.a = 1;`就是正确的。如果是`struct C`，那么这段代码就是错误的。 1334 | 1335 | 因此在模板定义的地方进行语义分析，并不能**完全**得出代码是正确或者错误的结论，只有到了实例化阶段，确定了模版参数的类型后，才知道这段代码正确与否。令人高兴的是，在这一问题上，我们和C++标准委员会的见地一致，说明我们的C++水平已经和Herb Sutter不分伯仲了。既然我们和Herb Sutter水平差不多，那凭什么人家就吃香喝辣？下面我们来选几条标准看看服不服： 1336 | 1337 | > **14.6 名称解析（Name resolution）** 1338 | 1339 | > **1)** 模板定义中能够出现以下三类名称： 1340 | 1341 | > * 模板名称、或模板实现中所定义的名称； 1342 | > * 和模板参数有关的名称； 1343 | > * 模板定义所在的定义域内能看到的名称。 1344 | 1345 | > … 1346 | 1347 | > **9)** … 如果名字查找和模板参数有关，那么查找会延期到模板参数全都确定的时候。 … 1348 | 1349 | > **10)** 如果（模板定义内出现的）名字和模板参数无关，那么在模板定义处，就应该找得到这个名字的声明。… 1350 | 1351 | > **14.6.2 依赖性名称（Dependent names）** 1352 | 1353 | > **1)** …（模板定义中的）表达式和类型可能会依赖于模板参数，并且模板参数会影响到名称查找的作用域 … 如果表达式中有操作数依赖于模板参数，那么整个表达式都依赖于模板参数，名称查找延期到**模板实例化时**进行。并且定义时和实例化时的上下文都会参与名称查找。（依赖性）表达式可以分为类型依赖（类型指模板参数的类型）或值依赖。 1354 | 1355 | > **14.6.2.2 类型依赖的表达式** 1356 | 1357 | > **2)** 如果成员函数所属的类型是和模板参数有关的，那么这个成员函数中的`this`就认为是类型依赖的。 1358 | 1359 | > **14.6.3 非依赖性名称（Non-dependent names）** 1360 | 1361 | > **1)** 非依赖性名称在**模板定义**时使用通常的名称查找规则进行名称查找。 1362 | 1363 | [Working Draft: Standard of Programming Language C++, N3337][1] 1364 | 1365 | 知道差距在哪了吗：人家会说黑话。什么时候咱们也会说黑话了，就是标准委员会成员了，反正懂得也不比他们少。不过黑话确实不太好懂 —— 怪我翻译不好的人，自己看原文，再说好懂了人家还靠什么吃饭 —— 我们来举一个例子： 1366 | 1367 | ```C++ 1368 | int a; 1369 | struct B { int v; } 1370 | template struct X { 1371 | B b; // B 是第三类名字，b 是第二类 1372 | T t; // T 是第二类 1373 | X* anthor; // X 这里代指 X，第一类 1374 | typedef int Y; // int 是第三类 1375 | Y y; // Y 是第一类 1376 | C c; // C 什么都不是，编译错误。 1377 | void foo() { 1378 | b.v += y; // b 是第一类，非依赖性名称 1379 | b.v *= T::s_mem; // T::s_mem 是第二类 1380 | // s_mem的作用域由T决定 1381 | // 依赖性名称，类型依赖 1382 | } 1383 | }; 1384 | ``` 1385 | 1386 | 所以，按照标准的意思，名称查找会在模板定义和实例化时各做一次，分别处理非依赖性名称和依赖性名称的查找。这就是“两阶段名称查找”这一名词的由来。只不过这个术语我也不知道是谁发明的，它并没有出现的标准上，但是频繁出现在StackOverflow和Blog上。 1387 | 1388 | 接下来，我们就来解决2.3.1节中留下的几个问题。 1389 | 1390 | 先看第四个问题。为什么MSVC中，模板函数的定义内不管填什么编译器都不报错？因为MSVC在分析模板定义时没有做任何事情。至于为啥连“大王叫我来巡山”都能过得去，这是C++语法/语义分析的特殊性导致的。 1391 | C++是个非常复杂的语言，以至于它的编译器，不可能通过词法-语法-语义多趟分析清晰分割。因为它的语义将会直接干扰到语法： 1392 | 1393 | ```C++ 1394 | void foo(){ 1395 | A b; 1396 | } 1397 | ``` 1398 | 在这段简短的代码中，就包含了两个歧义的可能，一是`A`是模板，于是`A`是一个实例化的类型，`b`是变量，另外一种就是关系表达式，`((A < T) > b)`。 1399 | 1400 | 甚至词法分析也会受到语义的干扰，C++11中才明确被修正的`vector>`，就因为`>>`被误解为右移或流操作符，而导致某些编译器上的错误。因此，在语义没有确定之前，连语法都没有分析的价值。 1401 | 1402 | 大约是基于如此考量，为了偷懒，MSVC将包括所有的语法/语义分析工作都挪到了第二个Phase，于是乎连带着语法分析都送进了第二个阶段。符合标准么？显然不符合。 1403 | 1404 | 但是这里值得一提的是，MSVC的做法和标准相比，虽然投机取巧，但并非有弊无利。我们来先说一说坏处。考虑以下例子： 1405 | ```C++ 1406 | // ----------- X.h ------------ 1407 | 1408 | template struct X { 1409 | // 实现代码 1410 | }; 1411 | 1412 | // ---------- X.cpp ----------- 1413 | 1414 | // ... 一些代码 ... 1415 | X xi; 1416 | // ... 一些代码 ... 1417 | X xf; 1418 | // ... 一些代码 ... 1419 | ``` 1420 | 此时如果X中有一些与模板参数无关的错误，如果名称查找/语义分析在两个阶段完成，那么这些错误会很早、且唯一的被提示出来；但是如果一切都在实例化时处理，那么可能会导致不同的实例化过程提示同样的错误。而模板在运用过程中，往往会产生很多实例，此时便会大量报告同样的错误。 1421 | 1422 | 当然，MSVC并不会真的这么做。根据推测，最终他们是合并了相同的错误。因为即便对于模板参数相关的编译错误，也只能看到最后一次实例化的错误信息： 1423 | ``` 1424 | template struct X {}; 1425 | 1426 | template struct Y 1427 | { 1428 | typedef X ReboundType; // 类型定义1 1429 | void foo() 1430 | { 1431 | X instance0; 1432 | X::MemberType instance1; 1433 | WTF instance2 1434 | } 1435 | }; 1436 | 1437 | void poo(){ 1438 | X::foo(); 1439 | X::foo(); 1440 | } 1441 | ``` 1442 | 1443 | MSVC下和模板相关的错误只有一个： 1444 | ``` 1445 | error C2039: 'MemberType': is not a member of 'X' 1446 | with 1447 | [ 1448 | T=float 1449 | ] 1450 | ``` 1451 | 然后是一些语法错误，比如`MemberType`不是一个合法的标识符之类的。这样甚至你会误以为`int`情况下模板的实力化是正确的。虽然在有了经验之后会发现这个问题挺荒唐的，但是仍然会让新手有困惑。 1452 | 1453 | 相比之下，更加遵守标准的Clang在错误提示上就要清晰许多： 1454 | 1455 | ``` 1456 | error: unknown type name 'WTF' 1457 | WTF instance2 1458 | ^ 1459 | error: expected ';' at end of declaration 1460 | WTF instance2 1461 | ^ 1462 | ; 1463 | error: no type named 'MemberType' in 'X' 1464 | typename X::MemberType instance1; 1465 | ~~~~~~~~~~~~~~~^~~~~~~~~~ 1466 | note: in instantiation of member function 'Y::foo' requested here 1467 | Y::foo(); 1468 | ^ 1469 | error: no type named 'MemberType' in 'X' 1470 | typename X::MemberType instance1; 1471 | ~~~~~~~~~~~~~~~^~~~~~~~~~ 1472 | note: in instantiation of member function 'Y::foo' requested here 1473 | Y::foo(); 1474 | ^ 1475 | 4 errors generated. 1476 | ``` 1477 | 可以看到，Clang的提示和标准更加契合。它很好地区分了模板在定义和实例化时分别产生的错误。 1478 | 1479 | 另一个缺点也与之类似。因为没有足够的检查，如果你写的模板没有被实例化，那么很可能缺陷会一直存在于代码之中。特别是模板代码多在头文件。虽然不如接口那么重要，但也是属于被公开的部分，别人很可能会踩到坑上。缺陷一旦传播开修复起来就没那么容易了。 1480 | 1481 | 但是正如我前面所述，这个违背了标准的特性，并不是一无是处。首先，它可以完美的兼容标准。符合标准的、能够被正确编译的代码，一定能够被MSVC的方案所兼容。其次，它带来了一个非常有趣的特性，看下面这个例子： 1482 | 1483 | ```C++ 1484 | struct A; 1485 | template struct X { 1486 | void foo(T v) { 1487 | A a; 1488 | a.v = v; 1489 | } 1490 | }; 1491 | 1492 | struct A { int v; }; 1493 | 1494 | void main() { 1495 | X x; 1496 | x.foo(5); 1497 | } 1498 | ``` 1499 | 这个例子在Clang中是错误的，因为： 1500 | ``` 1501 | error: variable has incomplete type 'A' 1502 | A a; 1503 | ^ 1504 | note: forward declaration of 'A' 1505 | struct A; 1506 | ^ 1507 | 1 error generated. 1508 | ``` 1509 | 1510 | 符合标准的写法需要将模板类的定义，和模板函数的定义分离开： 1511 | 1512 | ```C++ 1513 | struct A; 1514 | template struct X { 1515 | void foo(T v) { 1516 | A a; 1517 | a.v = v; 1518 | } 1519 | }; 1520 | 1521 | struct A { int v; }; 1522 | 1523 | template void X::foo(T v) { 1524 | A a; 1525 | a.v = v; 1526 | } 1527 | 1528 | void main() { 1529 | X x; 1530 | x.foo(5); 1531 | } 1532 | ``` 1533 | 1534 | 但是其实我们知道，`foo`要到实例化之后，才需要真正的做语义分析。在MSVC上，因为函数实现就是到模板实例化时才处理的，所以这个例子是完全正常工作的。 1535 | 1536 | 在实际应用中，我们经常既希望把模板类成员函数的声明和实现放到一起，因为模板函数看不到实现也很难调用；又希望一般类型可以声明定义分离，把类型定义隐藏到源文件中，以完成声明实现分离。 1537 | 1538 | 此时如果编译器是符合标准的，我们只能将模板头文件拆分成``和``两个部分，并按照顺序引用两个文件。但是在MSVC中就可以直接将模板函数的实现，和一般类型的声明放在一起，反而更加简单清晰。 1539 | 1540 | 扩展阅读： [The Dreaded Two-Phase Name Lookup][2] 1541 | ###2.4 函数模板的重载、参数匹配、特化与部分特化 1542 | ###2. 技巧单元：模板与继承 1543 | 1544 | 1545 | ## 3 拿起特化的武器，去写程序吧！ 1546 | ###3.1 利用模板特化规则实现If-Then-Else与Switch-Case 1547 | ###3.2 特化可以有多个选择：替换失败并不是一个错误，只是一种可能 1548 | ###3.3 技巧单元：获得类型的属性——类型萃取（Type Traits） 1549 | 1550 | ## 4 用模板写程序吧！骚年！ 1551 | ###4.1 模板上的递归 1552 | ###4.2 将循环变成递归，将分支变成递归，将一切变成递归 1553 | ###4.3 实战单元：元编程的Fibonacci数列 1554 | ###4.4 技巧单元：typename与template的另一种用法 1555 | ###4.5 实战单元：撰写你自己的元编程“函数”库 1556 | ###4.6 实战单元：实现元编程上的数据结构——以Vector为例 1557 | 1558 | ## 5 关于模板，你还需要知道的其它常识 1559 | ###5.1 类中类：灵活的模板定义 1560 | ###5.2 Template-Template Class 1561 | ###5.3 技巧单元：高阶函数——从函数到函数的组合 1562 | ###5.4 实战单元：STL中的Allocator Rebinder 1563 | ###5.5 像看堆栈一样的看出错信息 1564 | ###5.6 模板的症结：易于实现，难于完美 1565 | 1566 | alexandrescu 关于 min max 的讨论：《再谈Min和Max》 1567 | 1568 | ## 6 C++11的新特性 1569 | ###6.1 变参模板 1570 | ###6.2 Lambda与模板程序 1571 | 1572 | ## 7 模板的威力：从foreach, transform到Linq 1573 | ###7.1 Foreach与Transform 1574 | ###7.2 Reactor风格的编程 1575 | ###7.3 Reactor与Linq 1576 | ###7.4 Linq的C++实践 1577 | ###7.5 更高更快更强：从Linq到FP 1578 | 1579 | ## 8 结语：讨论有益，争端无用 1580 | 1581 | 1582 | [1]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3337.pdf 1583 | [2]: http://blog.llvm.org/2009/12/dreaded-two-phase-name-lookup.html -------------------------------------------------------------------------------- /stdafx.cpp: -------------------------------------------------------------------------------- 1 | // stdafx.cpp : source file that includes just the standard includes 2 | // CppTemplateTutorial.pch will be the pre-compiled header 3 | // stdafx.obj will contain the pre-compiled type information 4 | 5 | #include "stdafx.h" 6 | 7 | // TODO: reference any additional headers you need in STDAFX.H 8 | // and not in this file 9 | -------------------------------------------------------------------------------- /stdafx.h: -------------------------------------------------------------------------------- 1 | // stdafx.h : include file for standard system include files, 2 | // or project specific include files that are used frequently, but 3 | // are changed infrequently 4 | // 5 | 6 | #pragma once 7 | 8 | #include "targetver.h" 9 | 10 | #include 11 | #include 12 | 13 | 14 | 15 | // TODO: reference additional headers your program requires here 16 | -------------------------------------------------------------------------------- /targetver.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // Including SDKDDKVer.h defines the highest available Windows platform. 4 | 5 | // If you wish to build your application for a previous Windows platform, include WinSDKVer.h and 6 | // set the _WIN32_WINNT macro to the platform you wish to support before including SDKDDKVer.h. 7 | 8 | #include 9 | --------------------------------------------------------------------------------