static-cast

Just a few hours ago, the following question came up: Variable cannot appear in a constant-expression Luckily for the OP, the answer provided did solve his problem, but I cannot reproduce the solution. I've attempted to simplify the code even more and I am now stuck with the following: #include <bitset> int main () { const size_t length_1 = static_cast<const size_t>(1.0f); std::bitset<length_1> bits_1; const size_t length_2 = static_cast<const size_t>(1.0f / 1.0f); std::bitset<length_2> bits_2; } If compiled with -pedantic , the first example is accepted by the compiler, but the one with a

Prerequisities: To understand this question, please, read the following question and its answer at first: Cast auto_ptr<Base> to auto_ptr<Derived> At Cast auto_ptr<Base> to auto_ptr<Derived> Steve answered that "Your static_cast would copy the auto_ptr to a temporary, and so aS would be reset and the resource would be destroyed when the temporary is (at the end of the statement)." I'm interested in the process of temporary creation while static_cast is called. I would like to have the code that I can trace in order to see this effect. I cannot use static_cast<auto_ptr<Circle>> ... because it

Consider the following class, just as a simple example: #include <iostream> #include <string> using namespace std; class point { public: int _x{ 0 }; int _y{ 0 }; point() {} point(int x, int y) : _x{ x }, _y{ y } {} operator string() const { return '[' + to_string(_x) + ',' + to_string(_y) + ']'; } friend ostream& operator<<(ostream& os, const point& p) { // Which one? Why? os << static_cast<string>(p); // Option 1 os << p.operator string(); // Option 2 return os; } }; Should one call a conversion operator directly, or rather just call static_cast and let that do the job? Those two lines will

I need to take 2 unsigned 8-bit values and subtract them, then add this value to a 32-bit accumulator. The 8-bit subtraction may underflow, and that's ok (unsigned int underflow is defined behavior, so no problems there). I would expect that static_cast<uint32_t>(foo - bar) should do what I want (where foo and bar are both uint8_t ). But it would appear that this casts them first and then performs a 32-bit subtraction, whereas I need it to underflow as an 8-bit variable. I know I could just mod 256, but I'm trying to figure out why it works this way. Example here: https://ideone.com/TwOmTO

I have a plain old CRPT (please don't get distracted by access restrictions - the question is not about them): template<class Derived> class Base { void MethodToOverride() { // generic stuff here } void ProblematicMethod() { static_cast<Derived*>(this)->MethodToOverride(); } }; that is as usual intended to be used like this: class ConcreteDerived : public Base<ConcreteDerived> { void MethodToOverride() { //custom stuff here, then maybe Base::MethodToOverride(); } }; Now that static_cast bothers me. I need a downcast (not an upcast), so I have to use an explicit cast. In all reasonable cases

I have a const pointer to a pointer to a Fred and I don't understand why a static_cast isn't sufficient. typedef struct { int n; } Fred; Fred *pFred; Fred **const ppFred = &pFred; void **const ppVoid = static_cast<void ** const>(ppFred); Please could someone explain why a reinterpret_cast is needed to convert a pointer to Fred* to a pointer to void* but static_cast is fine to convert pointer to Fred to a pointer to void . There's no requirement that a Fred* and a void* have the same size and representation. (I've worked on machines where they didn't, although that was before my C++ days.) When