Pointers

Remember,

A pointer is a data type
- A pointer "points" to another location in memory.
- It is an "indirect" reference to memory.
Pointers are declared with
- ```
dattype * identifier, *identifier
```
- The * is associated with the identifier.
Pointers can point anywhere,
- But for our immediate use, we will be pointing to dynamic memory.
- This is memory allocated from the heap.
- We must return this memory when we are finished.
- We allocate memory from the heap with new
- We return memory to the heap with delete

new/delete

There are two forms of new and delete.
- The first is for a single instance of the data type.
  - Syntax
  - ```
   new datatype
```
- ```
 delete id
```
  - Example
  - ```
   myIntPtr = new int 
```
- ```
 delete myIntPtr 
```
- The second is for arrays
  - Syntax
  - ```
   new datatype[size_t]
```
- ```
 delete [] id
```
  - Example
  - ```
   myIntPtr= new int[10] 
```
- ```
 delete []  myIntPtr 
```
- Notice in the second, there the size_t is not const.
For every call to new, there should be a corresponding call to delete.
- All of the memory we allocate from the heap needs to be restored.
- All memory is restored on exit by default.
- Failure to return memory is called a memory leak

Memory Leaks

A memory leak is the loss of available memory space that occurs when dynamic data is allocated but never deallocated.
But for this class, you need to explicitly return all memory.
Memory leaks will be charged a substantial point penalty

Checking for memory leaks

Pointers and Arrays

Passing pointers as parameters.

Pointers are variables and can be passed by value or reference.
```
void foo(int * & intPtr);
```
The semantics with const become more difficult, so we will put that aside for now.

NULL or nullptr

Some other pointer errors

An Inaccessible Object is allocated memory with no pointer pointing to it.
A Dangling Pointer is a pointer that points to memory that has been deallocated.
An Invalid Pointer is a pointer that points to an invalid address other than NULL or nullptr.

Write a program to store integers in a dynamic array.