编译校验【代码笔记】
1、版本编译控制（比如多项目）
2、编译校验
3、static_cast
----------------------------------------------------------
// static_check.cpp : Defines the entry point for the console application.//#include "stdafx.h"#include <string>using namespace std;namespace Loki{////////////////////////////////////////////////////////////////////////////////// Helper structure for the STATIC_CHECK macro//////////////////////////////////////////////////////////////////////////////// template<int> struct CompileTimeError; template<> struct CompileTimeError<true> {};}////////////////////////////////////////////////////////////////////////////////// macro STATIC_CHECK// Invocation: STATIC_CHECK(expr, id)// where:// expr is a compile-time integral or pointer expression// id is a C++ identifier that does not need to be defined// If expr is zero, id will appear in a compile-time error message.////////////////////////////////////////////////////////////////////////////////#define STATIC_CHECK(expr, msg) \ { Loki::CompileTimeError<((expr) != 0)> ERROR_##msg; (void)ERROR_##msg; } int _tmain(int argc, _TCHAR* argv[]){STATIC_CHECK((sizeof(int) == 4 && sizeof(long) == 4), 32bit);STATIC_CHECK((sizeof(int) != sizeof(long)), 64bit);return 0;} ////////////////////////////////////////////////////////////////////////////////
// The Loki Library// Copyright (c) 2001 by Andrei Alexandrescu// This code accompanies the book:// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design // Patterns Applied". Copyright (c) 2001. Addison-Wesley.// Permission to use, copy, modify, distribute and sell this software for any // purpose is hereby granted without fee, provided that the above copyright // notice appear in all copies and that both that copyright notice and this // permission notice appear in supporting documentation.// The author or Addison-Welsey Longman make no representations about the // suitability of this software for any purpose. It is provided "as is" // without express or implied warranty.////////////////////////////////////////////////////////////////////////////////// Last update: November 22, 2001#ifndef TYPEMANIP_INC_#define TYPEMANIP_INC_namespace Loki{////////////////////////////////////////////////////////////////////////////////// class template Int2Type// Converts each integral constant into a unique type// Invocation: Int2Type<v> where v is a compile-time constant integral// Defines 'value', an enum that evaluates to v//////////////////////////////////////////////////////////////////////////////// template <int v> struct Int2Type { enum { value = v }; }; ////////////////////////////////////////////////////////////////////////////////// class template Type2Type// Converts each type into a unique, insipid type// Invocation Type2Type<T> where T is a type// Defines the type OriginalType which maps back to T//////////////////////////////////////////////////////////////////////////////// template <typename T> struct Type2Type { typedef T OriginalType; }; ////////////////////////////////////////////////////////////////////////////////// class template Select// Selects one of two types based upon a boolean constant// Invocation: Select<flag, T, U>::Result// where:// flag is a compile-time boolean constant// T and U are types// Result evaluates to T if flag is true, and to U otherwise.//////////////////////////////////////////////////////////////////////////////// template <bool flag, typename T, typename U> struct Select { typedef T Result; }; template <typename T, typename U> struct Select<false, T, U> { typedef U Result; }; ////////////////////////////////////////////////////////////////////////////////// class template IsSameType// Return true iff two given types are the same// Invocation: SameType<T, U>::value// where:// T and U are types// Result evaluates to true iff U == T (types equal)//////////////////////////////////////////////////////////////////////////////// template <typename T, typename U> struct IsSameType { enum { value = false }; }; template <typename T> struct IsSameType<T,T> { enum { value = true }; };////////////////////////////////////////////////////////////////////////////////// Helper types Small and Big - guarantee that sizeof(Small) < sizeof(Big)//////////////////////////////////////////////////////////////////////////////// namespace Private { template <class T, class U> struct ConversionHelper { typedef char Small; struct Big { char dummy; }; static Big Test(...); static Small Test(U); static T MakeT(); }; }////////////////////////////////////////////////////////////////////////////////// class template Conversion// Figures out the conversion relationships between two types// Invocations (T and U are types):// a) Conversion<T, U>::exists// returns (at compile time) true if there is an implicit conversion from T// to U (example: Derived to Base)// b) Conversion<T, U>::exists2Way// returns (at compile time) true if there are both conversions from T// to U and from U to T (example: int to char and back)// c) Conversion<T, U>::sameType// returns (at compile time) true if T and U represent the same type//// Caveat: might not work if T and U are in a private inheritance hierarchy.//////////////////////////////////////////////////////////////////////////////// template <class T, class U> struct Conversion { typedef Private::ConversionHelper<T, U> H;#ifndef __MWERKS__ enum { exists = sizeof(typename H::Small) == sizeof((H::Test(H::MakeT()))) };#else enum { exists = false };#endif enum { exists2Way = exists && Conversion<U, T>::exists }; enum { sameType = false }; }; template <class T> struct Conversion<T, T> { enum { exists = 1, exists2Way = 1, sameType = 1 }; }; template <class T> struct Conversion<void, T> { enum { exists = 0, exists2Way = 0, sameType = 0 }; }; template <class T> struct Conversion<T, void> { enum { exists = 0, exists2Way = 0, sameType = 0 }; }; template <> struct Conversion<void, void> { public: enum { exists = 1, exists2Way = 1, sameType = 1 }; };////////////////////////////////////////////////////////////////////////////////// class template SuperSubclass// Invocation: SuperSubclass<B, D>::value where B and D are types. // Returns true if B is a public base of D, or if B and D are aliases of the // same type.//// Caveat: might not work if T and U are in a private inheritance hierarchy.////////////////////////////////////////////////////////////////////////////////template <class T, class U>struct SuperSubclass{enum { value = (::Loki::Conversion<const volatile U*, const volatile T*>::exists && !::Loki::Conversion<const volatile T*, const volatile void*>::sameType) };};////////////////////////////////////////////////////////////////////////////////// class template SuperSubclassStrict// Invocation: SuperSubclassStrict<B, D>::value where B and D are types. // Returns true if B is a public base of D.//// Caveat: might not work if T and U are in a private inheritance hierarchy.////////////////////////////////////////////////////////////////////////////////template<class T,class U>struct SuperSubclassStrict{enum { value = (::Loki::Conversion<const volatile U*, const volatile T*>::exists && !::Loki::Conversion<const volatile T*, const volatile void*>::sameType && !::Loki::Conversion<const volatile T*, const volatile U*>::sameType) };};} // namespace Loki////////////////////////////////////////////////////////////////////////////////// macro SUPERSUBCLASS// Invocation: SUPERSUBCLASS(B, D) where B and D are types. // Returns true if B is a public base of D, or if B and D are aliases of the // same type.//// Caveat: might not work if T and U are in a private inheritance hierarchy.// Deprecated: Use SuperSubclass class template instead.////////////////////////////////////////////////////////////////////////////////#define SUPERSUBCLASS(T, U) \ ::Loki::SuperSubclass<T,U>::value////////////////////////////////////////////////////////////////////////////////// macro SUPERSUBCLASS_STRICT// Invocation: SUPERSUBCLASS(B, D) where B and D are types. // Returns true if B is a public base of D.//// Caveat: might not work if T and U are in a private inheritance hierarchy.// Deprecated: Use SuperSubclassStrict class template instead.////////////////////////////////////////////////////////////////////////////////#define SUPERSUBCLASS_STRICT(T, U) \ ::Loki::SuperSubclassStrict<T,U>::value////////////////////////////////////////////////////////////////////////////////// Change log:// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!// November 22, 2001: minor change to support porting to boost// November 22, 2001: fixed bug in Conversion<void, T>// (credit due to Brad Town)// November 23, 2001: (well it's 12:01 am) fixed bug in SUPERSUBCLASS - added// the volatile qualifier to be 100% politically correct// September 16, 2002: Changed "const volatile" to "const volatile *", to enable// conversion to succeed. Done earlier by MKH.// Added SuperSubclass and SuperSubclassStrict templates. The corresponding// macros are deprecated.// Added extra parenthesis in sizeof in Conversion, to disambiguate function// call from function declaration. T.S.////////////////////////////////////////////////////////////////////////////////#endif // TYPEMANIP_INC_
页:
[1]