.. index:: type; value value type .. _value-types: Value Types and Conversions =========================== .. index:: int; value range type; int overflow .. _type-int: Type int -------- A variable is associated with a space in memory. This space has a fixed size associated with the type of data. The ``int`` and ``double`` types are examples of *value types*, which means that this memory space holds an encoding of the complete data for the value of the variable. The fixed space means that an ``int`` cannot be a totally arbitrary integer of an enormous size. In fact an ``int`` variable can only hold an integer in a specific range. See :ref:`data-representation` for the general format of the underlying encoding in bits. An ``int`` is held in a memory space of 32 bits, so it can have at most :math:`2^{32}` values, and the encoding is chosen so about half are positive and half are negative: An ``int`` has maximum value :math:`2^{31} - 1 = 2147483647` and a minimum value of :math:`-2^{31} = -2147483648`. The extreme values are also named constants in C#, ``int.MaxValue`` and ``int.MinValue``. In particular this means ``int`` arithmetic does not always work. What is worse, it fails *silently*: .. code-block:: none csharp> int i = int.MaxValue; csharp> i; 2147483647 csharp> i + 5; -2147483644 Add two positive numbers and get a negative number! Getting such a wrong answer is called *overflow*. Be very careful if you are going to be using big numbers! Note: with addition, overflow will give the wrong sign, but the sign may not give such a clue if another operation overflows, like multiplication. .. index:: type; long long type short type byte type .. _type-long: Type long --------- Most everyday uses of integers fit in this range of an ``int``, and many modern computers are designed to operate on an ``int`` very efficiently, but sometimes you need a larger range. Type `long` uses twice as much space. The same kind of silent overflow errors happen with ``long`` arithmetic, but only with much larger numbers. When we get to :ref:`array`, you will see that a program may store an enormous number of integers, and then the total space may be an issue. If some numbers fit in a ``long``, but not an ``int``, ``long`` must be used, taking us twice the space of an array of ``int`` elements. If all the integers have even more limited ranges, they might be stored in the smaller space of a ``short`` or a ``byte``. We will not further discuss or use types ``short`` or ``byte`` in this book. Here we will only use the integral types ``int`` and ``long``. .. index:: type; double double type precision float type type; float .. _type-double: Type double ------------ A ``double`` is also a value type, stored in a fixed sized space. There are even more issues with ``double`` storage than with an ``int``: Not only do you need to worry about the total magnitude of the number, you also need to choose a *precision*: There are an infinite number of real values, just between 0 and 1. Clearly we cannot encode for all of them! As a result a ``double`` has a limited number of digits of accuracy. There is also an older type ``float`` that takes up half of the space of a ``double``, and has a smaller range and less accuracy. This at least gives a reason for the name ``double``: double the storage space of a ``float``. To avoid a ridiculously large number of trailing 0's, a big double literal can be expressed using a variant of scientific notation: ``1.79769313486232E+308`` means :math:`1.7976931348623157(10^{308})` C# does not have the typography for raised exponents. Instead literal values can use the E to mean "times 10 to the power", and the E is followed by and exponent integer that can be positive or negative. The whole double literal may not contain any embedded blanks. Internally these numbers are stored with powers of 2, not 10: See :ref:`data-representation`. Arithmetic with the ``double`` type does not overflow silently as with the integral types. We show behavior that could be important if you do scientific computing with enormous numbers: There are values for Infinity and Not a Number, abbreviated NaN. See them used in csharp: .. code-block:: none csharp> double x = double.MaxValue; csharp> x; 1.79769313486232E+308 csharp> double y = 10 * x; csharp> y; Infinity csharp> y + 1000; Infinity csharp> y - 1000; Infinity csharp> 1000/y; 0 csharp> double z = 10 - y; csharp> z; -Infinity csharp> double sum = y + z; csharp> sum; NaN csharp> sum/1000; NaN Once a result gets too big, it gets listed as infinity. As you can see, there is some arithmetic allowed with a finite number and infinity! Still some operations are not legal. Once a result turns into ``NaN``, no arithmetic operations change further results away from ``NaN``, so there is a lasting record of a big error! Note that Infinity, -Infinity and NaN are just representations when displayed as strings. The numerical constants are ``Double.PositiveInfinity``, ``Double.NegativeInfinity``, and ``Double.NaN``. .. warning:: There is no such neat system for showing off small inaccuracies in ``double`` arithmetic accumulating due to limited precision. These inaccuracies *still* happen silently. .. index:: numeric type range range of numeric types byte type short type type; byte and short .. _numeric-type-limits: Numeric Types and Limits -------------------------- The listing below shows how the storage size in bits translates into the limits for various numerical types. We will not discuss or use ``short``, ``byte`` or ``float`` further. long 64 bits; range -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 int 32 bits; range -2,147,483,648 to 2,147,483,647 short 16 bits; range -32,768 to 32,767 byte 8 bits; range 0 to 255 (no negative values) double 64 bits; maximum magnitude: :math:`1.7976931348623157(10^{308})`; about 15 digits of accuracy float 32 bits; maximum magnitude: :math:`3.402823(10^{38})`; about 7 digits of accuracy decimal 128 bits; maximum value: 79228162514264337593543950335; 28 digits of accuracy; can exactly represents decimal values for financial operations; briefly discussed in *optional* :ref:`Decimal Type `. char See :ref:`char as integer `. .. index:: cast .. _cast: Casting --------- While the mathematical ideas of 42 and 42.0 are the same, C# has specific types. There are various places where numerical types get converted automatically by C# or explicitly by the programmer. A major issue is whether the new type can accurately represent the original value. Going from ``int`` to ``double`` has no issue: Any ``int`` can be exactly represented as a ``double``. Code like the following is fine: .. code-block:: none csharp> int i = 33; csharp> double d = i; csharp> double x; csharp> x = 11; csharp> double z = i + 2.5; csharp> ShowVars(); int i = 33 double d = 33 double x = 11 double z = 35.5 The ``double`` variable ``d`` is initialized with the value of an ``int`` variable. The ``double`` variable ``x`` is assigned a value using an ``int`` literal. The ``double`` variable ``z`` is initialized with the value of a sum involving both an ``int`` variable and a ``double`` literal. As we have discussed before in :ref:`arithmetic`, the ``int`` is converted to a ``double`` before the addition operation is done. The other direction for conversion is more problematic: .. code-block:: none csharp> double d= 2.7; csharp> int i; csharp> i = d; {interactive}(1,4): error CS0266: Cannot implicitly convert type 'double' to 'int'. An explicit conversion exists (are you missing a cast?) The ``int`` ``i`` cannot accurately hold the value 2.7. Since the compiler does this checking, looking only at types, not values, this even fails if the the ``double`` happens to have an integer value: .. code-block:: none csharp> double d = 2.0; csharp> int i = d; {interactive}(1,4): error CS0266: Cannot implicitly convert type 'double' to 'int'. An explicit conversion exists (are you missing a cast?) .. index:: truncate in cast If you really want to possibly lose precision and convert a ``double`` to an ``int`` result, you *can* do it, but you must be explicit, using a *cast* as the csharp error messages suggest. .. code-block:: none csharp> double d= 2.7; csharp> int i; csharp> i = (int)d; csharp> i; 2 The desired result type name in parentheses ``(int)`` is a *cast*, telling the compiler you really intend the conversion. Look what is lost! The cast does not *round* to the nearest integer, it *truncates* toward 0, dropping the fractional part, .7 here. .. index:: Round function Rounding is possible, but if you really want the ``int`` type, it takes two steps, because the function ``Math.Round`` does round to a mathematical integer, but leaves the type as ``double``! To round ``d`` to an ``int`` result we could use: .. code-block:: none csharp> i = (int)Math.Round(d); csharp> i; 3 You can also use an explicit cast from int to double. This is generally not needed, because of the automatic conversions, but there is one place where it is important: if you want ``double`` division but have ``int`` parts. Here is a quick artificial test: .. code-block:: none csharp> int sum = 14; csharp> int n = 4; csharp> double avg = sum/n; csharp> avg; 3 Oops, integer division. Instead, continue with: .. code-block:: none csharp> avg = (double)sum/n; csharp> avg; 3.5 We get the right decimal answer. This is a bit more subtle than it may appear: The cast to double, ``(double)`` is an operation in C# and so it has a *precedence* like all operations. Casting happens to have precedence higher than any arithmetic operation, so the expression is equivalent to:: avg = ((double)sum)/n; On the other hand, if we switch the order the other way with parentheses around the division: .. code-block:: none csharp> avg = (double)(sum/n); csharp> avg; 3 then working *one* step at a time, ``(sum/n)`` is *integer* division, with result 3. It is the 3 that is then cast to a double (too late)! See the appendix :ref:`precedence`, listing all C# operations discussed in this book. .. index:: type; char char .. _type-char: Type char ---------- The type for an individual character is ``char``. A ``char`` literal value is a *single* character enclosed in *single* quotes, like ``'a'`` or ``'$'``. The literal for a single quote character itself and the literal for a newline use *escape codes*, like in :ref:`Strings2`: The literals are ``'\''`` and ``'\n'`` respectively. Be careful to distinguish a ``char`` literal like ``'A'`` from a string literal ``"A"``. .. index:: Unicode .. _integer-char: **Char as integer**: Though the ``char`` type has character literals and prints as a character, internally a ``char`` is a *type of integer*, stored in 16 bits, with the correspondence between numeric codes and characters given by the *Unicode* standard. Unicode allows special symbol characters and alphabets of many languages. We will stick to the standard American keyboard for these characters. Besides different alphabets, Unicode also has characters for all sorts of symbols: emoticons, chess pieces, advanced math.... See http://www.unicode.org/charts. All the symbols can be represented as escape codes in C#, starting with ``\u`` followed by 4 hexadecimal digits. For example ``\u262F`` produces a yin-yang symbol. We mention the ``char`` type being numeric mostly because of errors that you can make that would otherwise be hard to figure out. This code does not concatenate the ``char`` symbols: .. code-block:: none csharp> Console.WriteLine('A' + '-'); 110 What? We mentioned that modern computers are set up to easily work with the ``int`` type. In arithmetic with *smaller* integral types the operands are first automatically converted to type ``int``. An ``int`` sum is an ``int``, and that is what is printed. You can look at the numeric values inside a ``char`` with a cast! .. code-block:: none csharp> (int)'A'; 65 csharp> (int)'-'; 45 So the earlier 110 is correct: 65 + 45 = 110. For completeness: It is also possible to cast from small ``int`` back to ``char``. This may be useful for dealing with the alphabet in sequence (or simple classical cryptographic codes): .. code-block:: none csharp> 'A' + 1; 66 csharp> (char)('A' + 1); 'B' The capital letter one place after A is B. .. index:: type; Boolean or bool Boolean or bool .. _type-boolean: Type Boolean or bool --------------------- There is one more very important value type, that we introduce here for completeness, though we will not use it until :ref:`If-Statements`. Logical conditions are either true or false. The type with just these two values is *Boolean*, or *bool* for short. The type is named after George Boole, who invented what we now call *Boolean algebra*. Though it seemed like a useless mathematical curiosity when Boole invented it, a century later Boolean algebra turned out to be at the heart of the implementation of computer hardware. .. note:: The Boolean literals are ``true`` and ``false``, with *no* quotes around them. With quotes they would be of type string, not Boolean! Overflow to Positive Exercise ------------------------------- We gave an example above in :ref:`type-int`, adding two positive ``int`` values and clearly having an error, since the result was negative. Declare and initialize two positive ``int`` variables ``x`` and ``y``. Experiment with the initializations so i. Their product is too big to fit in an ``int`` AND ii. The wrong overflow result for ``x*y`` is *positive*, not negative.