Why use static cast int x instead of int x

Question

I ve heard that the static cast function should be preferred to C-style or simple function-style casting   Is this true   Why

User · Answer

static cast  aside from manipulating pointers to classes  can also be used to perform conversions explicitly defined in classes  as well as to perform standard conversions between fundamental types   double d   3 14159265  int    i   static cast lt int gt  d

User · Answer

It s about how much type-safety you want to impose   When you write  bar  foo  which is equivalent to reinterpret cast lt bar gt  foo if you haven t provided a type conversion operator  you are telling the compiler to ignore type safety  and just do as it s told   When you write static cast lt bar gt  foo you are asking the compiler to at least check that the type conversion makes sense and  for integral types  to insert some conversion code     EDIT 2014-02-26  I wrote this answer more than 5 years ago  and I got it wrong   See comments   But it still gets upvotes

User · Answer

The question is bigger than just using wither static cast or C style casting because there are different things that happen when using C style casts   The C   casting operators are intended to make these operations more explicit   On the surface static cast and C style casts appear to the same thing  for example when casting one value to another   int i  double d    double i                     C-style cast double d2   static cast lt double gt   i       C   cast   Both of these cast the integer value to a double   However when working with pointers things get more complicated   some examples   class A     class B   public A      A  a   new B  B  b    B  a                                      1  what is this supposed to do   char  c    char  new int  5                       2  that weird  char  c1   static cast lt char  gt   new int  5         3  compile time error   In this example  1  maybe OK because the object pointed to by A is really an instance of B   But what if you don t know at that point in code what a actually points to    2  maybe perfectly legal you only want to look at one byte of the integer   but it could also be a mistake in which case an error would be nice  like  3    The C   casting operators are intended to expose these issues in the code by providing compile-time or run-time errors when possible   So  for strict  value casting  you can use static cast   If you want run-time polymorphic casting of pointers use dynamic cast   If you really want to forget about types  you can use reintrepret cast   And to just throw const out the window there is const cast   They just make the code more explicit so that it looks like you know what you were doing

User · Answer

One pragmatic tip  you can search easily for the static cast keyword in your source code if you plan to tidy up the project

User · Answer

In short          static cast lt  gt    gives you a compile time checking ability  C-Style   cast doesn t    static cast lt  gt    can be spotted easily   anywhere inside a C   source code  in contrast  C Style cast is harder to spot    Intentions are conveyed much better using C   casts          More Explanation       The static cast performs conversions between compatible types  It   is similar to the C-style cast  but is more restrictive  For example    the C-style cast would allow an integer pointer to point to a char   char c   10           1 byte int  p    int   amp c     4 bytes       Since this results in a 4-byte pointer pointing to 1 byte of allocated   memory  writing to this pointer will either cause a run-time error or   will overwrite some adjacent memory    p   5     run-time error  stack corruption       In contrast to the C-style cast  the static cast will allow the   compiler to check that the pointer and pointee data types are   compatible  which allows the programmer to catch this incorrect   pointer assignment during compilation   int  q   static cast lt int  gt   amp c      compile-time error    Read more on  What is the difference between static cast lt   and C style casting  and Regular cast vs  static cast vs  dynamic cast

User · Answer

static cast means that you can t accidentally const cast or reinterpret cast  which is a good thing

User · Answer

The main reason is that classic C casts make no distinction between what we call static cast lt  gt     reinterpret cast lt  gt     const cast lt  gt     and dynamic cast lt  gt     These four things are completely different   A static cast lt  gt    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 when you cast down to an inherited class  you must make sure that the object is actually the descendant that you claim it is  by means external to the language  like a flag in the object   A dynamic cast lt  gt    is safe as long as the result is checked  pointer  or a possible exception is taken into account  reference     A reinterpret cast lt  gt     or a const cast lt  gt     on the other hand is always dangerous  You tell the compiler   trust me  I know this doesn t look like a foo  this looks as if it isn t mutable   but it is     The first problem is that it s almost impossible to tell which one will occur in a C-style cast without looking at large and disperse pieces of code and knowing all the rules   Let s assume these   class CDerivedClass   public CMyBase        class CMyOtherStuff          CMyBase   pSomething     filled somewhere   Now  these two are compiled the same way   CDerivedClass  pMyObject  pMyObject   static cast lt CDerivedClass  gt  pSomething      Safe  as long as we checked  pMyObject    CDerivedClass   pSomething      Same as static cast lt  gt                                          Safe  as long as we checked                                         but harder to read   However  let s see this almost identical code   CMyOtherStuff  pOther  pOther   static cast lt CMyOtherStuff  gt  pSomething      Compiler error  Can t convert  pOther    CMyOtherStuff   pSomething                 No compiler error                                                       Same as reinterpret cast lt  gt                                                       and it s wrong      As you can see  there is no easy way to distinguish between the two situations without knowing a lot about all the classes involved   The second problem is that the C-style casts are too hard to locate  In complex expressions it can be very hard to see C-style casts  It is virtually impossible to write an automated tool that needs to locate C-style casts  for example a search tool  without a full blown C   compiler front-end  On the other hand  it s easy to search for  static cast lt   or  reinterpret cast lt     pOther   reinterpret cast lt CMyOtherStuff  gt  pSomething            No compiler error           but the presence of a reinterpret cast lt  gt  is           like a Siren with Red Flashing Lights in your code           The mere typing of it should cause you to feel VERY uncomfortable    That means that  not only are C-style casts more dangerous  but it s a lot harder to find them all to make sure that they are correct

User · Answer

C Style casts are easy to miss in a block of code  C   style casts are not only better practice  they offer a much greater degree of flexibility   reinterpret cast allows integral to pointer type conversions  however can be unsafe if misused   static cast offers good conversion for numeric types e g  from as enums to ints or ints to floats or any data types you are confident of type  It does not perform any run time checks   dynamic cast on the other hand will perform these checks flagging any ambiguous assignments or conversions  It only works on pointers and references and incurs an overhead   There are a couple of others but these are the main ones you will come across

User · Answer

Allows casts to be found easily in your code using grep or similar tools   Makes it explicit what kind     of cast you are doing  and engaging     the compiler s help in enforcing it      If you only want to cast away     const-ness  then you can use     const cast  which will not allow you     to do other types of conversions  Casts are inherently ugly -- you as         a programmer are overruling how the         compiler would ordinarily treat your         code   You are saying to the         compiler   I know better than you           That being the case  it makes sense         that performing a cast should be a         moderately painful thing to do  and         that they should stick out in your         code  since they are a likely source         of problems    See Effective C   Introduction

[c++] Why use static_cast<int>(x) instead of (int)x?

Examples related to c++

Examples related to casting

Examples related to static-cast