The type of a data item defines:

1. The nature of its internal representation.
2. The interpretation placed on this internal representation.
3. As a result of (2) the allowed set of values for the item.
4. Also as a result of (2) the operations that can be performed on it.

The process of associating a type with a data item is referred to as a data declaration.

Categorisation of Types

2. Scaler and Compound types. Scalar types define data items that can be expressed as single values (e.g. numbers and characters). Compound types (also referred to as composite or complex types) define data items that comprise several individual values. Scaler types are generally pre-defined, while compound types are often programmer-defined.

3. Discrete and Non-discrete types. Discrete types (also refered to as linear or ordinal tpes) are types for which each value (except its minimum and maximum) has a predecessor and a successor value. The opposite are referred to as non-discrete types.

4. Basic and Higher Level types. Basic types (also refered to as a simple types or type primitives) are the standard scaler predefined types that one would expect to find ready for imediate use in any imperative programming language. Higher level types are then made up from such basic types or other existing higher level types. Higher level types are not necessarily programmer defined - for example many imperative languages include a string high-level type.

Every imperative languages supports a number of standard basic data types:

Note that the type void supported by C indicates a type whose value corresponds to only 0 bits in memory.

Examples of Data Item Initialisation in Ada and C

with CS_IO; use CS_IO;

procedure INIT_ADA is
        NUM_A: integer:= 1;
        NUM_B: integer:= 2;
        NUM_C, NUM_D: integer:= 3;
        NUM_E: integer:= C;
        NUM_F: integer:= C+1;
begin
        put(NUM_A);put(NUM_B);new_line;
        put(NUM_C);put(NUM_D);new_line;
        put(NUM_E);put(NUM_F);new_line;
end INIT_ADA;

#include

void main(void)
{
int num_a = 1, num_b = 2;
int num_c = 3, num_d = 3;
int num_e = num_c;
int num_f = num_c+1;

printf("a = %d, b = %d\n",num_a,num_b);
printf("c = %d, d = %d\n",num_c,num_d);
printf("e = %d, f = %d\n",num_e,num_f);
}

Note that Ada supports multiple initialisation (e.g. NUM_C, NUM_D: integer:= 3;) while C does not.

• The term range refers to the minimum and maximum value that numeric types can take.
• The term precision refers to the number of significant figures with which a numeric type is stored.
• All numeric types have default precisions and/or ranges associated with them.
• Different imperative languages specify ranges and precisions in different ways, but there are three principal styles:
  1. Predefined (cannot be influenced by the programmer)
  2. Adjectives (e.g. C)
  3. Explicit specification (e.g. Ada, Pascal)

Adjectives

Adjectives are used to specify classes of numeric types. Some C examples are given below:

Pointers (access values in Ada) are variables that have as their value an address, i.e. a reference to another data object.

• A pointer may take a special value null (in C and Ada) which indicates that the pointer is pointing nowhere.
• Given a pointer we can access the value "pointed" to through a process known as dereferencing.

C POINTERS

• C makes extensive use of pointers and uses two prefix operators:

  * (Asterisk)
  & (Ampersand)
  

• * when used in a declaration is read as "pointer to a data type". Example:

  int *numberPtr;
  

• * when used elsewhere is interpreted as "the value contained in the reference/ address pointed at" (i.e. the pointer is dereferenced). Example:

  *numberPtr = *numberPtr + 1;
  

• & when used anywhere is read as the "reference/address of ...". Example:

  numberPtr = &x
  

  In this case x is referred to as a reference variable.

Consider the following example:

#include <stdio.h>

void main(void)
{
int number, *numberPtr;

scanf("%d",&number);

numberPtr = &number;
printf("Value of number = %d\n",number);
printf("Address of number = %d\n",&number);
printf("Value of numberPtr = %d\n",numberPtr);
printf("Address of numberPtr = %d\n",&numberPtr);
printf("Value pointed at by numberPtr = %d\n",*numberPtr);
}

Note that the address of number and the value of numberPtr are the same. If the result of running the above program (with number set to 2) were:

Value of number = 2
Address of number = 2063808352
Value of numberPtr = 2063808352
Address of numberPtr = 2063808356
Value pointed at by numberPtr = 2

We can illustrate this as follows:

Ada Access Values

• In Ada pointers are referred to as access values.
• To declare an access value the reserved word access is used in the declaration. Example:

with CS_IO; use CS_IO;

procedure ACCESS is
   type INTEGERPTR is access
      integer;
   INT_PTR: INTEGERPTR:=
      new integer'(2);
begin
   put(INT_PTR.ALL); new_line;
end ACCESS;

Note that the variable INT_PTR is referred to as an access variable.

Programmer-defined types are defined using a type declaration statement. This binds a "new" type definition with a type name (remember that a data item declaration statement binds a data item name to a type definition). Type declaration statements have the general form:

type <TYPE_NAME> is <TYPE DEFINITION> ;

<TYPE_NAME> = <TYPE DEFINITION> ;

typedef <TYPE_NAME> <TYPE DEFINITION> ;

In Ada, Pascal and C. Note that in Pascal type declarations must be grouped together in a type declaration section which must be preceded by a const declaration section (if any), and followed by a var declaration section (again if any).

A type declaration statement can also be used to rename an existing type, for example to use a more descriptive (application dependent) type name for a particular type. This offers advantages of both Clarity and Brevity. Examples:

Ada

subtype REAL_T is float;
NUMBER: REAL_T;

C

typedef float REAL_T, *REAL_T_PTR;
REAL_T number;
REAL_T_PTR numberPtr;

In both of the above examples an alternative name for the pre-defined type float has been declared.

SUB-TYPES

Given a particular application it is sometimes also useful to characterise a sub-set of values of some other pre-existing type. This is supported by languages such as Ada (but not C) where a subtype declaration statement is used as follows:

subtype DAY_NUMBER_T is integer
        range 1..31;
DAY: DAY_NUMBER_T:= 10;

Here the type DAY_NUMBER_T is declared as a "sub-type" of the type integer (the new types range is a sub-set of that available for the supper-type). A similar effect can be achieved in Pascal (although the languages does not specifically support a "subtype" statement).

OPTICS: Left - return to imperative home page. Right - continue.