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 ?

Answer 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);

Answer 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.]

Answer 3

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

Answer 4

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.

Answer 5

From an object to primitive -> Type conversion

String s = "1234";
int i = Integer.parseInt(s);
int j = Integer.valueOf(s);

From an primitive to object -> Type conversion

int i = 55;
String s = String.valueOf(i);
String t = Integer.toString(i);

From a primitive to primitive(or object to object) -> Type casting(explicit when narrowing and implicit when widening)

//explicit  
double d = 3.14156;
int i = (int)d; 
//implicit
int i = 100;
double d = i;

Note: In case of object type casting, we cannot use child class reference to hold parent object

Answer 6

According to the Wikipedia article:

"In the C family of languages, the word cast typically refers to an explicit type conversion (as opposed to an implicit conversion), regardless of whether this is a re-interpretaion of a bit-pattern or a real conversion."

Here is a C++ example:

double d = 42.0;
int i = d; // Here you have an implicit conversion from double to int
int j = static_cast<int>(d); // Here you have a cast (explicit conversion).

Here is a Java example (note that in Java unlike C++ you can't implicitly convert from double to int):

int i = 42;
double d = i; // Here you have an implicit conversion from int to double
int j = (int)d; // Here you have a cast (explicit conversion).