Newb float casting question

[lamthierry]

Are the following two similar?

float a = 1.0f;

float a = static_cast<float>(1.0);

If they are, which one is preferrable?

Thanks
Thierry

[Victor Bazarov]

la********@gmail.com wrote:

Are the following two similar?

float a = 1.0f;

float a = static_cast<float>(1.0);

If they are, which one is preferrable?

Yes, they are, AFAIUI.

I prefer the first, it's so much less to type or to read/comprehend.

If given a choice I'd even shorten it to

float a = 1;

Although it's basically the same as

float a(1);

, I still find the form with '=' easier on my eyes/brain.

V

[Ali Çehreli]

<la********@gmail.com> wrote in message
news:11*********************@g14g2000cwa.googlegro ups.com...

Are the following two similar?

float a = 1.0f;
That one initializes 'a' with a value having the exact type.
float a = static_cast<float>(1.0);
That one uses a double, converts it to a float, then uses the result to
initialize a.
If they are, which one is preferrable?

The compiler would probably generate equivalent code for both, but I would
prefer the first one, because it is exactly what is intended, and the second
one is as strange as this:

float a = 2.0f / 2; // why? :)

Ali

[Andrew Koenig]

"Victor Bazarov" <v.********@comAcast.net> wrote in message
news:NO*******************@newsread1.mlpsca01.us.t o.verio.net...

la********@gmail.com wrote:

float a = 1.0f; float a = static_cast<float>(1.0); If they are, which one is preferrable?

Yes, they are, AFAIUI. I prefer the first, it's so much less to type or to read/comprehend.

There is a much more subtle (additional) argument in favor of the first one.

The literal 1.0 has type double. So if you write

float a = static_cast<float>(1.0);

or, equivalently,

float a = 1.0;

you are taking the exact decimal value 1.0, converting it to double (with
implied rounding), and then converting it to float (with a second implied
rounding).

If you write

float a = 1.0f;

you are taking the exact decimal value 1.0 and converting it directly to
float, with only one rounding operation.

Rounding once is never less accurate than rounding twice, and might be more
accurate.

[John Carson]

"Andrew Koenig" <ar*@acm.org> wrote in message
news:ci*******************@bgtnsc04-news.ops.worldnet.att.net

There is a much more subtle (additional) argument in favor of the
first one.
The literal 1.0 has type double. So if you write

float a = static_cast<float>(1.0);

or, equivalently,

float a = 1.0;

you are taking the exact decimal value 1.0, converting it to double
(with implied rounding), and then converting it to float (with a
second implied rounding).

If you write

float a = 1.0f;

you are taking the exact decimal value 1.0 and converting it directly
to float, with only one rounding operation.

Rounding once is never less accurate than rounding twice, and might
be more accurate.

My understanding is that there is no rounding needed for 1.0 (or for any
integer that involves less than the number of significant digits that a
floating point size supports). Is my understanding flawed, or are you really
making a point about numbers like, say, 1.2 which involve real rounding?

--
John Carson

[Andrew Koenig]

"John Carson" <jc****************@netspace.net.au> wrote in message
news:dg***********@otis.netspace.net.au...

My understanding is that there is no rounding needed for 1.0 (or for any
integer that involves less than the number of significant digits that a
floating point size supports). Is my understanding flawed, or are you
really
making a point about numbers like, say, 1.2 which involve real rounding?

I am really making a point about numbers such as 1.2, which involve real
rounding.