Typically you decide which size integer to use (short , int, or long ) based on the magnitude of the value you want to store. For example, a ushort can only hold values from 0 through 65,535, while a ulong can hold values from 0 through 4,294,967,295.

That said, memory is fairly cheap, and programmer time is increasingly expensive; most of the time you’ll simply declare your variables to be of type int, unless there is a good reason to do otherwise.

The signed types are the numeric types of choice of most programmers unless they have a good reason to use an unsigned value.

Although you might be tempted to use an unsigned short to double the positive values of a signed short (moving the maximum positive value from 32,767 up to 65,535), it is easier and preferable to use a signed integer (with a maximum value of 2,147,483,647).

It is better to use an unsigned variable when the fact that the value must be positive is an inherent characteristic of the data. For example, if you had a variable to hold a person’s age, you would use an unsigned int because an age cannot be negative.

Float, double, and decimal offer varying degrees of size and precision. For most small fractional numbers, float is fine. Note that the compiler assumes that any number with a decimal point is a double unless you tell it otherwise. To assign a literal float, follow the number with the letter f. (Assigning values to literals is discussed in detail later in this chapter.)

float someFloat = 57f;

The char type represents a Unicode character. char literals can be simple, Unicode, or escape characters enclosed by single quote marks. For example, A is a simple character while u0041 is a Unicode character. Escape characters are special two-character tokens in which the first character is a backslash. For example, is a horizontal tab. The common escape characters are shown in Table 3-2.

'

"

\

a



f

v

Objects of one type can be converted into objects of another type either implicitly or explicitly. Implicit conversions happen automatically; the compiler takes care of it for you. Explicit conversions happen when you “cast” a value to a different type. The semantics of an explicit conversion are “Hey! Compiler! I know what I’m doing.” This is sometimes called “hitting it with the big hammer” and can be very useful or very painful, depending on whether your thumb is in the way of the nail.

Implicit conversions happen automatically and are guaranteed not to lose information. For example, you can implicitly cast from a short int (2 bytes) to an int (4 bytes) implicitly. No matter what value is in the short, it will not be lost when converting to an int:

short x = 5;
int y = x; // implicit conversion

If you convert the other way, however, you certainly can lose information. If the value in the int is greater than 32,767 it will be truncated in the conversion. The compiler will not perform an implicit conversion from int to short:

short x;
int y = 500;
x = y;  // won't compile

You must explicitly convert using the cast operator:

short x;
int y = 500;
x = (short) y;  // OK

All of the intrinsic types define their own conversion rules. At times it is convenient to define conversion rules for your user-defined types, as discussed in Chapter 5.