loki库是C++模板大牛Andrei写的， 里面大量运用模板的特性， 而tc_loki.h借用了loki库的部分代码， 形成了一个基本的文件tc_loki.h， 来看看：
1 #ifndef __TC_TYPETRAITS_H 2 #define __TC_TYPETRAITS_H 3 4 #include <memory> 5 6 namespace tars 7 { 8 ///////////////////////////////////////////////// 9 // 说明: loki 10 ///////////////////////////////////////////////// 11 12 namespace TL 13 { 14 //只声明, 不定义的类, 作为TYPELIST的末端类型 15 class NullType; 16 17 //空类型 18 struct EmptyType { }; 19 20 /** 21 * 数值到类型的映射 22 */ 23 template<int v> 24 struct Int2Type 25 { 26 enum { value = v }; 27 }; 28 29 /** 30 * 类型到类型的映射 31 */ 32 template<typename T> 33 struct Type2Type 34 { 35 typedef T OriginalType; 36 }; 37 38 /////////////////////////////////////////////////////////////////////////// 39 // 以下是TypeList的定义(目前只支持10个参数) 40 /** 41 * 定义类型链表 42 */ 43 template<typename Head, typename Tail> 44 struct TypeList 45 { 46 typedef Head H; 47 typedef Tail T; 48 }; 49 50 #define TYPELIST_1(T1) TypeList<T1, TL::NullType> 51 #define TYPELIST_2(T1, T2) TypeList<T1, TL::TYPELIST_1(T2)> 52 #define TYPELIST_3(T1, T2, T3) TypeList<T1, TL::TYPELIST_2(T2, T3)> 53 #define TYPELIST_4(T1, T2, T3, T4) TypeList<T1, TL::TYPELIST_3(T2, T3, T4)> 54 #define TYPELIST_5(T1, T2, T3, T4, T5) TypeList<T1, TL::TYPELIST_4(T2, T3, T4, T5)> 55 #define TYPELIST_6(T1, T2, T3, T4, T5, T6) TypeList<T1, TL::TYPELIST_5(T2, T3, T4, T5, T6)> 56 #define TYPELIST_7(T1, T2, T3, T4, T5, T6, T7) TypeList<T1, TL::TYPELIST_6(T2, T3, T4, T5, T6, T7)> 57 #define TYPELIST_8(T1, T2, T3, T4, T5, T6, T7, T8) TypeList<T1, TL::TYPELIST_7(T2, T3, T4, T5, T6, T7, T8)> 58 #define TYPELIST_9(T1, T2, T3, T4, T5, T6, T7, T8, T9) TypeList<T1, TL::TYPELIST_8(T2, T3, T4, T5, T6, T7, T8, T9)> 59 #define TYPELIST_10(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) TypeList<T1, TL::TYPELIST_9(T2, T3, T4, T5, T6, T7, T8, T9, T10)> 60 #define TYPELIST_11(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) TypeList<T1, TL::TYPELIST_10(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> 61 #define TYPELIST_12(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) TypeList<T1, TL::TYPELIST_11(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> 62 #define TYPELIST_13(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) TypeList<T1, TL::TYPELIST_12(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> 63 #define TYPELIST_14(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) TypeList<T1, TL::TYPELIST_13(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> 64 #define TYPELIST_15(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) TypeList<T1, TL::TYPELIST_14(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> 65 #define TYPELIST_16(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) TypeList<T1, TL::TYPELIST_15(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)> 66 #define TYPELIST_17(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) TypeList<T1, TL::TYPELIST_16(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)> 67 #define TYPELIST_18(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) TypeList<T1, TL::TYPELIST_17(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)> 68 #define TYPELIST_19(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) TypeList<T1, TL::TYPELIST_18(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)> 69 #define TYPELIST_20(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) TypeList<T1, TL::TYPELIST_19(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)> 70 71 72 ////////////////////////////////////////////////////////////////////////////// 73 // 以下定义TypeList的编译期的操作函数(通过偏特化实现) 74 /** 75 * Length: 取TypeList的长度 76 */ 77 template<class TList> struct Length; 78 template<> struct Length<NullType> 79 { 80 enum { value = 0 }; 81 }; 82 template<class Head, class Tail> struct Length<TypeList<Head, Tail> > 83 { 84 enum { value = 1 + Length<Tail>::value }; 85 }; 86 87 /** 88 * TypeAt, 取链表在i位置上的类型 89 */ 90 template<class TList, unsigned int i> struct TypeAt; 91 template<class Head, class Tail> struct TypeAt<TypeList<Head, Tail>, 0> 92 { 93 typedef Head Result; 94 }; 95 template<class Head, class Tail, unsigned int i> struct TypeAt<TypeList<Head, Tail>, i> 96 { 97 typedef typename TypeAt<Tail, i-1>::Result Result; 98 }; 99 100 /** 101 * TypeAt, 取链表在i位置上的类型, i超出了返回, 则返回DefaultType 102 */ 103 template<class TList, unsigned int index, typename DefaultType = NullType> struct TypeAtNonStrict 104 { 105 typedef DefaultType Result; 106 }; 107 template <class Head, class Tail, typename DefaultType> struct TypeAtNonStrict<TypeList<Head, Tail>, 0, DefaultType> 108 { 109 typedef Head Result; 110 }; 111 template <class Head, class Tail, unsigned int i, typename DefaultType> struct TypeAtNonStrict<TypeList<Head, Tail>, i, DefaultType> 112 { 113 typedef typename TypeAtNonStrict<Tail, i - 1, DefaultType>::Result Result; 114 }; 115 116 /** 117 * 取链表上类型为T的序号, 没有则返回-1 118 */ 119 template<class TList, class T> struct IndexOf; 120 template<class T> struct IndexOf<NullType, T> 121 { 122 enum { value = -1 }; 123 }; 124 template<class Tail, class T> struct IndexOf<TypeList<T,Tail>, T> 125 { 126 enum { value = 0 }; 127 }; 128 template<class Head, class Tail, class T> struct IndexOf<TypeList<Head, Tail>, T> 129 { 130 private: 131 enum { temp = IndexOf<Tail, T>::value }; 132 public: 133 enum { value = temp == -1 ? -1 : 1 + temp }; 134 }; 135 136 /** 137 * Append, 添加到链表尾部 138 */ 139 template<class TList, class T> struct Append; 140 template<> struct Append<NullType, NullType> 141 { 142 typedef NullType Result; 143 }; 144 template<class T> struct Append<NullType,T> 145 { 146 typedef TYPELIST_1(T) Result; 147 }; 148 template<class Head, class Tail> struct Append<NullType, TypeList<Head, Tail> > 149 { 150 typedef TypeList<Head, Tail> Result; 151 }; 152 template<class Head, class Tail, class T> struct Append<TypeList<Head, Tail>, T> 153 { 154 typedef TypeList<Head, typename Append<Tail, T>::Result> Result; 155 }; 156 157 /** 158 * Erase 删除 159 */ 160 template<class TList, class T> struct Erase; 161 template<class T> struct Erase<NullType, T> 162 { 163 typedef NullType Result; 164 }; 165 template<class T, class Tail> struct Erase<TypeList<T, Tail>, T> 166 { 167 typedef Tail Result; 168 }; 169 template<class Head, class Tail, class T> struct Erase<TypeList<Head, Tail>, T> 170 { 171 typedef TypeList<Head, typename Erase<Tail, T>::Result> Result; 172 }; 173 174 /** 175 * EraseAll 删除 176 */ 177 template<class TList, class T> struct EraseAll; 178 template<class T> struct EraseAll<NullType, T> 179 { 180 typedef NullType Result; 181 }; 182 template<class T, class Tail> struct EraseAll<TypeList<T, Tail>, T> 183 { 184 typedef typename EraseAll<Tail, T>::Result Result; 185 }; 186 template<class Head, class Tail, class T> struct EraseAll<TypeList<Head, Tail>, T> 187 { 188 typedef TypeList<Head, typename EraseAll<Tail, T>::Result> Result; 189 }; 190 191 /** 192 * 生成TypeList类型 193 */ 194 template<class T1=NullType, class T2=NullType, class T3=NullType, class T4=NullType, class T5=NullType, 195 class T6=NullType, class T7=NullType, class T8=NullType, class T9=NullType, class T10=NullType, 196 class T11=NullType, class T12=NullType, class T13=NullType, class T14=NullType, class T15=NullType, 197 class T16=NullType, class T17=NullType, class T18=NullType, class T19=NullType, class T20=NullType> 198 struct TLMaker 199 { 200 private: 201 typedef TYPELIST_20(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, 202 T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) TmpList; 203 public: 204 typedef typename EraseAll<TmpList, NullType>::Result Result; 205 }; 206 207 ///////////////////////////////////////////////////////////////////////////////////// 208 //判断类型T是否可以转换成类型U(参考了wbl库, 直接采用loki, 编译时会有警告 209 //关键:如果能够转换, 则接收U的函数, 也能够接收T 210 template<class T, class U> 211 class Conversion 212 { 213 protected: 214 typedef char YES; 215 struct NO {char dummy[2];}; 216 struct any_conversion 217 { 218 template <typename P> any_conversion(const volatile P&); 219 template <typename P> any_conversion(P&); 220 }; 221 222 template <typename P> struct conversion_checker 223 { 224 static NO _m_check(any_conversion ...); 225 static YES _m_check(P, int); 226 }; 227 228 static T _m_from; 229 public: 230 enum 231 { 232 //是否可以转换(如果Test(makeT())匹配到了static Small Test(U), 则可以转换) 233 exists = (sizeof(conversion_checker<U>::_m_check(_m_from, 0)) == sizeof(YES)), 234 //是否可以双向转换 235 exists2Way = exists && Conversion<U, T>::exists, 236 //是否相同类型 237 sameType = false 238 }; 239 }; 240 241 //偏特化来确定sameType 242 template<class T> 243 class Conversion<T, T> 244 { 245 public: 246 enum 247 { 248 exists = true, 249 exists2Way = true, 250 sameType = true 251 }; 252 }; 253 254 //判断两个类是否可以继承 255 //关键:子类指针可以转换成父类指针, 且不是void*类型 256 //相同类型, SUPERSUBCLASS判断为true 257 #define SUPERSUBCLASS(T, U) (TL::Conversion<const U*, const T*>::exists && !TL::Conversion<const T*, const void*>::sameType) 258 //相同类型, SUPERSUBCLASS_STRICT判断为false 259 #define SUPERSUBCLASS_STRICT(T, U) (SUPERSUBCLASS(T, U) && !TL::Conversion<const T, const U>::sameType) 260 261 /////////////////////////////////////////////////////////////////////////////////////////////// 262 // 类型选择器 263 template<bool flag, typename U, typename V> 264 struct TypeSelect 265 { 266 typedef U Result; 267 }; 268 269 template<typename U, typename V> 270 struct TypeSelect<false, U, V> 271 { 272 typedef V Result; 273 }; 274 275 /////////////////////////////////////////////////////////////////////////////////////// 276 /** 277 * 类型萃取器, copy至Loki库 278 */ 279 template<typename T> 280 class TypeTraits 281 { 282 private: 283 284 /////////////////////////////////////////////////////// 285 //提取引用的原始类型(即去掉引用类型) 286 template<class U> 287 struct ReferenceTraits 288 { 289 enum { result = false }; 290 typedef U Result; 291 }; 292 293 template<class U> 294 struct ReferenceTraits<U&> 295 { 296 enum { result = true }; 297 typedef U Result; 298 }; 299 300 /////////////////////////////////////////////////////// 301 //指针类型 302 template<class U> 303 struct PointerTraits 304 { 305 enum { result = false }; 306 typedef TL::NullType Result; 307 }; 308 309 template<class U> 310 struct PointerTraits<U*> 311 { 312 enum { result = true }; 313 typedef U Result; 314 }; 315 316 template<class U> 317 struct PointerTraits<U*&> 318 { 319 enum { result = true }; 320 typedef U Result; 321 }; 322 323 /////////////////////////////////////////////////////// 324 //成员函数指针, gcc下面支持有问题, 屏蔽之 325 template<typename U> 326 struct PointerToMemberTraits 327 { 328 enum { result = false }; 329 }; 330 331 template<class U, class V> 332 struct PointerToMemberTraits<U V::*> 333 { 334 enum { result = true }; 335 }; 336 337 template<class U, class V> 338 struct PointerToMemberTraits<U V::*&> 339 { 340 enum { result = true }; 341 }; 342 343 /////////////////////////////////////////////////////// 344 // const 345 template<typename U> 346 struct UnConstTraits 347 { 348 enum { result = false }; 349 typedef U Result; 350 }; 351 template<typename U> 352 struct UnConstTraits<const U> 353 { 354 enum { result = true }; 355 typedef U Result; 356 }; 357 template<typename U> 358 struct UnConstTraits<const U&> 359 { 360 enum { result = true }; 361 typedef U& Result; 362 }; 363 364 /////////////////////////////////////////////////////// 365 // volatile 366 template<typename U> 367 struct UnVolatileTraits 368 { 369 enum { result = false }; 370 typedef U Result; 371 }; 372 template<typename U> 373 struct UnVolatileTraits<volatile U> 374 { 375 enum { result = true }; 376 typedef U Result; 377 }; 378 template<typename U> 379 struct UnVolatileTraits<volatile U&> 380 { 381 enum { result = true }; 382 typedef U& Result; 383 }; 384 public: 385 //T是否是指针类型 386 enum { isPointer = PointerTraits<T>::result }; 387 //T是否是引用类型 388 enum { isReference = ReferenceTraits<T>::result }; 389 //T是否指向成员函数的指针 390 enum { isMemberPointer = PointerToMemberTraits<T>::result }; 391 392 //T是否是Const类型 393 enum { isConst = UnConstTraits<T>::result }; 394 //T是否是Volatile类型 395 enum { isVolatile = UnVolatileTraits<T>::result }; 396 397 //如果T是指针类型,则获取T的原类型, 即去掉指针类型 398 typedef typename PointerTraits<T>::Result PointeeType; 399 //如果T是引用类型,则获取T的原类型, 即去掉引用类型 400 typedef typename ReferenceTraits<T>::Result ReferencedType; 401 //如果T是Const类型,则获取T的原类型, 即去掉Const类型 402 typedef typename UnConstTraits<T>::Result NonConstType; 403 //如果T是volatile类型,则获取T的原类型, 即去掉volatile类型 404 typedef typename UnVolatileTraits<T>::Result NonVolatileType; 405 //去掉const volatile类型 406 typedef typename UnVolatileTraits<typename UnConstTraits<T>::Result>::Result UnqualifiedType; 407 408 public: 409 410 ////////////////////////////////////////////////////// 411 // 412 typedef TL::TLMaker<unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long>::Result UnsignedInts; 413 typedef TL::TLMaker<signed char, short, int, long, long long>::Result SignedInts; 414 typedef TL::TLMaker<bool, char, wchar_t>::Result OtherInts; 415 typedef TL::TLMaker<float, double, long double>::Result Floats; 416 typedef TL::TYPELIST_2(TL::EmptyType, TL::NullType) NullTypes; 417 418 //无符号整形 419 enum { isStdUnsignedInt = TL::IndexOf<UnsignedInts, T>::value >= 0 }; 420 //有符号整形 421 enum { isStdSignedInt = TL::IndexOf<SignedInts, T>::value >= 0 }; 422 //整形 423 enum { isStdInt = isStdUnsignedInt || isStdSignedInt || TL::IndexOf<OtherInts, T>::value >= 0 }; 424 //浮点类型 425 enum { isStdFloat = TL::IndexOf<Floats, T>::value >= 0 }; 426 //数值类型 427 enum { isStdArith = isStdInt || isStdFloat }; 428 //基础类型(包括void) 429 enum { isStdFundamental = isStdArith || TL::IndexOf<TL::TYPELIST_1(void), T>::value >= 0}; 430 //空类型 431 enum { isNullType = TL::IndexOf<NullTypes, T>::value >= 0 }; 432 //简单类型 433 enum { isBaseType = isStdArith || isPointer || isMemberPointer }; 434 435 //对于复杂类型, 获取数据的引用类型, 即加上引用类型 436 typedef typename TypeSelect<isBaseType, T, ReferencedType&>::Result ReferenceType; 437 438 //对于复杂类型且非空类型, 获取数据的引用类型, 即加上引用类型 439 //typedef typename TypeSelect<isBaseType || isNullType, T, ReferencedType&>::Result ReferenceTypeEx; 440 441 //获取数据的原类型, 消除引用的引用这种情况 442 typedef typename TypeSelect<!isReference, T, ReferencedType&>::Result ParameterType; 443 }; 444 445 //////////////////////////////////////////////////////////////////////////////////////////////////// 446 //下面的使用开始展示TypeList的威力, 用于自动生成class 447 448 //散乱的继承体系 449 template<class TList, template <class> class Unit> 450 class ScatterHierarchy; 451 452 /* 453 namespace p 454 { 455 //注释copy至loki库 456 // The following type helps to overcome subtle flaw in the original 457 // implementation of GenScatterHierarchy. 458 // The flaw is revealed when the input type list of GenScatterHierarchy 459 // contains more then tars element of the same type (e.g. LOKI_TYPELIST_2(int, int)). 460 // In this case GenScatterHierarchy will contain multiple bases of the same 461 // type and some of them will not be reachable (per 10.3). 462 // For example before the fix the first element of Tuple<LOKI_TYPELIST_2(int, int)> 463 // is not reachable in any way! 464 template<class, class> 465 struct ScatterHierarchyTag; 466 } 467 template<class T1, class T2, template <class> class Unit> 468 class ScatterHierarchy<TypeList<T1, T2>, Unit> : public ScatterHierarchy<p::ScatterHierarchyTag<T1, T2>, Unit> 469 , public ScatterHierarchy<T2, Unit> 470 { 471 public: 472 typedef TypeList<T1, T2> TList; 473 typedef ScatterHierarchy<p::ScatterHierarchyTag<T1, T2>, Unit> LeftBase; 474 typedef ScatterHierarchy<T2, Unit> RightBase; 475 template<typename T> struct Rebind 476 { 477 typedef Unit<T> Result; 478 }; 479 }; 480 // In the middle *unique* class that resolve possible ambiguity 481 template <class T1, class T2, template <class> class Unit> 482 class ScatterHierarchy<p::ScatterHierarchyTag<T1, T2>, Unit> 483 : public ScatterHierarchy<T1, Unit> 484 { 485 }; 486 */ 487 488 //具现化继承体系 489 template <class T1, class T2, template <class> class Unit> 490 class ScatterHierarchy<TypeList<T1, T2>, Unit> 491 : public ScatterHierarchy<T1, Unit> 492 , public ScatterHierarchy<T2, Unit> 493 { 494 public: 495 typedef TypeList<T1, T2> TList; 496 typedef ScatterHierarchy<T1, Unit> LeftBase; 497 typedef ScatterHierarchy<T2, Unit> RightBase; 498 template <typename T> struct Rebind 499 { 500 typedef Unit<T> Result; 501 }; 502 }; 503 504 template<class AtomicType, template <class> class Unit> 505 class ScatterHierarchy : public Unit<AtomicType> 506 { 507 public: 508 typedef Unit<AtomicType> LeftBase; 509 510 template<typename T> struct Rebind 511 { 512 typedef Unit<T> Result; 513 }; 514 }; 515 516 template<template <class> class Unit> 517 class ScatterHierarchy<NullType, Unit> 518 { 519 public: 520 template<typename T> struct Rebind 521 { 522 typedef Unit<T> Result; 523 }; 524 }; 525 526 ///////////////////////////////////////////////////////////////////// 527 //构建继承体系后, 采用下面的函数获取继承体系中某个类 528 529 template<class T, class H> 530 struct FieldHelperByType 531 { 532 typedef typename H::template Rebind<T>::Result ResultType; 533 static ResultType& dochange(H &obj) 534 { 535 return static_cast<ResultType&>(obj); 536 } 537 }; 538 template<class T, class H> 539 struct FieldHelperByType<T, const H> 540 { 541 typedef const typename H::template Rebind<T>::Result ResultType; 542 static ResultType& dochange(const H &obj) 543 { 544 return (ResultType&)obj; 545 } 546 }; 547 548 //直接按照类型获取, 如果有两个相同的类型, 则编译不过 549 template<class T, class H> 550 typename FieldHelperByType<T, H>::ResultType& field(H &obj) 551 { 552 return FieldHelperByType<T, H>::dochange(obj); 553 } 554 555 ///////////////////////////////////////////////////////////////////// 556 // 根据索引获取字段 557 //定义Tuple, 默认的数据操作器(Unit) 558 template<typename T> 559 struct TupleUnit 560 { 561 T _value; 562 operator T&() { return _value; } 563 operator const T&() const { return _value; } 564 }; 565 566 template<class TList> 567 struct Tuple : public ScatterHierarchy<TList, TupleUnit> 568 { 569 }; 570 571 //定义FieldHelperByIndex 572 template<class H, unsigned int i> struct FieldHelperByIndex; 573 574 //特化版本的FieldHelperByIndex, 推导出最后一个元素 575 template<class H> 576 struct FieldHelperByIndex<H, 0> 577 { 578 typedef typename H::TList::H ElementType; 579 typedef typename H::template Rebind<ElementType>::Result UnitType; 580 581 enum 582 { 583 isTuple = Conversion<UnitType, TupleUnit<ElementType> >::sameType, 584 isConst = TypeTraits<H>::isConst 585 }; 586 587 typedef const typename H::LeftBase ConstLeftBase; 588 typedef typename TypeSelect<isConst, ConstLeftBase, typename H::LeftBase>::Result LeftBase; 589 typedef typename TypeSelect<isTuple, ElementType, UnitType>::Result UnqualifiedResultType; 590 typedef typename TypeSelect<isConst, const UnqualifiedResultType, UnqualifiedResultType>::Result ResultType; 591 592 static ResultType &dochange(H& obj) 593 { 594 LeftBase &leftBase = obj; 595 return (ResultType&)leftBase; 596 } 597 }; 598 599 //根据索引获取FieldHelper 600 template<class H, unsigned int i> 601 struct FieldHelperByIndex 602 { 603 typedef typename TypeAt<typename H::TList, i>::Result ElementType; 604 typedef typename H::template Rebind<ElementType>::Result UnitType; 605 606 enum 607 { 608 isTuple = Conversion<UnitType, TupleUnit<ElementType> >::sameType, 609 isConst = TypeTraits<H>::isConst 610 }; 611 612 typedef const typename H::RightBase ConstRightBase; 613 typedef typename TypeSelect<isConst, ConstRightBase, typename H::RightBase>::Result RightBase; 614 typedef typename TypeSelect<isTuple, ElementType, UnitType>::Result UnqualifiedResultType; 615 typedef typename TypeSelect<isConst, const UnqualifiedResultType, UnqualifiedResultType>::Result ResultType; 616 617 static ResultType &dochange(H& obj) 618 { 619 RightBase &rightBase = obj; 620 return FieldHelperByIndex<RightBase, i-1>::dochange(rightBase); 621 } 622 }; 623 624 //定义按照索引获取 625 template<unsigned int i, class H> 626 typename FieldHelperByIndex<H, i>::ResultType &field(H& obj) 627 { 628 return FieldHelperByIndex<H, i>::dochange(obj); 629 } 630 } 631 632 } 633 #endif 634
是不是有一种看天书的感觉， 确实如此。
也行, 姑且把它当成和STL类似的基础库， 别纠结于它。
转自：https://blog.csdn.net/stpeace/article/details/79772562