好可怕的template

stonemason

高人们解析一下，呵呵。这个chess engine源码g下就有，非常有名：

1. /*
   
2.   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   
3.   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
   
4.   Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
   
5. 
   
6.   Stockfish is free software: you can redistribute it and/or modify
   
7.   it under the terms of the GNU General Public License as published by
   
8.   the Free Software Foundation, either version 3 of the License, or
   
9.   (at your option) any later version.
   
10. 
    
11.   Stockfish is distributed in the hope that it will be useful,
    
12.   but WITHOUT ANY WARRANTY; without even the implied warranty of
    
13.   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    
14.   GNU General Public License for more details.
    
15. 
    
16.   You should have received a copy of the GNU General Public License
    
17.   along with this program.  If not, see <http://www.gnu.org/licenses/>.
    
18. */
    
19. 
    
20. #if !defined(ENDGAME_H_INCLUDED)
    
21. #define ENDGAME_H_INCLUDED
    
22. 
    
23. #include <map>
    
24. #include <string>
    
25. 
    
26. #include "position.h"
    
27. #include "types.h"
    
28. 
    
29. 
    
30. /// EndgameType lists all supported endgames
    
31. 
    
32. enum EndgameType {
    
33. 
    
34.   // Evaluation functions
    
35. 
    
36.   KXK,   // Generic "mate lone king" eval
    
37.   KBNK,  // KBN vs K
    
38.   KPK,   // KP vs K
    
39.   KRKP,  // KR vs KP
    
40.   KRKB,  // KR vs KB
    
41.   KRKN,  // KR vs KN
    
42.   KQKR,  // KQ vs KR
    
43.   KBBKN, // KBB vs KN
    
44.   KNNK,  // KNN vs K
    
45.   KmmKm, // K and two minors vs K and one or two minors
    
46. 
    
47. 
    
48.   // Scaling functions
    
49.   SCALE_FUNS,
    
50. 
    
51.   KBPsK,   // KB+pawns vs K
    
52.   KQKRPs,  // KQ vs KR+pawns
    
53.   KRPKR,   // KRP vs KR
    
54.   KRPPKRP, // KRPP vs KRP
    
55.   KPsK,    // King and pawns vs king
    
56.   KBPKB,   // KBP vs KB
    
57.   KBPPKB,  // KBPP vs KB
    
58.   KBPKN,   // KBP vs KN
    
59.   KNPK,    // KNP vs K
    
60.   KPKP     // KP vs KP
    
61. };
    
62. 
    
63. 
    
64. /// Some magic to detect family type of endgame from its enum value
    
65. 
    
66. template<bool> struct bool_to_type { typedef Value type; };
    
67. template<> struct bool_to_type<true> { typedef ScaleFactor type; };
    
68. template<EndgameType E> struct eg_family : public bool_to_type<(E > SCALE_FUNS)> {};
    
69. 
    
70. 
    
71. /// Base and derived templates for endgame evaluation and scaling functions
    
72. 
    
73. template<typename T>
    
74. struct EndgameBase {
    
75. 
    
76.   virtual ~EndgameBase() {}
    
77.   virtual Color color() const = 0;
    
78.   virtual T operator()(const Position&) const = 0;
    
79. };
    
80. 
    
81. 
    
82. template<EndgameType E, typename T = typename eg_family<E>::type>
    
83. struct Endgame : public EndgameBase<T> {
    
84. 
    
85.   explicit Endgame(Color c) : strongerSide(c), weakerSide(~c) {}
    
86.   Color color() const { return strongerSide; }
    
87.   T operator()(const Position&) const;
    
88. 
    
89. private:
    
90.   Color strongerSide, weakerSide;
    
91. };
    
92. 
    
93. 
    
94. /// Endgames class stores in two std::map the pointers to endgame evaluation
    
95. /// and scaling base objects. Then we use polymorphism to invoke the actual
    
96. /// endgame function calling its operator() method that is virtual.
    
97. 
    
98. class Endgames {
    
99. 
    
100.   typedef std::map<Key, EndgameBase<Value>*> M1;
     
101.   typedef std::map<Key, EndgameBase<ScaleFactor>*> M2;
     
102. 
     
103.   M1 m1;
     
104.   M2 m2;
     
105. 
     
106.   M1& map(Value*) { return m1; }
     
107.   M2& map(ScaleFactor*) { return m2; }
     
108. 
     
109.   template<EndgameType E> void add(const std::string& code);
     
110. 
     
111. public:
     
112.   Endgames();
     
113.   ~Endgames();
     
114. 
     
115.   template<typename T> EndgameBase<T>* get(Key key) {
     
116.     return map((T*)0).count(key) ? map((T*)0)[key] : NULL;
     
117.   }
     
118. };
     
119. 
     
120. #endif // !defined(ENDGAME_H_INCLUDED)
     

复制代码

hgrany

boost::auto的扩展再应用.