• ### Announcements

#### Archived

This topic is now archived and is closed to further replies.

# Alright you C++ gurus :P

## Recommended Posts

Snyper    122
This has been bugging me for a long time now. Is there a difference between these two ways of casting?
  static_cast(something); OR (int)something; 
This C++ tutorial that comes w/ VC++ 6.0 says the first way is better, yet they dont say why. Theres also the dynamic_cast and reinterpret_cast, of course, also. I know what these "new?" casts do but i dont see any differeneces in my programs between the two. -Snyper Edited by - Snyper on 10/5/00 5:18:42 PM

##### Share on other sites
Esap1    122
well, I know that:
(int)some_type
and:
int(some_type)

Is the same thing, but to tell u tha truth, Ive never seen the first one u put, Any one know?, now Im curious,

##### Share on other sites
farmersckn    122
--From wrox press c++ tutorial by ivor horton:
With mixed expressions involving the basic types, your compiler automatically arranges casting where necessary, but you can also force a conversion from one type to another by using an explicit cast. To cast the value of an expression to a given type, you write the cast in the form:

static_cast<the_type_to_convert_to>(expression)

The keyword static_cast reflects the fact that the cast is checked statically - that is, when your program is compiled. Later, when we get to deal with classes, we will meet dynamic casts, where the conversion is checked dynamically - that is, when the program is executing. The effect of the cast is to convert the value that results from evaluating expression to the type that you specify between the angled brackets. The expression can be anything from a single variable to a complex expression involving lots of nested parentheses.

A dynamic cast is a cast that is performed at runtime. To specify a dynamic cast, you use the dynamic_cast<>() operator. You can only apply the dynamic_cast<>() operator to pointers and references to polymorphic class types - that is class types that contain at least one virtual function. The reason is that only pointers to polymorphic class types contain the information that the dynamic_cast<>() operator needs to check the validity of the cast. The dynamic_cast<>() operator is specifically for converting between pointers or between references to class types in a hierarchy. Note that the types you are casting between must be pointers or references to classes within the same class hierarchy (though not necessarily in a single leg of a hierarchy). You can''t use dynamic_cast<>() for anything else. We will look at dynamically casting pointers first.

two others:
reinterpret_cast<>() - this handles casts between unrelated types, for example, an integer to a pointer

const_cast<>() - this removes the const qualifier

##### Share on other sites
TomH    258
My take on the 'C' style casting vs static_cast is as follows.

'C' style casting i.e. 'i = (int)j' will always compile without error the compiler doing the best it can to convert the data. This may result in platform depended ( non-portable ) results.

Static casting i.e. 'i = static_cast<int>j' will only compile if the cast is reasonable ( The compiler knows how to perform the required conversion )

I guess MS recommend static_casts over 'C' casts as most non-portable casts are probable bugs/ typing errors ( i.e. missing * )

NB: C++ provides reinterpret_cast<> as a mechanism for performing non-portable casts.

  //// casts.cpp : checks which casts are valid//class C1{ int i; };class C2{ float f; };class C3 : public C2{ long l; };int main(int argc, char* argv[]){ int i1 = 1, i2 = 2; float f1, f2; char c1, c2; char *pc1, *pc2; C1 foobar1, foobar2; C2 *pfoo1, *pfoo2; C3 junk; f1 = (float)i1; c1 = (char)f1; pc1 = (char*)c1; pfoo1 = (C2*)&foobar2; f2 = static_cast(i2); c2 = static_cast(f2); // Line produces an error pc2 = static_cast(c2); // Line produces an error pfoo1 = static_cast(&foobar2); pfoo1 = static_cast(&junk); return 0;}

Edited by - TomH on October 6, 2000 8:29:19 AM

Edited by - TomH on October 6, 2000 8:30:39 AM

##### Share on other sites
mossmoss    326
The new C++-style casts are potentially safer; three of them are restricted in use (static, dynamic, const) while the reinterpret_cast is no worse than a C-style cast.

Another benefit of the new style casts: they're damn easy to find in source code. Set search to "cast".

---- --- -- -