You receive the "Cannot implicitly convert type <type> to <type>" error message when you compile your code (304696)

CAUSE

Conversions must occur when you assign a variable of one type to a variable of a different type. When you make an assignment between variables of different types, the compiler must convert the type on the right side of the assignment operator to the type on the left side of the assignment operator. For example, consider the following the code:

int i = 50;
long lng = 100;
i = lng;
				

Notice that the last statement is making an assignment, but the data types of the variables on the left and right sides of the assignment operator don't match. Before making the assignment, the compiler is implicitly converting the variable "lng", which is of type long, to type int. This is called implicit because the code does not explicitly tell the compiler to perform this conversion. The compiler is doing it automatically. The problem with this code is that this is considered a "narrowing" conversion, and implicit narrowing conversions are not allowed by the compiler. They are not allowed because a loss of data may result.

Narrowing vs. Widening Conversions

Let's take a moment to define what we mean by narrowing and widening conversions and why there is a potential loss of data.

• A narrowing conversion exists when you convert a data type to another data type that occupies less storage space in memory. For example, converting a long to an int would be considered a narrowing conversion. A long occupies 8 bytes of memory while an int occupies 4 bytes of memory. The code provided earlier is an example of a narrowing conversion. How could data loss occur in this situation? For example, consider the following code:

  int i = 50;
  long lng = 3147483647;
  i = lng;
  						

  Notice that compared to the previous sample, the value being assigned to our long data type is changed. The variable lng now contains a value that cannot be stored in the variable i because it is too large. If you were to convert this value to an int type, you would lose some data and the converted value would not be the same as the value before the conversion. The compiler error is a way of warning you of that loss.
• A widening conversion would be the opposite of a narrowing conversion. With widening conversions, you are converting to a data type that occupies more storage space in memory than the data type that you are converting from. Here is an example of a widening conversion:

  int i = 50;
  long lng = 100;
  lng = i;
  						

  Notice the difference between this code sample and the first. This time the variable lng is on the left side of the assignment operator, so it is the target of our assignment. Before the assignment can be made the compiler must implicitly convert the variable i, which is of type int, to type long. This is a widening conversion because we are converting from a type that occupies 4 bytes of memory (an int) to a type that occupies 8 bytes of memory (a long). Implicit widening conversions are allowed because there is no potential loss of data. Any value that can be stored in an int can also be stored in a long.

int i = 50;
long lng = 3147483647;
i = (int) lng;