DATA - "that which is given". A data item has a number of attributes:

• The address or reference of a data item is the physical location in memory (computer store) of that data item.
• The amount of memory required by a particular data item is dictated by its type, e.g. integer, character, etc.

• The binary number stored at an address associated with a data item is its value.
• The required interpretation is dictated by the type of the data item.
• Consider 01011010, this can be interpreted as:
  • The Decimal integer 90
  • The Hexadecimal integer 5A
  • The Octal integer 132
  • The ASCII character (capital) Z
  • Etc.
• The set of symbols used to express the value of a given data item is sometimes referred to as a literal.

The type of a data item also dictates the operations that can be performed on it. For example numeric data types can have the standard mathematical operations performed on them while string data types cannot.

To do anything useful with a data item all the above must be tied together by giving each data item an identifying name (sometimes referred to as a label or an identifier).

• Names are usually made up of alpha-numeric characters.
• White space is usually not allowed (an exception is Algol 60).
• Some languages (Ada and C included) allow underscores.
• Some languages restrict the number of characters (first 31 in ANSII C).
• Some allow any length but treat the first N characters as significant.
• Case may be significant: in Algol'60, C and Modula 2 case matters; in Pascal and Ada it does not.
• Cannot use key/reserved words as names.

Data Items comprise: (1) a name, (2) an address and (3) a value. It is important to distinguish between these:

• The amount of storage required for its internal representation.
• The interpretation of the internal representation.
• The operations that can be performed on the item.

Data items can be classified as being either global or local data items, and as being either variables or constants. The nature of a data item is defined through a data declaration.

A data declaration introduces a data item. This is typically achieved by associating the item (identified by a name) with a data type. Examples in Ada, Pascal and C:

NUMBER: integer;     NUMBER: integer;     int number;

In some Imperative languages we can specify the possible values for a data item, in which case the compiler may deduce the type of a data item according to the nature of these values. Examples in Pascal:

NUMBER: 1..10;               LETTWER: 'A'..'C';

Here the first item will be considered to be an integer (because the range of possible values for the item are integers), and the second will be considered to be a character (because the range of possible values for the item are characters).

Assignment is the process of associating a value with a data item. Usually achieved using an assignment operator. Examples in Ada, Pascal and C:

NUMBER:= 2;          NUMBER:= 2;          number = 2;

Initialisation is then the process of assigning an initial value to a data item. Some imperative languages allow this to be done on declaration (e.g. C and Ada) others do not (e.g. Pascal). Examples in Ada and C:

NUMBER: integer:= 2;                         int number = 2;

In some imperative languages (notably Pascal) declarations must be presented in a certain order, e.g. constants before variables. In Pascal constants are grouped together in a CONST section, followed by variables grouped together in a VAR section.

Many imperative langauge (Ada and Pascal, but not C) support the concept of multiple assignment where a number of variable can be assigned a value (or values) using a single assignment statement. Examples in Ada and Pascal:

NUMBER1, NUMBER2:= 2;                        NUMBER1, NUMBER2:= 2, 4;

Note that in Pascal we do not have to assign the same value to ecah varaibale when using a multiple assignment statement. In Pascal we can also write:

NUMBER1, NUMBER2 := NUMBER2, NUMBER1;

which has the effect of "doing a swap".

Data items have associated with them:

1. A life time - the period during the running of a program when they can be said to exist.
2. A visibility - the parts of the program from where they can be accessed ("seen").

The nature of the life time and visibility of a data item is dictated by what are referred to as scoping rules. In this respect there are two types of data:

1. Global data, which has a life time equivalent to an entire program and is visible from anywhere within that programme.
2. Local data, whose life time and visibility is in some way limited.

• Given that we can always replace a particular bit pattern with another, the value of a data item can always be changed.
• Imperative languages support such change.
• Data items that are intended to be used in this way are referred to as variables.
• The value associated with a variable can be changed using an assignment operation.
• In most imperative languages (including Ada and C) data items are assumed to be variables by default (in Pascal we must include the key word VAR in the declaration).

Uninitialised Variables

• It is possible to declare a data item that has no value (other than an arbitrary bit pattern).
• Such a data item is referred to as an uninitialised variable.
• Uninitialised variables are dangerous!
• Individual imperative languages treat the phenomena of uninitialised variables differently. Common approaches include:
  1. Ignore the problem and leave it up to the programmer not to use them.
  2. Consider their usage to represent an error.
  3. Allocate an appropriate value to such variables.
• Most imperative languages either ignore the problem completely (Modula II), or at least to a large extent (C and Ada).
  • Ada initialises pointers to NULL and otherwise ignores the problem.
  • C initialises global variables to some appropriate "zero" value and otherwise ignores the problem.

It is sometimes desirable to define a data item whose value cannot be changed. Such data items are referred to as constants and are usually indicated by incorporating a predefined key word into the declaration. Examples in Ada and C:

I: constant integer:= 2;                const int i = 2;

Conceptually we can think of a constant as a data item comprising only of a name and a value (i.e. no address):

However it should be appreciated that what we are doing here is telling the compiler to "flag" the data item as a constant (i.e. we are only instigating software protection). Theoretically we can still change the bit pattern representing the value.

Often we use data items in a programme without giving them a name, such data items are referred to as anonymous data items. Examples include:

4 + (5*6)                       x + (5*6)

The (5*6) is an anonymous data item. The significance is that anonymous data items cannot be changes or used again in other parts of a program. Conceptually we can think of an anonymous data item as a data item without a name, consequently we cannot access its address (or its value).

To summarise the above:

• Data items can be variables or constants.
• Variables or constants can be global or local.
• Data items are "introduced" using a declaration statement.
• Data items have an "initial" value associated with them through a process known as initialisation.
• The value associated with a variable can be changed using an assignment operation.

It is sometimes useful, given a particular application, to rename (alias) particular data items, i.e. provide a second access path to it. This is supported by some imperative languages such as Ada (but not C or Pascal). Ada Example:

I: integer = 1;
ONE: integer renames I;

Here we have declared a data item integer and then allocated a second name (ONE) to the item. Thus, conceptually, renaming creates a data item with more than one name (but only one address and consequently only one value).

It is dangerous to rename variables. Consider the following Ada programme:

with CS_IO; use CS_IO;

procedure RENAME is
        ITEM : integer;
        ONE  : integer renames ITEM;
begin
        get(ITEM);

        put("ITEM = "); put(ITEM); new_line;
        put("ONE = "); put(ONE); new_line; new_line;

        ITEM:= ITEM*10;
        put("ITEM = "); put(ITEM); new_line;
        put("ONE = "); put(ONE); new_line; new_line;

        ONE:= ONE*10;
        put("ITEM = "); put(ITEM); new_line;
        put("ONE = "); put(ONE); new_line;
end RENAME;

Note that any change made to data item ITEM results in an identical change to data item ONE (and vice versa). This is because both names represent the same data item.

• Whereas renaming (aliasing) binds more than one name to one data item, overloading binds two or more data items (usually of different types) to one name.
• Care must be taken not to cause ambiguity!
• Neither Ada or C explicitly support overloading, however:
  1. In C overloading can be implemented by declaring a compound type known as a union.
  2. In Ada the same effect can be contrived using an appropriately defined record.
• More generally overloading can best be illustrated by considering the `+' and `-' arithmetic operators available in all imperative languages.
• Traditionally the operands for these operators are overloaded to allow both integer and floating point addition and subtraction:

 5 + 3                   5 - 3
5.6 + 3.2               5.6 - 3.2

• We say that the `+' and `-' operators are overloaded.
• C also allows mixing of operands (Ada does not) - so called mixed mode arithmetic:

 5 + 3.2               5.6 - 3
5.6 + 3                   5 - 3.2

EMERGENCY SHUT DOWN PROCEDURE! Left lever: return to imperative home page. Right: continue.