Yes there is a very important difference: std::move documents what you want to do. In addition the cast is prone to writing errors like a forgotten & or wrong type X. As it can be seen, std::move is even less to type.
The main reason is that classic C casts make no distinction between what we call static_cast<>(), reinterpret_cast<>(), const_cast<>(), and dynamic_cast<>(). These four things are completely different. A static_cast<>() is usually safe. There is a valid conversion in the language, or an appropriate constructor that makes it possible. The only time it’s a bit risky is … Read more
This is a little complicated… Remember that qobject_cast<T>(obj) is a way to dynamically cast a QObject to the target type T which also derives from QObject. Now, for this to work, the macro Q_OBJECT should be included in the definition of class T. Apparently, the qt_check_for_QOBJECT_macro call is for checking that the class really contains … Read more
There are things that reinterpret_cast can do that no sequence of static_casts can do (all from C++03 5.2.10): A pointer can be explicitly converted to any integral type large enough to hold it. A value of integral type or enumeration type can be explicitly converted to a pointer. A pointer to a function can be … Read more
Use static_cast: it is the narrowest cast that exactly describes what conversion is made here. There’s a misconception that using reinterpret_cast would be a better match because it means “completely ignore type safety and just cast from A to B”. However, this doesn’t actually describe the effect of a reinterpret_cast. Rather, reinterpret_cast has a number of … Read more
[*] The technical problem is that there’s no way to work out from a Base* what the offset is between the start of the Base sub-object and the start of the Derived object. In your example it appears OK, because there’s only one class in sight with a Base base, and so it appears irrelevant … Read more
They are completely different types see standard: 3.9.1 Fundamental types [basic.fundamental] 1 Objects declared as characters char) shall be large enough to store any member of the implementation’s basic character set. If a character from this set is stored in a character object, the integral value of that character object is equal to the value … Read more
For convertible pointers to fundamental types both casts have the same meaning; so you are correct that static_cast is okay. When converting between some pointer types, it’s possible that the specific memory address held in the pointer needs to change. That’s where the two casts differ. static_cast will make the appropriate adjustment. reinterpret_cast will not. … Read more
In order to understand the cast system, you need to dive into the object model. The classic representation of a simple hierarchy model is containment: if B derives from A then the B object will, in fact, contain an A subobject alongside its own attributes. With this model downcasting is a simple pointer manipulation by … Read more
Use boost::static_pointer_cast: boost::shared_ptr<Base> b(new Derived()); boost::shared_ptr<Derived> d = boost::static_pointer_cast<Derived>(b);