Answer 1:
Passing by const reference to a non-inline function may lose performance, because the piece of data needs to live on the stack (so that a pointer/reference can be generated). If the function is inline (such as most templates) then the compiler has enough information to optimize the passing to actually be by value -- although whether it chooses to do that may vary based on the compiler and specific compiler flags. If you know it's only for ints, floats, doubles and the like, then pass by value.
Answer 2:
In the case of a downcast, C-style casts will perform a static_cast<> when the base type is known, but a reinterpret_cast<> when the base type is not known, without telling you about it. static_cast<> will tell you (using an error) if you're trying to do a downcast without knowing the derived type definition.
class Junk { public: int j; virtual void junkFunc() = 0; }; class Base { public: virtual void someBaseFunction() = 0; }; class Derived; // forward declared Base * b; Derived * d = (Derived *)b; // will not warn you about the reinterpret-cast; will blow up on use Derived * d = static_cast< Derived * >( b ); // will tell you about the problem class Derived : public Junk, public Base { public: }; Derived * d = (Derived *)b; // will do the right cast Derived * d = static_cast< Derived * >( b ); // will do the right cast
C-style casts are fine for POD types, but when you're involving types that may have inheritance, you're better off with static_cast<> (which is almost always the behavior you actually want).
