13.1 User-defined data types

# User-Defined Data Types

##### the purpose of a user-defined data type
- To create a new data type (from existing data types)
- To allow data types not available in a programming language to be constructed // To extend the flexibility of the programming language
## Composite data types
- Composite data types can be user-defined or primitive
- Composite data types refer to other data types in their definition/contain more than one data type in their definition
- Composite data types can be record/set/class
#### What is meant by composite data types
-  A (user defined) data type that is a collection of data that can consist of multiple elements
-  of different or the same data types
-  grouped under a single identifier.  
#### What is meant by a user-defined composite data type
- A data type constructed by a programmer // not a primitive data type
- A data type that references at least one other data type…
- … the data types can be primitive, or user defined
##### example
Class / object / set / Record

### Record Data type
- *Allow programmer to create record data type with components that precisely match the data requirements of the particular program

```pseudocode
TYPE
<main identifier>
  DECLARE <subidentifier1> : <built in data type>
  DECLARE <subidentifier2> : <built in data type>
ENDTYPE

// Creating a variable using this record data-type.
DECLARE myVariable : main identifier // The variable is declared as a record

<main identifier>.<sub identifier(x)> ← <value>
```

Example
```pseudocode
TYPE
TEmployeeRecord                    
  DECLARE FirstName : STRING      
  DECLARE LastName : STRING
  DECLARE Salary$ : REAL
  DECLARE Position : STRING
ENDTYPE

DECLARE Employee1 : TStudentRecord

Employee1.FirstName ← "John"       
Employee1.LastName ← "Doe"
Employee1.Salary$ ← 2830.80
Employee1.Position ← "Project Manager"
```
### Set Data type
- Allows a program to create sets and to apply the mathematical operations defined in set theory
- A set is mathematical concept with important properties
  - Contains a collection of data values
  - No organisation of the data value within the set
  - Duplicate values are not allowed

```pseudocode
// In pseudocode the type definition has this structure:
TYPE <set-identifier> = SET OF <Basetype>

// Variable definition
DEFINE <identifier> (value1, value2, value3, ... ) : <set-identifier>
```

Example
```pseudocode
TYPE Days = SET OF STRING
DEFINE Today (Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday) : Days
```

#### Objects and Classes
- Is a data type which is used is used for an object-oriented programming
- There are likely to be a number of built in classes
## Non-Composite data types
- Non-composite data types can both be user-defined or primitive
- Non-composite data types do not refer to other data types in their definition / contain one data type in their definition
- Non-composite data types can be primitive/enumerated/pointer
### What is meant by non-composite data types
-  It can be defined without referencing another data type
-  It can be a primitive type available in a programming language, **or** a user- defined type.
##### Enumerated data type
- A user-defined non-composite (data type)
- …with a list of all possible values
- …that is ordered.  
```pseudocode
TYPE <Datatype> = (<value1>,<value2>,<value3>…)

DECLARE <identifier> : <datatype>
```
Example
```pseudocode
TYPE Season = (Summer,Winter,Autumn,Spring) // Note: we are not writing
                                               Summer intead of "Summer" b/c
                                               it is a non-composite data type 
DECLARE ThisSeason : Season
DECLARE NextSeason : Season

ThisSeason <-- Autum 
NextSeason <-- ThisSeason + 1 // NextSeason is set to Spring
```
##### Pointer data type
- A user-defined non-composite (data type) (only award once)
- …that stores addresses/memory locations only
- …and indicates the type of data stored in the memory location.  
```
TYPE <Datatype> = ^<type name>

// Declaring a pointer variable
DECLARE <identifier> : <datatype>

<assignment value> ← <identifier>^  // This accesses the data stored at the address which IntegerPointer points to. This is known as dereferencing.
```
Example:
```
SecondPointer <-- @<identifier> //This stores the memory address of the <identifier> in SecondPointer 
SecondPointer^ <-- MyVariable //This stores the value in MyVariable to the memory location currently pointed by SecondPointer.
```

**Write pseudocode statements that will achieve the following.**

1. **Place the address of MyInt2 in the IPointer.**

```pseudocode
   IPointer <-- @MyInt2
   ```

2. **Assign the value 33 to the variable MyInt1.**

```pseudocode
   MyInt1<-- 33
   ```

3. **Copy the value of MyInt2 into the memory location currently pointed at by the IPointer.**

```pseudocode
   IPointer^ <-- MyInt2
   ```

Example Questions:
The value for *NumberOfCopies* must be between *1* *and* *10* inclusive.

```pseudocode
DECLARE NumberOfCopies : 1 .. 10
```

The values for *BicycleID* *must be between* *500* *and* *599* inclusive.

```pseudocode
DECLARE BicycleID : 500 .. 599
```