This is something that was de factor supported prior to C++11 and has now been specified in the standard. The second case is for using standard layout types. Similar conversions are allowed for function pointers and member function pointers, but in the latter case you can cast to/from another member function pointer simply to have a variable that is big enouhg. Conversion back to a different pointer type is of course undefined (sort of). You are allowed to convert a pointer to a suitably sized integer and then back to a pointer and it will be the exact same pointer. The first is to use opaque pointer types, either for a library API or just to store a variety of pointers in a single array (obviously along with their type). , and for these reasons the standard actually defines what happens. Note that value produced by reinterpret_cast is exactly the same as an address of 'c', while C-style cast resulted in a correctly offset pointer. that B is an unaccessible base of C, resulting pointer will pointĬout << "reinterpret_cast:\t" << b1 << "\n" Ĭout << "C-style cast:\t\t" << b2 << "\n" perform the conversion with a semantic of static_cast(&c), disregarding just type pun the pointer to c, pointer value will remain the same The C-style cast is somewhat similar in a sense that it can perform reinterpret_cast, but it also "tries" static_cast first and it can cast away cv qualification (while static_cast and reinterpret_cast can't) and perform conversions disregarding access control (see 5.4/4 in C++11 standard). So if you know what you do and how it all looks like on a low-level nothing can go wrong. It is intended to be unsurprising to those who know the addressing structure So it's really a very platform specific for conversions like: It is implementation defined in a sense that standard doesn't (almost) prescribe how different types values should look like on a bit level, how address space should be structured and so on. Int* p6 = reinterpret_cast(p2) // guaranteed that p6 = p0 Int* p5 = reinterpret_cast(p1) // guaranteed that p5 = p0 Int* p4 = (int*)p2 // guaranteed that p4 = p0 Int* p3 = (int*)p1 // guaranteed that p3 = p0 That part is guaranteed.īut again, remember that this is true whether you useįloat* p1 = (float*)p0 // implementation-defined resultįloat* p2 = reinterpret_cast(p0) // implementation-defined result , then you will get the original pointer. , then you have no guarantee that the resulting pointer will point to the same address. This means that when you use it to convert from, say, an To answer the other part of your question, yes, ) is much harder to find reliably by searching Is easy to find, which is good, because casts are ugly and should be paid attention to when used.
#Quickcast vs normal cast code
It's hard to find when reading or searching the code. It can do many different things, and it's not always clear from reading the code which type of cast will be invoked (it might behave like aĬonsequently, changing the surrounding code might change the behaviour of the cast It simply tries the various C++-style casts in order, until it finds one that works.
0 kommentar(er)
