What is the difference between type casting and type conversion in C++ or Java?

Question

What is the difference between typecasting and typeconversion in C++ or Java ?

Solution 1

Type casting is treating a value (block of memory) referenced by a variable as being of a different type than the type the variable is declared as.

Type conversion is actually performing a conversion of that value.

In many languages, some casts (usually numeric ones) do result in conversions (this will vary quite a bit by language), but mostly it's just "treat this X as a Y".

Like most aspects of human language, unfortunately the terms are used slightly differently in different communities, mostly along language lines. For instance, see James' comment below about C++ — the word "cast" there has a much broader meaning than the above definition, which is more in the C or Java mold. And just to make things fun, the Java Language Spec actually gets into various kinds of casts, including casting conversions. But the above is a good rule of thumb.

But to take a simple case:

In Java, prior to generics it wasn't unusual to have to do a lot of typecasting when dealing with maps:

Map m = new HashMap();
m.put("one", "uno");

// This would give a compiler error, because although we know
// we'll get a String back, all the compiler knows is that it's
// an Object
String italian = m.get("one");

// This works, we're telling the compiler "trust me, it's a String"
String italian = (String)m.get("one");

Fortunately, the addition of generics addressed this, as casting in this way tends to be a fragile process with maintenance issues.

In contrast, you'd convert if you had a String of digits:

String s = "1234";

...and needed to know what number those digits represented in decimal:

// Wrong (cast)
int n = (int)s;

// Right (conversion)
int n = Integer.parseInt(s, 10);

Solution 2

Maybe an example can help:

• If you cast 33 to a string, you get "!".
• If you convert 33 to a string, you get "33".

[Note: this example makes all sorts of not-necessarily-valid assumptions about the encodings and in-memory representations of numbers and strings, but I hope the mechanism is clear.]

Solution 3

Typecasting is just taking a pen and writing "this is now a int" on the variable, conversion is actually convert the content to the desired type so the value keeps having a sense.

Solution 4

Type conversion:

double value = 3; // implicit conversion to double value 3.0
int nValue = 3.14156; // implicit conversion to integer value 3

Casting is a request by the programmer to do an explicit type conversion.

int nValue = 10;
double dvalue = double(nValue); // explicit type casting

Solution 5

The terms are often used interchangeably.

Java

Type casting and type conversion are the same thing in Java, though if someone says that they are casting, they are usually referring to an explicit conversion.

A cast in Java will be done at runtime, so can potentially fail (throw an exception). Some types of invalid casts can be caught at compile time. When the cast fails, the instance was seated in an object reference, so the compiler couldn't tell what cast was going to be performed, until it actually ran the code.

C++

Type casting and type conversion are different in C++. There are five types of casts in C++, which all have different behavior: static_cast, dynamic_cast, reinterpret_cast, const_cast, and c-style casts ((int)someVariable).

Some C++ casts perform type conversion (hence why this concept is confusing), calling code and potentially doing runtime checks. Other C++ casts simply fake the type change of the referring variable - no memory will be modified, moved, or copied, so the resulting datatype might not be properly converted. This can give great speed at runtime, and can be a powerful tool for low-level code, but tends to be avoided for high level code.

Note that the c-style cast syntax (which happens to look exactly like the Java syntax) is one of the casts that will not necessarily call conversion code.

Type conversion in C++ often refers to calling a copy constructor or assignment operator, which will copy data over to a new instance of a different class/structure. If a type has conversion operators defined, then the conversion syntax could look like a cast, or simply a straight assignment. The main difference here is that code is called to do the conversion.

View more solutions

Comments

[Jagan]

Could you please provide me examples for both typecasting and typeconversion ?

[T.J. Crowder]

@Jagan: Curiously enough, I was just doing that. :-)

[James McNellis]

At least in C++, use of the term cast is not so limited; there are several (four) types of casts. Reinterpretation is only one of them and is the least commonly used of them.

[Merlyn Morgan-Graham]

@James: "Least commonly used" in well designed high level code, at least.

[T.J. Crowder]

@James: That's part of why I said "In many languages, some casts (usually numeric ones) do result in conversions (this will vary quite a bit by language)..." C++ has gone its own way a bit in terminology (IMV). Not being a C++ guru (at all), I stuck to the Java side of things. :-)

[James McNellis]

@Merlyn: Yes, and I should have said "one of," since const casting should also be done sparingly.

[Aoi Karasu]

''Type conversion is actually performing a conversion'' - LOL nice one ;)

[Insignificant Person]

best answer i've seen so far in any community about this topic :)