CODEWITHSUNDEEP
c++c
user3316811
user3316811

Reputation:

Type conversion vs type disambiguation

Casts are used for both type conversion and disambiguation. In further research I found these two as examples :

(double) 3;   // conversion
(double) 3.0; // disambiguation

Can someone explain the difference, I don't see any. Is this distinction, also valid in C++

EDIT

Originally the code snippet was like so:

(float) 3;   // conversion
(float) 3.0; // disambiguation

But changed it to double because floating point literals are no longer float in modern compilers and the question had no meaning. I hope I interpreted the comments correctly and I appologize for any answer already posted that became irrelevant after the edit.

Upvotes: 0

Views: 150

Answers (2)

Alexis Wilke
Alexis Wilke

Reputation: 20731

This is similar to many things asked of programmers in any language. I will give a first example, which is different from what you are asking, but should illustrate better why this would appear wherever you've seen it.

Say I define a constant variable:

static const a = 5;

Now, what is 'a'? Let's try again...

static const max_number_of_buttons = 5;

This is explicit variable naming. It is much longer, and in the long run it is likely to save your ass. In C++ you have another potential problem in that regard: naming of member variables, versus local and parameter variables. All 3 should make use of a different scheme so when you read your C++ function you know exactly what it is doing. There is a small function which tells you nothing about the variables:

void func(char a)
{
    char b;
    b = a;
    p = b * 3;
    g = a - 7;
}

Using proper naming conventions and you would know whether p and g are local variables, parameters to the function, variable members, or global variables. (This function is very small so you have an idea, imagine a function of 1,000 lines of code [I've seen those], after a couple pages, you have no idea what's what and often you will shadow variables in ways that are really hard to debug...)

void func(char a)
{
    char b;
    b = a;
    g_p = b * 3;
    f_g = a - 7;
}

My personal convention is to add g_ for global variables and f_ for variable members. At this point I do not distinguish local and parameter variables... although you could write p_a instead of just a for the parameter and now you know for all the different types of variables.

Okay, so that makes sense in regard for disambiguation of variable names, although in your case you specifically are asking about types. Let's see...

Ada is known for its very strong typing of variables. For example:

type a is 1 .. 100;
type b is 1 .. 100;

A: a;
B: b;

A := 5;
B := A;

The last line does NOT compile. Even though type a and type b look alike, the compiler view them both as different numeric types. In other words, it is quite explicit. To make it work in Ada, you have to cast A as follow:

B := B'(A);

The same in C/C++, you declare two types and variables:

typedef int a;
typedef int b;

a A;
b B;

A = 5;
B = A;

That works as is in C/C++ because type a and type b are considered to be exactly the same (int, even though you gave them names a and b). It is dearly NOT explicit. So writing something like:

A = (b) 5;

would explicitly tell you that you view that 5 as of type b and convert it (implicitly) to type a in the assignment. You could also write it in this way to be fully explicit:

A = a(b(5));

Most C/C++ programmers will tell you that this is silly, which is why we have so many bugs in our software, unfortunately. Ada protects you against mixing carrots and bananas because even if both are defined as integers they both are different types.

Now there is a way to palliate to that problem in C/C++, albeit pretty much never used, you can make use of a class for each object, including numbers. Then you'd have a specific type for each different type (because variables of class A and class B cannot just be mixed together, at least not unless you allow it by adding functions for the purpose.) Very frankly, even I do not do that because it would be way too much work to write any C program of any length...

So as Juri said: 3.0 and (double) 3.0 are exactly the same thing and the (double) casting is redundant (a pleonasm, as in you say the same thing twice). Yet, it may help the guy who comes behind you see that you really meant for that number to be a double and not whatever the language says it could eventually be.

Upvotes: 0

Juri Robl
Juri Robl

Reputation: 5746

The (double) 3 is a conversion from an Integer (int) to a floting point number (double).

The cast in (double) 3.0 is useless, it doesn't do anything since it's already double.

An unsuffixed floating constant has type double.

(ANSI C Standard, §3.1.3.1 Floating constants)

This answer is valid for C, it should be the same in C++.

Upvotes: 2

Related Questions