1 // Copyright (c) 2006-2009 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef BASE_CASTS_H_ 6 #define BASE_CASTS_H_ 7 8 #include <assert.h> // for use with down_cast<> 9 #include <string.h> // for memcpy 10 11 #include "base/macros.h" 12 13 14 // Use implicit_cast as a safe version of static_cast or const_cast 15 // for upcasting in the type hierarchy (i.e. casting a pointer to Foo 16 // to a pointer to SuperclassOfFoo or casting a pointer to Foo to 17 // a const pointer to Foo). 18 // When you use implicit_cast, the compiler checks that the cast is safe. 19 // Such explicit implicit_casts are necessary in surprisingly many 20 // situations where C++ demands an exact type match instead of an 21 // argument type convertable to a target type. 22 // 23 // The From type can be inferred, so the preferred syntax for using 24 // implicit_cast is the same as for static_cast etc.: 25 // 26 // implicit_cast<ToType>(expr) 27 // 28 // implicit_cast would have been part of the C++ standard library, 29 // but the proposal was submitted too late. It will probably make 30 // its way into the language in the future. 31 template<typename To, typename From> 32 inline To implicit_cast(From const &f) { 33 return f; 34 } 35 36 37 // When you upcast (that is, cast a pointer from type Foo to type 38 // SuperclassOfFoo), it's fine to use implicit_cast<>, since upcasts 39 // always succeed. When you downcast (that is, cast a pointer from 40 // type Foo to type SubclassOfFoo), static_cast<> isn't safe, because 41 // how do you know the pointer is really of type SubclassOfFoo? It 42 // could be a bare Foo, or of type DifferentSubclassOfFoo. Thus, 43 // when you downcast, you should use this macro. In debug mode, we 44 // use dynamic_cast<> to double-check the downcast is legal (we die 45 // if it's not). In normal mode, we do the efficient static_cast<> 46 // instead. Thus, it's important to test in debug mode to make sure 47 // the cast is legal! 48 // This is the only place in the code we should use dynamic_cast<>. 49 // In particular, you SHOULDN'T be using dynamic_cast<> in order to 50 // do RTTI (eg code like this: 51 // if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo); 52 // if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo); 53 // You should design the code some other way not to need this. 54 55 template<typename To, typename From> // use like this: down_cast<T*>(foo); 56 inline To down_cast(From* f) { // so we only accept pointers 57 // Ensures that To is a sub-type of From *. This test is here only 58 // for compile-time type checking, and has no overhead in an 59 // optimized build at run-time, as it will be optimized away 60 // completely. 61 if (false) { 62 implicit_cast<From*, To>(0); 63 } 64 65 assert(f == NULL || dynamic_cast<To>(f) != NULL); // RTTI: debug mode only! 66 return static_cast<To>(f); 67 } 68 69 // Overload of down_cast for references. Use like this: down_cast<T&>(foo). 70 // The code is slightly convoluted because we're still using the pointer 71 // form of dynamic cast. (The reference form throws an exception if it 72 // fails.) 73 // 74 // There's no need for a special const overload either for the pointer 75 // or the reference form. If you call down_cast with a const T&, the 76 // compiler will just bind From to const T. 77 template<typename To, typename From> 78 inline To down_cast(From& f) { 79 COMPILE_ASSERT(base::is_reference<To>::value, target_type_not_a_reference); 80 typedef typename base::remove_reference<To>::type* ToAsPointer; 81 if (false) { 82 // Compile-time check that To inherits from From. See above for details. 83 implicit_cast<From*, ToAsPointer>(0); 84 } 85 86 assert(dynamic_cast<ToAsPointer>(&f) != NULL); // RTTI: debug mode only 87 return static_cast<To>(f); 88 } 89 90 // bit_cast<Dest,Source> is a template function that implements the 91 // equivalent of "*reinterpret_cast<Dest*>(&source)". We need this in 92 // very low-level functions like the protobuf library and fast math 93 // support. 94 // 95 // float f = 3.14159265358979; 96 // int i = bit_cast<int32>(f); 97 // // i = 0x40490fdb 98 // 99 // The classical address-casting method is: 100 // 101 // // WRONG 102 // float f = 3.14159265358979; // WRONG 103 // int i = * reinterpret_cast<int*>(&f); // WRONG 104 // 105 // The address-casting method actually produces undefined behavior 106 // according to ISO C++ specification section 3.10 -15 -. Roughly, this 107 // section says: if an object in memory has one type, and a program 108 // accesses it with a different type, then the result is undefined 109 // behavior for most values of "different type". 110 // 111 // This is true for any cast syntax, either *(int*)&f or 112 // *reinterpret_cast<int*>(&f). And it is particularly true for 113 // conversions betweeen integral lvalues and floating-point lvalues. 114 // 115 // The purpose of 3.10 -15- is to allow optimizing compilers to assume 116 // that expressions with different types refer to different memory. gcc 117 // 4.0.1 has an optimizer that takes advantage of this. So a 118 // non-conforming program quietly produces wildly incorrect output. 119 // 120 // The problem is not the use of reinterpret_cast. The problem is type 121 // punning: holding an object in memory of one type and reading its bits 122 // back using a different type. 123 // 124 // The C++ standard is more subtle and complex than this, but that 125 // is the basic idea. 126 // 127 // Anyways ... 128 // 129 // bit_cast<> calls memcpy() which is blessed by the standard, 130 // especially by the example in section 3.9 . Also, of course, 131 // bit_cast<> wraps up the nasty logic in one place. 132 // 133 // Fortunately memcpy() is very fast. In optimized mode, with a 134 // constant size, gcc 2.95.3, gcc 4.0.1, and msvc 7.1 produce inline 135 // code with the minimal amount of data movement. On a 32-bit system, 136 // memcpy(d,s,4) compiles to one load and one store, and memcpy(d,s,8) 137 // compiles to two loads and two stores. 138 // 139 // I tested this code with gcc 2.95.3, gcc 4.0.1, icc 8.1, and msvc 7.1. 140 // 141 // WARNING: if Dest or Source is a non-POD type, the result of the memcpy 142 // is likely to surprise you. 143 // 144 145 template <class Dest, class Source> 146 inline Dest bit_cast(const Source& source) { 147 // Compile time assertion: sizeof(Dest) == sizeof(Source) 148 // A compile error here means your Dest and Source have different sizes. 149 typedef char VerifySizesAreEqual [sizeof(Dest) == sizeof(Source) ? 1 : -1]; 150 151 Dest dest; 152 memcpy(&dest, &source, sizeof(dest)); 153 return dest; 154 } 155 156 #endif // BASE_CASTS_H_ 157
