reinterpret_cast vs c cast

dezembro 15, 2022     Seja o primeiro a comentar

This is true for both the union and reinterpret_cast approaches. a "new CBaseY()" 17. 10. reinterpret_cast It tells somebody reading the code that we had to compromise something and as a result we have ended up with a dangerous cast, and be careful when you mess with this code. Don't use static cast for arithmetic conversions (cpp-core-guidelines). Protobuf . Member enum : Which Method is Better & Why? To see how static_cast<> actually works, we have to look at the memory layout of CDerived. The C++ compiler detects and quietly fixes most but not all violations. Compile a static binary which code there a function gethostbyname, is there any difference between static cast to rvalue reference and std::move, Which MinGW file to use as a C++ compiler. void bar() { printf("CBaseY::bar() y=%d, *py=%d/n", y, *py); And to not break the C style, the writer of that code used macros instead of constant expressions. For a conversion of void* to int* you can only use static_cast (or the equivalent C-style cast). The most reliable and understandable document that I can find is cppreference.com Here is the link to static_cast and reinterpret_cast But here is some quick explanation for basic and common cases. C++11 Passing function as lambda parameter, How can cmake activate "Inherit from parent" link option in Visual Studio. Scenario 1: Conversion between two unrelated classes. public: While we are at it, we can replace the C-cast with the proper C++ cast, which in this case is reinterpret_cast: constexpr auto FOO = reinterpret_cast<uint8*> (0xBAD50BAD); constexpr auto BAR = reinterpret_cast<S*> (FOO); Sadly, this won't compile, because reinterpret_cast s are not allowed in constant expressions by the standard. // System the conversions that can be performed using a reinterpret_cast are limited; the permissible ones are specified by the standard. 392fbc CDerived s pD1 Once we've converted the pointer to void, we can't easily convert it back to the original class. The definitions of FOO and BAR then looked like this: Where uint8 is a typedef to some 8-bit unsigned type, and S is a struct. Be aware that modifiyng objects that actually are declared as const is undefined behaviour. http://blog.csdn.net/jiangdf/archive/2009/05/21/4205481.aspx, The difference between anSI, unicode, utf-8, DBCS and other character sets and related data types and functions, The OSG implements a camera that follows the node, OSG uses OpenGL Vertex Shaders and Chip Shaders, OSG adds the osgParticle particle effect to the scene, The STL carefully selects the container type, The more perfect point is judged in the multilateral line (c? CDerived* pD = new CDerived(); C++: reinterpret_cast v.s. The definition of nullptr_t could be found from LLVM header __nullptr (link), As we can see from the following two lines, it can be converted to pointer type either pointer to an object or a pointer to a class member, using implicit conversion. To be fair, a handful of those macros were in actual C headers provided by third parties, but many of them appeared to be written only in the same style in a project that specifically claims to be a C++ project. CDerived* pD3 = static_cast(pY3); How does including gtest.h break template argument deduction for a std algorithm? 2. An actual type-pun that directly reads the bits of p using the representation of type T* only happens when you cast to a reference type, as in reinterpret_cast(p). public: So, when you convert CDerived to CBaseY, it adds 4 bytes to the pointer, and when you convert CBaseY to CDerived, it subtracts 4 from the pointer. Sometimes we may be a little fuzzy when we use static_cast<> and reinterpret_cast<> when we write C.C. reinterpret_cast C-style cast? output --------------------------- CDerived*pD s 392fbb8 That means that when it acts like a reinterpret_cast, it has the exact same problems as a reinterpret_cast.But in addition, it has these problems: Love podcasts or audiobooks? This means that when you use it to convert from, say, an int* to a float*, then you have no guarantee that the resulting pointer will point to the same address. 1. Most C++ developers know that #defines are evil because the are simple text replacement and therefore bring problems like lacking type safety and more. // Compiled successfully, pD1 now s pD the compiler knows you should call static_cast<> //int i s reinterpret_cast (f); They do not function same. In current C++, you can't use reinterpret_cast like in that code. CBaseY s pY s How do you use CreateThread for functions which are class members? Powered by WordPress and Stargazer. C++ .reinterpret_cast:reinpreter_cast<type-id> (expression) reinterpret_cast,,.: int n=9; double d= reinterpret_cast< double > (n); . //error, 17. CBaseX() { x = 10; } const_cast is pretty easy to understand as it doesnt change the memory layout and just toggle the const flag for the compiler to help you do or avoid some checks. Compile C files in C++ project which do not use precompiled header? 2. dynamic_cast<> needs the class to become polymorphic, i.e. static_cast provided that you know (by design of your program) that the thing pointed to really is an int. Note: When you convert CDerived s to CBaseY with an implicit static_cast<> (line 5), the result is (pointing to) CDerived? One thing to notice though is that nullptr_t cant be convert to other pointer types such as void* or int* using reinterpret_cast because nullptr_t is an object type not a pointer type. Solution 1. Comment document.getElementById("comment").setAttribute( "id", "ae10f4a28469b8a73cf8745d5899237d" );document.getElementById("a2d4e530cf").setAttribute( "id", "comment" ); Copyright 2022 Simplify C++!. No. Any light to shed here? Since a C-style cast is basically a "oh, just cast it however you can" cast, it's better to prefer the more specific casts. 18. printf("CDerived* pD3 = %x/n", (int)pD3); not CBaseX // Compiled Lets have a look from the memory perspective. Can I assume that reinterpret_cast is not safe and should not be used? , : fftw_complex *H_cast; H_cast = (fftw_complex*) fftw_malloc(sizeof(fftw_complex)*M*N); : H_cast= reinterpret_cast (H); int main() { class_name object; object.method(); fstream file(writeobject.dat , ios::out|ios::app); file.write(reinterpret_cast(&object), sizeof(object)); return 0; } 1 , union { T var_1; U var_2; } var_2 = reinterpret_cast (var_1) ? // pY2->bar(); } It simply tries the various C++-style casts in order, until it finds one that works. // static cast <> interpreting the same address as yet something else might not be wanted. the pointer variable pf is a fluat type, which is now to be converted to an int type) Which to use when? Conversely, a C-style cast (as in (int)42.0) is much harder to find reliably by searching To answer the other part of your question, yes, reinterpret_cast is implementation-defined. (programs). However, in memory manipulation . CDerived* pD1 = static_cast(pY1); In which scenario do I use a particular STL container? What are the basic rules and idioms for operator overloading? protobuf . The actual pointer object is a constant expression, but we still have a macro, what about that? Scenario 2: Transition to the relevant class. It's used primarily for things like turning a raw data bit stream into actual data or storing data in the low bits of an aligned pointer. Refresh the page, check Medium 's site. Furthermore, it is currently impossible to implement a constexpr bit-cast function . We probably do only want these pairs, i.e. In C++0x, reinterpret_cast(p) will be equivalent to static_cast(p). Over the last couple days, I've been reading up on the various casting operators in C++. In C++, reinterpret_cast, static_cast and const_cast is very common. Even in the C++20 world where we can allocate memory at compile time, reinterpret_cast is forbidden in constexpr functions. gives some good details. n s 12 int n s static_cast (f); The compiler emitted a little over 1000 warnings or, more precisely, the same warning 1000 times. void* is just an ugly way of saying, "I don't know the type, but I'm going to pass the pointer on to someone else who does". In this article, I'll explain what static_cast<> actually did, and point out some situations that will lead to errors. For a conversion of void* to int* you can only use static_cast (or the equivalent C-style cast). Errors can occur if no one pointer can be converted to void, and void can be converted backward to any pointer (for static_cast<> and reinterpret_cast<> conversions). For object pointers. Can I use partial template specialization for a (non-member) function? It's probably incorporated in one of the next WPs. Immediate scheduler , reinterpret_cast, gradlew gradle, undefined reference android NDK. Possible Duplicates: vs. python, . }; class CDerived : public CBaseX, public CBaseY ---------------------- Output If you know C, you know which one the C-style cast does, but it's nicer in some ways to have different syntax for both. s pY printf ("void s pV1 s %x/n", (int)pV1); If there are two parent classes, then the result of upcasting to different parent class would be different. to un arerelated // It is used when we want to work with bits. float f = 12.3; Lets look at them side by side. IS 5.2.10 - Reinterpret cast -1- The result of the expression reinterpret_cast<T> (v) is the result of converting the expression v to type T. . This is exclusively to be used in inheritence when you cast from base class to derived class. int z; Bjarne Stroustrup, in his guidelines, recommended reinterpret_cast in another context: if you want to type-pun in a way that the language does not define by a static_cast , he suggested that you do it with something like . Before you ask: No, we can not go back to the C-cast, because the rules say that in this case, effectively a reinterpret_cast is performed. Copyright 2022 www.appsloveworld.com. One of the explicit goals of bit_cast is to be able to do these sorts of things at compile-time:. Should one never use static inline function? reinterpret_cast has nothing to do with 'const'. reinterpret_cast < new-type > ( expression ) Returns a value of type new-type . If we go ahead and replace the macro with a constant expression, we should get the warning at the exact location where the C-cast is written, not where the macros are expanded. ; . the difference between static_cast and reinterpret_cast Most programmers have studied C before they learn C and are accustomed to C-style (type) conversion. Error, type point is irrelevant // CBaseY s pY1 s static_cast (pX); Most programmers have studied C before they learn C and are accustomed to C-style (type) conversion. And is suggested to use it using proper data type i.e., (pointer data type should be same as original data type). As we've learned in generic examples, if you try to convert an object to another unrelated class static_cast<> will fail, and reinterpret_cast<> always succeed in "spoofing" the compiler: that object is the unrelated class. When should static_cast, dynamic_cast, const_cast and reinterpret_cast be used? - security/portablility/performance . Sometimes we may be a little fuzzy when we use static_cast<> and reinterpret_cast<> when we write C.C. reinterpret_cast < new-type > ( expression ) Returns a value of type new-type . But thats not too satisfying, is it? // System crash!! Don't conclude from the answers that (type)expression in C++ is equivalent to a reinterpret_cast. Which is better option to use for dividing an integer number by 2? From the semantics of your problem, I'd go with reinterpret, because that's what you actually do. Your email address will not be published. int y; Note that the (type)exression equivalent of C can do much more than reinterpret_cast in C++ (well, after all, they are two different languages - so we can't expect much anyway). reinterpret_cast if you've omitted details that mean you might actually be reading memory using a type other than the type is was written with, and be aware that your code will have limited portability. How does ENet manage its arriving packets? The amount of code broken when it's rejected will be no fun, so there is no motivation for them to forbid it. CBaseY() { y = 20; py = &y; } Where would you use a friend function vs. a static member function? Conversion fct( reinterpret_cast< B* >( pC ) );:-) Here is what Microsoft has to say about reinterpret_cast <Quote> The reinterpret_cast operator allows any pointer to be converted into any other pointer type. const_cast<NewType> (static_cast<const NewType> (variable)) reinterpret_cast<const NewType> (variable) const_cast<NewType> (reinterpret_cast<const NewType> (variable)) Functional casting is very similar, though as a few restrictions as the result of its syntax: NewType (expression). We could stop here and give up. // pD2 s pY, but we expect pD2 s pY - 4 However it will affect how other CPU instructions are generated. reinterpret_cast: Casts anything which has the same size, for example, int to FancyClass* on x86. I suggest that reinterpret_cast is "better" for this task, since it makes the intent clearer. Code D3, https://kristerw.blogspot.se/2017/07/hard-coded-hardware-addresses-in-cc.html, Whats Ubiquitous Language and Why You Should Care, [fix dev diary] Week 6-7: Description and Issue ID, isValid()? The conversions to the two pointer types still have to be done in the runtime code, so they are in functions that are not constepr. For a conversion between different function type pointers or between different object type pointers you need to use reinterpret_cast. // Error, the type pointed to is irrelevant (i.e. When would I use const volatile, register volatile, static volatile in C++? const_cast on the other hand, could change the data. // Compiled successfully, but pY2 is (The pointer is backward) offset by 4 (bytes) (4 is the number of bytes that the int type occupies in memory). Because you can use cast it using C-style cast, but this is not explicit so that is not recommended. constexpr and initialization of a static const void pointer with reinterpret cast, which compiler is right? ; ( ), . Use the reinterpret_cast<> to highlight these dangerous areas in the code. At that point, it's up to you to understand exactly what your compiler and machine do in this situation. Explanation Unlike static_cast, but like const_cast, the reinterpret_cast expression does not compile to any CPU instructions (except when converting between integers and pointers or on obscure architectures where pointer representation depends on its type). CDerived* pD = new CDerived(); Does boost::asio::deadline_timer use a thread for each timer? 2. printf("CDerived* pD = %x/n", (int)pD); What is the use of private static member functions? Getting around the reinterpret cast limitation with constexpr. reinterpret_cast is a very special and dangerous type of casting operator. [MSDN] C++ Language Reference -- Casting Is it safe to use the address of a static local variable within a function template as a type identifier? The reinterpret_cast operator, as well as the other named cast operators, is more easily spotted than C-style casts, and highlights the paradox of a strongly typed language that allows explicit casts. Pointer conversion is a bit complicated, and we'll use the following classes for the rest of this article: class CBaseX : double x = 10.3; int y; y = (int) x; // c-like cast notation : double x = 10.3; int y; y = reinterpret_cast(x). void foo() { printf("CBaseX::foo() x=%d/n", x); } 13. successfully, but pY2 is not CBaseX CBaseY*pY2 s reinterpret_cast< CBaseY*> (pX); It can typecast any pointer to any other data type. { C-Style casting, using the (type)variable syntax. When and why would you use static with constexpr? The reinterpret_cast operator can be used for conversions such as char* to int*, or One_class* to Unrelated_class*, which are inherently unsafe. In C++0x, reinterpret_cast<int*> (p) will be . Which std::async implementations use thread pools? CBaseY s pY1 s Note: s pY2 s 392fb8 Juan Soulie, C++ Language Tutorial: Type Casting, This article is from the CSDN blog and reproduced with the source: reinterpret_cast vs c style cast Possible Duplicate: c-style cast vs reinterpret_cast : A* pA = new B; B* p1 = (B*)pA; B* p2 = reinterpret_cast<B*>(pA); ? It's a misconception that reinterpret_cast(p) would interpret the bits of p as if they were representing a T*. So we might not want to bake the cast into the constant expression. For a conversion between different function type pointers or between different object type pointers you need to use reinterpret_cast. We could go ahead and replace our raw function with an implicit conversion operator, but I think that is not what we should do. int* py; Required fields are marked *. s 392fb8 CBasey The other two is sometimes confusing. Learn on the go with our new app. In the assembly code, you wont see any CPU instructions corresponding to the reinterpret_cast call. But wait the all-caps FOO and BAR look suspicious. is actually meaningless, and as int*pi s/reinterpret_cast (pf); Is there a ffs() equivalent for std::bitset? 15. Needless to say, this is much more powerful as it combines all of const_cast, static_cast and reinterpret_cast, but it's also unsafe, because it does not use dynamic_cast. CDerived s pD2 s static_cast (pV1); Is it legal to check whether the address of a subobject lies within the bounds of a containing object. I wrote about a different way of solving this problem: crash // pD2->bar(); ---------------------- There wont be any difference between the two, except for multi-inheritance. Misuse of the reinterpret_cast operator can easily be unsafe. ), the difference between static_cast and reinterpret_cast, Hands teach you how to configure and compile ogre 1.7.0 plus cegui 0.7.1, A comparison of several multithreaded 3D engine architectures, Research on spatial topology relationship judgment methods, http://blog.csdn.net/jiangdf/archive/2009/05/21/4205481.aspx. If your C++ code is using some C API then of course you don't have much choice. Remember in C++, parent class stuff (vtable and attributes) are putting upfront, followed by child class stuff. float* pf = &f; Incorrect cast - is it the cast or the use which is undefined behavior. boost, shared ptr Vs weak ptr? , . For your example, it is preferable to use a static_cast since you know the actual type of the derived object. 7. Of course, this problem only happens if you do more inheritance. not CBaseY x 11. CBaseY* pY2 = reinterpret_cast(pD); cast statements ? I will require us to replace all the occurrences of FOO with the call to that function, but that is positive for two reasons: Since we are in an embedded project, memory and performance are critical. system() fork/execvp. static const Member Value vs. Nishant Sivakumar, Casting Basics - Use C++ casts in your VC++.NET programs A class template that fulfills these requirements could look like this: std::intptr_t is an alias for some integer type that is large enough to hold a pointer value. const_cast means two things. Qt Plugin with OpenMP Support on MinGW: Undefined reference? Basically if you have a child class depending on two parent classes, the static_cast from child to parent will work correctly but not reintrepret_cast. https://kristerw.blogspot.se/2017/07/hard-coded-hardware-addresses-in-cc.html, Its almost as if warnings are useful sometimes , Your email address will not be published. Other uses are, at best, nonportable. Another point is that the constant pointers seem come in pairs relatively often: A unit8* that seems to be used for very low level reads and writes to memory, and a pointer to the same location that interprets the data as some object like the S above. }; { Why do both libstdc++ and libc++ not check for pointer and reference type D for the default unique_ptr constructor? Since the class holds this integer value and not a pointer value, it can be used as a constant expression. However . It is used for reinterpreting bit patterns and is extremely low level. 1. dynamic_cast<>, on the other hand, prevents a generic CBaseY? elasticsearch sink connector (kafka-connect). C-style callback interfaces can often be replaced with either a template function (for anything that resembles the standard function qsort) or a virtual interface (for anything that resembles a registered listener). Establish invariants and avoid zombie objects, Modern C++ Features - std::variant and std::visit, Modern C++ Features - Default Initializers for Member Variables, Modern C++ Features std::variant and std::visit, Trailing Return Types, East Const, and Code Style Consistency, std::string is not a Container for Raw Data. Looking at the code in question it would be something innocent like this: Both lines do not really look like there is a cast going on. static_cast is designed to reverse any implicit conversion. The C++ standard just doesn't guarantee you anything once you do it. What information does GCC Profile Guided Optimization (PGO) collect and which optimizations use it? }; At no point does any const get added or removed. from being converted to CDerived. 3. static_cast and memory layout difference | by Xianbo QIAN | Medium 500 Apologies, but something went wrong on our end. // System crash!! reinterpret_cast will never change the memory layout. union reinterpret_cast? You reinterpret cast one mutable pointer to another. Well, there is one obvious reason: because it wouldn't do everything that bit_cast does. What comes to mind is that the actual constant here is the address value, i.e. 'reinterpret_cast' is used to convert pointers to objects to integral values (and back), if there is a type that can hold the entire value; between pointers of different functions; between pointers and references of unrelated object types. 392fbc void s pV1 s 392fbc between Convert between CBaseX While we are at it, we can replace the C-cast with the proper C++ cast, which in this case is reinterpret_cast: Sadly, this wont compile, because reinterpret_casts are not allowed in constant expressions by the standard. Dipping my toes into a new project, I got a bunch of ugly warnings about a ton of C-casts inside a macro definition. Don't blame programmers for these mistakes! 4. static_cast<> CDerived?->CBaseY' -> CDerived?//Successful The C-style cast isn't better. It can cast integer and floating point types into each other. 3. printf("CDerived* pD2 = %x/n", (int)pD2); But really casts are a language smell. reinterpret_cast This is the trickiest to use. Same applies to downcasting. As shown in the figure, CDerived's memory layout consists of two objects, CBaseX and CBaseY, as the compiler knows. and CBaseY// CBaseX and CBaseY? In current C++, you can't use reinterpret_cast like in that code. It isn't clear what you're having difficulties with, but this clears it up for me: // Successful CBaseY* pY3 = new CBaseY(); 2. constexpr vs. static const: Which one to prefer? Therefore, I made the conversion to uint8* an explicit function. printf("CDerived* pD = %x/n", (int)pD); reinterpret_cast. void* pV1 = pY; Successful compilation, pV1 As far as I know, all current compilers allow to reinterpret_cast from void* and behave equivalent to the corresponding static_cast, even though it is not allowed in current C++03. the 0xBA50BAD, and the reinterpret_casts are only used in the runtime code. In the example above, the only way to return CDerived from a void is to convert it to CBaseY and then to CDerived. This wiki page has a good explanation. -O1 on ARM GCC). A C-style cast is basically identical to trying out a range of sequences of C++ casts, and taking the first C++ cast that works, without ever considering dynamic_cast. // Compiled successfully, although pY3 is just //Successful compilation, but the sn2 is meaningless memory (rubbish) // TODO: sign and unsigned integer numbers, float etc. Now this is not really a cast any more but just a way to tell the compiler to throw away type information and treat the data differently. Ref: With this in mind, the question is whether we could come up with a class that. 1. . a reinterpret_cast is a conversion operator. The const was there in the c-cast, obviously, Where exactly do you think a const cast was happening there? A reinterpret_cast is a cast that represents an unsafe conversion that might reinterpret the bits of one value as the bits of another value. The reason why using reinterpret_cast would be UB over there is e.g alignment questions (the buffer falls on an uneven address, first member is two-byte integral and the architecture requires that these are on even addresses, stuff like that) , or maybe pointer aliasing. CBaseY s pY3 s 390ff0 CDerived s pD3 s 390fec When to use which one? Similarly, casting an int to a void* is perfectly legal with reinterpret_cast, though it's unsafe. 6. printf("CBaseY* pY1 = %x/n", (int)pY1); CBaseY* pY = pD; Successful compilation, pY s pD s 4 , - . It only provides some information for the compiler to generate code. In that case it will read the value of p using p's type, and that value is then converted to a T*. public: class CBaseY - , ; , &a, . //Successful compilation, but the memory of the spn All rights reserved. 5. int x; With that assumption, nothing is being reinterpreted - void is an incomplete type, meaning that it has no values, so at no point are you interpreting either a stored int value "as void" or a stored "void value" as int. We could just write reinterpret_cast in the macros and live with the fact that we have ugly macros but silenced the warnings. In C++, is it safe/portable to use static member function pointer for C API callbacks? cmake: target_link_libraries use static library not shared, Returning unique_ptr