Reading on Types and Variables

The simple programs introduced at the start of this course illustrated that many (most?) (all?) C programs utilize variables to store data during processing. These simple programs also illustrate the following.

• A variable name can be almost any sequence of letters (upper or lower case), digits, and the underscore character (-).

  • The variable name must start with a letter or underscore.
  • Some keywords (e.g., int, float, double, if, else, etc.) have special meanings and cannot be redefined.

• Variable names are case sensitive, so a capital letter (e.g., A) is considered distinct from a lower case letter (e.g., a).

• C requires a variable to be declared before it can be used.

• The declaration must include what type of data will be stored (e.g., int, double), and

• Once declared, variables store values which can be used in subsequent processing (e.g., in computations and printing). (Examples later in the course will show values stored in variables can be changed as well.)

Building upon these introductory examples, this reading explores data types and variables in C in moderate detail. Basic questions include:

• Why declare variables at all; what is gained by having to specify variables and their types before the variables are used?

• What happens when data and variables of differing types are mixed within expressions?

• What options are available for printing data of various types?

Data Representation and Storage

At a practical level, C identifies numerous types of data. Further, the 2013 C Standard allows some flexibility in the details underlying numeric types, particularly integer types. In the following description, details represent common implementations within contemporary computers, although these details may differ from one machine to another. General comparisons among types, however, will likely carry over to each C compiler and implementation.

For now, we only consider a few, commonly-used types of numbers. Details are discussed in the course segment on data representation.

• short: integers (negative, zero, or positive numbers without decimal points), generally limited to the range -32,768 to 32,767.

• int: integers (no decimal points), generally limited to the range -2,147,483,648 to 2,147,483,647.

• unsigned short: non-negative integers (no decimal points), generally limited to the range 0 to 65,535

• unsigned int: non-negative integers (no decimal points), generally limited to the range 0 to 4,294,967,295.

• float: real numbers (with an explicit decimal point), including about 7-8 digits of accuracy

• double: real numbers (with an explicit decimal point), including about 16 digits of accuracy

Behind the scenes, these types require different amount of storage, and the details of storage for the types may vary.

Going beyond the details, perhaps the most important observation here is that the nature and details of storage differ for various data types.

Altogether, this background provides an important motivation for the declaration of variables in C: Declaration of each variable in C tells the computer how much storage to allocate to a variable and what details will apply in storing and processing data for that variable.

Aiding Error Detection

Programming languages vary considerably with regard to the introduction of variables within a program. At one extreme, some languages consider the appearance of each new variable name as an implicit request to create a variable by that name. Similarly, some languages infer from context what type of data might be involved with a variable, and processing proceeds by assuming the intended data type. Such a flexible environment introduces rather little overhead in writing programs, and coding in these languages can be relatively simple, as long as the programmer does not make typographical errors and the computing environment makes the correct guesses about what type(s) of data are intended. However, with the computing making inferences, the programming environment cannot perform much error checking.

In contrast, C takes a different approach — requiring the explicit declaration of variables and their types. Although this requires some initial overhead for a programmer, declaration of variables also aids the detection of errors in programs in at least two ways: detecting misspelling and finding inconsistent views of data by a programmer.

Spelling

A particularly common difficulty for programs that have just been written involves typographical errors. With C, variables must be declared before they are used, so the compiler can check that each variable has already been identified.

• In the short-term, a programmer may be annoyed at having to react to compiler error messages about undeclared variables. It takes time to correct typographical errors and to compile a program — particularly when the programmer wants to move ahead to check how the new code will work.

• In the medium- to long-term, finding typographical errors early can resolve difficulties that can take a long time track down later. A small amount of time expended early can save substantial time later.

Types

Some early studies of common errors in computer programs concluded that a substantial fraction of difficulties arose, because a programmer thought of a variable as one type during part of the program and as another type in a different part of the code.

Also, when a language does not require variables to be declared with a specified type and the computer tries to infer the intended data type, subtle errors can arise in some current programming language. A programmer may write code, based on processing using one type of data, when the computer adopts a different type behind the scenes.

Since C requires variables to be declared as a specific type, and since the type cannot change within a program, C avoids possible inconsistencies in programmer thinking or processing inferences. C's requirements may seem inflexible and cumbersome at times, but C's use of data types anticipates and resolves many problems that arose historically and other difficulties still found in using current programming languages.

Arithmetic Operations

C provides these common arithmetic operations:

Assignment Operations

In our programs up to now, we have assigned values to variables with an assignment operation (=). The general syntax is

variable = expression

In this setting, the expression on the right is evaluated, and the resulting value is stored in the variable — replacing the old value. For example, in the first program for this course quarts.c, we computed:

    liters = quarts / 1.056710 ;      /* arithemtic, assignment */

Often in future programs, we will want to update the value stored in a variable. For example,

   int a = 5;
   int b = 7;
   ...
   b = 2 * a + 12;

In this example, b begins with the value 7. However, after awhile, the value for b is updated to 2 * 5 + 12 or 22 (assuming the value for a has not changed).

In the following variation, we use the value of a in computing the new value for a.

   int a = 5;
   ...
   a = 2 * a + 12;

Here, for example, the value of a is updated from 5 to 22.

Although many types of updates are possible, a common circumstance is to add, subtract, multiply, or divide one value by another. For example,

   a = a + 2;  // add 2 to a
   b = b - 5;  // subtract 5 from b
   c = c * 4;  // update c by multiplying it by 4
   d = d / 10; // update d by dividing it by 10

Since this type of computation is so common in C programs, C provides a shorthand type of assignment: +=, -=, *=, and /=. With this shorthand, the above examples become

  a += 2;
  b -= 5;
  c *= 4;
  d /= 10;

Auto-increment and Auto-decrement

Of all the possible updates to a variable, adding and subtracting 1 is particularly common. Here, C has two variations. For a variable a

• pre-increment: ++a means add 1 to a before doing anything else in the expression.

• post-postincrement: a++ means add 1 to a after every other computation in the expression is completed.

The following examples may help clarify these operators:

   int a = 5;   // a starts at 5
   int b = a++; // b is assigned a's initial value (5), and then a is increment to 6
   int c = 12;  // c starts at 12
   int d = ++c; // c is incremented to 13, and this revised value is assigned to d

At the end of this code, a is 6, b is 5, c is 13, and d is also 13.

Operator Precedence

When multiple operations appear in the same expression, C follows the same conversions as mathematics. Thus, multiplication and division have higher priority or precedence than addition or subtraction. Further, when several of the same precedence appear in the same expression, the operations are done left to right.

Resulting Type after an Operation

When two variables have the same numeric type (e.g., two int variables or two double variables) C performs arithmetic using that data type. For example,

• a real number divided by a real number yields a real number (e.g., 5.7 / 2.2 = 2.590909...

• an integer divided by an integer yields an integer (e.g., 11 / 4 = 2 — any remainder is dropped in obtaining an integer).

However, when an arithmetic operation is applied to a real number and an integer, the integer is converted to a real number first, before the operation is performed.

Finally, when an expression contains a mixture of integers and real numbers, conversion to real numbers occurs as late as possible. (Integer arithmetic is faster at the hardware level, so performing as much integer arithmetic as possible makes processing as quick as possible.)

Conversion of Types and Casting

In some cases, conversion from one data type to another seems easy and obvious. For example, conversion from an integer to a real number seems straightforward (conceptually, just a decimal point, so 5 becomes 5. or 5.0).

• When an arithmetic operation is applied to an integer and a real number (e.g., 2.3 + 5), we have noted that the integer will be converted to a real number before the operation is performed (e.g., 2.3 + 5 becomes 2.3 + 5.0).

• Similarly, when an integer is assigned to a double (e.g., double a = 5), the integer is converted to a real number before the assignment occurs (e.g., double a = 5 becomes double a = 5.0.

However, sometimes we may want to explicitly convert one type to another. For example, in the expression 1.0 + 11/4, we may want the division to be performed for real numbers before the addition operation. In such instances, we can specify the data conversion by placing the desired type in parentheses, before the number to be converted. For example, we might write 1.0 + (double) 11 / (double) 4

Printing

The first programs for this course included reasonably simple printf statements, so users could read the results of computations. As illustrated in those programs, the printf statement utilizes the following format:

   printf ("format specification", variable1, variable2, ... );

The "format specification", given within double quotes, may present text to be printed, together with instructions of what values are to be printed in what format.

Identifying the Type of Number to be Printed

In particular, a number will be inserted within the text of a "format specification" when a percent sign (%) is encountered, and the letters following the % indicates the type of data to be printed. Previous examples in the course have illustrated the use of %d for printing integers in decimal format and %lf for printing doubles. The following table shows a more complete list of number-formatting options for format specifications within printf statements.

Additional Formatting Options

In the example programs up to now, each number was printed in a default format. That is, the computer usually printed the number with no spaces before or after, and real numbers were printed with a default number of digits. Such formatting can work well, when numbers are to be printed within a sentence or other text.

However, printing of numbers within columns requires additional work. For example, we might want to print two rows of numbers in a table, with each column being 11 characters wide. Also, we may want to specify how many decimal places should be printed for real numbers.

To address these needs, C allows a more general designation of conversion format. In particular, for any format (e.g., f), two additional elements may be added:

• field width: the minimum number of characters to be printed for a number.

  • If the number to be printed requires fewer characters, the full width is allocated, and the number appears right justified in that field.
  • If the number to be printed requires more characters, the full number is printed — possibly exceeding the specified field width.

• precision:

  • For integers, the minimum number of digits that must appear.
    If the precision is 0, the number may not be printed.
    If the precision equals the field width, the number is printed with leading zeros.
  • For real numbers, the maximum number of digits to appear after the decimal point.

To specify these optional parameters, a complete format specifier has the form

   % field_width.precision conversion_specifier

The following program printf-formatting.c provides several examples of these formatting options. This program generates two columns, each 11 characters wide, and the output is presented here to the right of the program itself.

/* Program to illustrate formatted printing of several data types */

#include <stdio.h>

int main ()
{
  short   sh = 13;          // short integer
  int     in = 13;          // normal integer
  float   fl = 10.0 / 3.0;  // basic floating point number
  double  db = -25.0 / 9.0; // double floating point number

  /* label columns to facilitate counting */
  printf ("data type:  /w f.width   /w precision\n");
  printf ("            12345678901 / 12345678901\n");

  printf ("integer printing\n");
  /* field width 11   field width 11, precision 11 */
  printf ("short:      %11hd / %11.11hd\n", sh, sh);
  printf ("integer:    %11d / %11.11d\n", in, in);

  printf ("\nfloating-point printing\n");
  printf ("float:      %11f / %11.3f\n", fl, fl);
  printf ("float:      %11f / %11.5f\n", fl, fl);
  printf ("double:     %11lf / %11.2lf\n", db, db);
  printf ("double:     %11lf / %11.8lf\n", db, db);

  return 0;
}

In practice, when designing nicely formatted output, a programmer first needs to consider the desired format on a character-by-character basis. Once the layout is determined, the programmer should count how many characters must be allocated for each numeric value and what level of accuracy should be reported for real numbers. These width/precision values can then be added to format specifications.