google protobuf 源码阅读（一）

文件： common.h，位于 src/google/protobuf/stubs 目录。下面·的代码是在阅读的时候，不太懂的地方，先记录下来。

（1）如下代码的意义

#ifdef _MSC_VER#define GOOGLE_LONGLONG(x) x##I64#define GOOGLE_ULONGLONG(x) x##UI64#define GOOGLE_LL_FORMAT "I64"  // As in printf("%I64d", ...)#else#define GOOGLE_LONGLONG(x) x##LL#define GOOGLE_ULONGLONG(x) x##ULL#define GOOGLE_LL_FORMAT "ll"  // As in "%lld". Note that "q" is poor form also.#endifstatic const int32 kint32max = 0x7FFFFFFF;static const int32 kint32min = -kint32max - 1;static const int64 kint64max = GOOGLE_LONGLONG(0x7FFFFFFFFFFFFFFF);static const int64 kint64min = -kint64max - 1;static const uint32 kuint32max = 0xFFFFFFFFu;static const uint64 kuint64max = GOOGLE_ULONGLONG(0xFFFFFFFFFFFFFFFF);

（2）如下代码的意义

#ifndef GOOGLE_ATTRIBUTE_ALWAYS_INLINE#if defined(__GNUC__) && (__GNUC__ > 3 ||(__GNUC__ == 3 && __GNUC_MINOR__ >= 1))// For functions we want to force inline.// Introduced in gcc 3.1.#define GOOGLE_ATTRIBUTE_ALWAYS_INLINE __attribute__ ((always_inline))#else// Other compilers will have to figure it out for themselves.#define GOOGLE_ATTRIBUTE_ALWAYS_INLINE#endif#endif#ifndef GOOGLE_ATTRIBUTE_DEPRECATED#ifdef __GNUC__// If the method/variable/type is used anywhere, produce a warning.#define GOOGLE_ATTRIBUTE_DEPRECATED __attribute__((deprecated))#else#define GOOGLE_ATTRIBUTE_DEPRECATED#endif#endif#ifndef GOOGLE_PREDICT_TRUE#ifdef __GNUC__// Provided at least since GCC 3.0.#define GOOGLE_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))#else#define GOOGLE_PREDICT_TRUE#endif#endif

（3）如下代的意义

#undef GOOGLE_ARRAYSIZE#define GOOGLE_ARRAYSIZE(a) \  ((sizeof(a) / sizeof(*(a))) / \   static_cast<size_t>(!(sizeof(a) % sizeof(*(a))))

（4）如下代码的意义

namespace internal {// Use implicit_cast as a safe version of static_cast or const_cast// for upcasting in the type hierarchy (i.e. casting a pointer to Foo// to a pointer to SuperclassOfFoo or casting a pointer to Foo to// a const pointer to Foo).// When you use implicit_cast, the compiler checks that the cast is safe.// Such explicit implicit_casts are necessary in surprisingly many// situations where C++ demands an exact type match instead of an// argument type convertable to a target type.//// The From type can be inferred, so the preferred syntax for using// implicit_cast is the same as for static_cast etc.:////   implicit_cast<ToType>(expr)//// implicit_cast would have been part of the C++ standard library,// but the proposal was submitted too late.  It will probably make// its way into the language in the future.template<typename To, typename From>inline To implicit_cast(From const &f) {  return f;}// When you upcast (that is, cast a pointer from type Foo to type// SuperclassOfFoo), it's fine to use implicit_cast<>, since upcasts// always succeed.  When you downcast (that is, cast a pointer from// type Foo to type SubclassOfFoo), static_cast<> isn't safe, because// how do you know the pointer is really of type SubclassOfFoo?  It// could be a bare Foo, or of type DifferentSubclassOfFoo.  Thus,// when you downcast, you should use this macro.  In debug mode, we// use dynamic_cast<> to double-check the downcast is legal (we die// if it's not).  In normal mode, we do the efficient static_cast<>// instead.  Thus, it's important to test in debug mode to make sure// the cast is legal!//    This is the only place in the code we should use dynamic_cast<>.// In particular, you SHOULDN'T be using dynamic_cast<> in order to// do RTTI (eg code like this://    if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo);//    if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo);// You should design the code some other way not to need this.template<typename To, typename From>     // use like this: down_cast<T*>(foo);inline To down_cast(From* f) {                   // so we only accept pointers  // Ensures that To is a sub-type of From *.  This test is here only  // for compile-time type checking, and has no overhead in an  // optimized build at run-time, as it will be optimized away  // completely.  if (false) {    implicit_cast<From*, To>(0);  }#if !defined(NDEBUG) && !defined(GOOGLE_PROTOBUF_NO_RTTI)  assert(f == NULL || dynamic_cast<To>(f) != NULL);  // RTTI: debug mode only!#endif  return static_cast<To>(f);}} 

（5）如下代码的意义

template<typename T> struct remove_pointer { typedef T type; };template<typename T> struct remove_pointer<T*> { typedef T type; };template<typename T> struct remove_pointer<T* const> { typedef T type; };template<typename T> struct remove_pointer<T* volatile> { typedef T type; };template<typename T> struct remove_pointer<T* const volatile> {  typedef T type; };