If you need assistance

University FAQ
Look at Will the course withdrawal period be extended?
Look at What assistance is available to students facing financial difficulties?
Look at What if I do not have reliable internet access?

Overview of the next few weeks

I would like to build a dynamic array.
- This is an array where the size can change as the program runs.
This array will employ dynamic memory.
To build it, we will need to employ it in a class, we will need three member functions
- A destructor
- A copy constructor
- An overloaded assignment operator
When we finish we will have the pattern for classes with dynamic memory.
After that we will discuss three distinct dynamic structures
- Linked Lists
- Stacks
- Queues
Finally, if there is time, we will discuss recursion.
An array class.
- For now, we will build an array class with a static array.
  - Static variables are variables where the memory is allocated at compile time.
  - Dynamic variables are variables where the memory is allocated at run time.
- For the first pass, we will implement the following functions
  - Constructor.
  - Size - return the size of the array.
  - Capacity - return the maximum number of values the array can hold.
  - At (pos) return the value at position pos, or 0 if pos is invalid.
  - Set(pos, value) if pos is valid set the value at that position.
  - Append(value) if there is space, append the value to the array.
  - Delete(), remove the last element from an array.
- We will have two private data members
Just a little randomness
- There are two random functions in c.
  - rand() produces a random integer between 0 and RAND_MAX inclusive.
    - rand()%limit will produce a random number between 0 and limit, not including limit.
  - Unfortunately this is not a true random number, it will repeat the same sequence every time the program is run.
  - srand(unsigned int seed) will allow the sequence to start at a new place each time.
    - srand(time(NULL)) is a recipe for initializing the random number generator.
    - You need #include <time.h>
    - You only do this once.
  - Write a program to emulate a d6.
Look at the code for the day.
You need to understand this to go on.

Discuss static memory in this class.

When is memory allocated?

How much memory is allocated?

```
size_t i;
```
```
ArrayT ary; 
```
```
int y;
foo(y);
void Foo(int x){ 
```
```
int y;
foo(y);
...
void Foo(int & x){ 
```
```
void FillArray(ArrayT & ary){
```
```
void PrintArray(ArrayT ary){
```