Moving to static_cast and reinterpret_cas t from old C-style cast

[Kobe]

Hi,

if I need to convert a size_t to an int, in "older" C++ I'd write the
following code (using C-like "casting"):

<CODE>
std::vector<... > v;
int count = (int) v.size();
// v.size() returns size_t
</CODE>

Now that modern C++ has different cast tools, how the above code should
be changed? Should I use static_cast or reinterpret_cas t ?

e.g.

int count = static_cast<int >(v.size());

Moreover, sometimes I need to convert 32 bits unsigned ints (typedef
unsigned int DWORD) into pointers.

e.g.

<CODE>
// Old style C casting
DWORD address;
// address = ...
AClass * myObject = (AClass *)address;
</CODE>

Should I use static_cast or reinterpret_cas t in this case?

Thanks in advance,
K

[Victor Bazarov]

Kobe wrote:

if I need to convert a size_t to an int, in "older" C++ I'd write the
following code (using C-like "casting"):

<CODE>
std::vector<... > v;
int count = (int) v.size();
// v.size() returns size_t
</CODE>

Now that modern C++ has different cast tools, how the above code should
be changed? Should I use static_cast or reinterpret_cas t ?

e.g.

int count = static_cast<int >(v.size());
That should suffice. Beware, though, that if the value of 'v.size()'
cannot be represented in an int, the behaviour is implementation-
defined, and you may end up with a negative 'count'. Do you really need
'count' to be 'int'?
Moreover, sometimes I need to convert 32 bits unsigned ints (typedef
unsigned int DWORD) into pointers.
Are you sure they will fit?
e.g.

<CODE>
// Old style C casting
DWORD address;
// address = ...
AClass * myObject = (AClass *)address;
</CODE>

Should I use static_cast or reinterpret_cas t in this case?

Only 'reinterpret_ca st' will do.

V
--
Please remove capital As from my address when replying by mail

[Ben Pope]

Kobe wrote:

Hi,

if I need to convert a size_t to an int, in "older" C++ I'd write the
following code (using C-like "casting"):

<CODE>
std::vector<... > v;
int count = (int) v.size();
// v.size() returns size_t
</CODE>

Now that modern C++ has different cast tools, how the above code should
be changed? Should I use static_cast or reinterpret_cas t ?

e.g.

int count = static_cast<int >(v.size());
That should work with the obvious limitation.

What's wring with:
typedef std::vector<... > myContainer;
myContainer v;
myContainer::si ze_type count = v.size();
Moreover, sometimes I need to convert 32 bits unsigned ints (typedef
unsigned int DWORD) into pointers.
<shudder/>
<CODE>
// Old style C casting
DWORD address;
// address = ...
AClass * myObject = (AClass *)address;
</CODE>

Should I use static_cast or reinterpret_cas t in this case?

reinterpret_cas t is the tool for the job.

Preferably, don't, of course.

Ben Pope
--
I'm not just a number. To many, I'm known as a string...

[Tomás]

Kobe posted:

Hi,

if I need to convert a size_t to an int, in "older" C++ I'd write the
following code (using C-like "casting"):

<CODE>
std::vector<... > v;
int count = (int) v.size();
// v.size() returns size_t
</CODE>

Now that modern C++ has different cast tools, how the above code should
be changed? Should I use static_cast or reinterpret_cas t ?

e.g.

int count = static_cast<int >(v.size());

Moreover, sometimes I need to convert 32 bits unsigned ints (typedef
unsigned int DWORD) into pointers.

e.g.

<CODE>
// Old style C casting
DWORD address;
// address = ...
AClass * myObject = (AClass *)address;
</CODE>

Should I use static_cast or reinterpret_cas t in this case?

Thanks in advance,
K

Here's what I'd do:

Where ever you have a C-style cast, replace it with "static_cas t".

Then recompile it.

If "static_cas t" causes any errors, then change the ones that cause
errors to "reinterpret_ca st".

Basically, "reinterpret_ca st" can do everything thing that "static_cas t"
does, and more.

-Tomás