Pointers: Lesson

Congratulations on completing this lesson on pointers and memory management! 

Here is a brief recap of everything you've learned:

* The base unit of memory is a byte.
* Memory is represented as a block of bytes.
* These bytes have an associated address which is represented by a hexadecimal number.
* When a program is running, it is the responsibility of the underlying operating system to reserve a block of RAM for the program.
* A pointer is a special type of integer variable that stores the memory address of a regular variable.
* A pointer can store the address of any type of variable, including other pointers.
* The address stored in a pointer is the address of the first byte of memory that stores a variable.
* A pointer can be declared in two ways:
  * dataType* nameOfPointer;
  * dataType *nameOfPointer;
* To obtain the address of a variable such that it may be assigned to a pointer, the reference operator (&) is used. Syntax: 
  * &variableName;
* Accessing data that is stored in a memory address pointed to by a pointer is done using the dereference operator (*). Syntax:
  * *pointerName
* Pointer arithmetic is allowed but only for addition and subtraction by an integer.
* It is not possible to add/subtract one pointer to/from another pointer.
* Incrementing or decrementing a pointer is done in the following way:
  * pointer += someInteger;
  * pointer -= someInteger;
* Incrementing/decrementing a pointer changes the address by *n* times the size of the data type the pointer is pointing to.
* Because an array is stored as a contiguous block of memory, a pointer can be used to traverse it.
* Great care must be exercised when using a pointer as it is possible to accidentally corrupt data stored in other memory addresses.

Good work!


Review

For a program to execute, it must use some of the computer’s resources such as CPU, RAM, IO, or other hardware. Deciding how and at what capacity to use these resources is the job of the underlying operating system. One of the most important of these resources is memory, more specifically: the temporary memory used for program execution which is called random access memory (RAM). When a program executes, the operating system reserves a section of the computer’s physical RAM to be used exclusively by the program. The fundamental unit of this memory is a byte. As you learned previously, all variables are simply a collection of some number of bytes: an `int` is four bytes, a `double` is eight bytes, and so on. The allocated section of RAM is simply a block of however many bytes the program needs (if available, of course).

As you can see, in this block of memory to the right, every byte has an associated address numbered using the [hexadecimal numbering system](https://en.wikipedia.org/wiki/Hexadecimal). For example, a byte of memory could be located at address 0x200 and the immediate byte next to it is located at address 0x201. 

Every programming language has a different policy regarding the direct access and manipulation of a byte in memory; some allow it, some do not. C is one of the languages that allow such operations through the use of a *pointer*, and we will see how in this lesson.

At first glance, pointers may appear to be an overcomplicated way to work with variables, and for such simple examples meant to illustrate basic principles, this is true. However, the real value of pointers becomes apparent in more complex applications, such as working with data structures or embedded systems (think robots and microchips). Examples of these are well beyond the scope of this introductory tutorial. For now, just familiarize yourself with these ideas such that you may recall them when you need to!

Memory in C

In the lesson on arrays, you learned that an array is a contiguous block of memory reserved for many variables of the same type. Because of this structured organization, a pointer is well suited to work with this data type. If we have an integer array, we can use pointers and pointer arithmetic to iterate through the array to access or manipulate its values. This might seem like an overcomplicated way to work with arrays, but there are some advanced applications in which working with an array through a pointer is necessary.

Consider an array of integers `arr`. Since arrays are contiguous blocks of memory, if we have a pointer to the first element, we can use pointer arithmetic to access the rest of the array. Keep in mind that while this is a valid way to work with arrays, it is unsafe. Accessing memory outside of the bounds of the array will not cause a program crash, but will silently corrupt data stored in those addresses. In the case of a read operation, it will return a random value.

With caution in mind, let's see how we can carefully access and manipulate elements in an array using pointers. The following code prints all of the elements of an array:

```cpp
int arr[10] = {2, 4, 7, 1, 10, 3, 11, 6, 20, 5};
int* ptr = &arr[0]; // Pointer to the first element

for(int i = 0; i < 10; i++){
  printf("%i\n", *ptr); // Dereference the pointer and print the value
  ptr++; // Increment the pointer to point to the next int in the array
}
```

The following code illustrates how to change the values of an array using pointers by changing all the elements in an array to three:

```cpp
int arr[10] = {2, 4, 7, 1, 10, 3, 11, 6, 20, 5};
int* ptr = &arr[0]; // Pointer to the first element

for(int i = 0; i < 10; i++){
  *ptr = 3; // Dereference the pointer and assign the value at the ptr address to three
  ptr++; // Increment the pointer to point to the next int in the array
}

for(int i = 0; i < 10; i++){
  printf("%i",arr[i]);
}
```

The output of the code above will be a string of 10 threes. These techniques are also applicable to strings since they are arrays too. It cannot be stressed enough: be very careful when working with pointers!

Pointers & Arrays

Remember that a pointer is a special type of integer variable. This implies that basic arithmetic operations can be done on pointers. In this exercise, we will explore this idea.

The only arithmetic operations allowed for pointers are addition and subtraction. Conceptually, adding to (or subtracting from) a pointer means the pointer will point to some new address. Multiplication is not allowed because the address of a byte of memory is usually a large number; therefore, multiplying an address may yield an even larger number, possibly representing an address outside the bounds of the available memory space. Division is not allowed as it potentially allows a pointer to illogically point to an address with a non-integer index.

The addition operation for a pointer is only valid when adding an integer to a pointer; you cannot add two or more pointers together! The syntax is traditional addition illustrated by the following example (here, `n` represents an integer):
```cpp
pointer = pointer + n;
pointer += n; // Same outcome with different syntax
```
The important thing to note here is that adding `n` to a pointer _does not_ increment the address to point to a value `n` bytes away. It moves the pointer by `n` * (size of the data type in bytes). For example, if a pointer to an `int`, the size of which is four bytes, initially contains address 100 (we will use a decimal address for simplicity), and three is added to the pointer, the pointer will now point to address 112.

Let's take a look at how this works:

```cpp
int main() {  
  int* ptr; 
  ptr += 3; // Increment pointer by three blocks. 
}
```
This code increments the pointer `ptr` to store the address that is three `int` sizes away. Incrementing by one can be done in the following ways:
```cpp
pointer++;
pointer += 1; // Same outcome with different syntax
```
Subtracting from a pointer behaves in the same way with the address being decremented instead of incremented. 

Pointers are very powerful and allow greater control over a program. But with great power comes great responsibility! Working with pointer arithmetic can be dangerous if used carelessly. If an attempt is made to increment (or decrement) a pointer beyond the bounds of the memory space of a program, a crash will occur. Pointers are so dangerous, that many high-level languages (such as Java) will not even allow such operations. Be careful!

Pointer Arithmetic

Since pointers are used to store the memory address of a variable, we need to obtain this address first. This is done by using the *reference operator* (&). The syntax for this is:

> &variableName;

Consider the following piece of code:

```cpp
int x = 9;
printf("%p", &x);
```
This will output to the screen the memory address of the variable `x`. To assign an address to a pointer, the following syntax is used:

> pointer = &variableName; 

Consider the following example:

```cpp
int x = 727; // Declare variable x
int* ptr = &x; // Declare a pointer to an int variable and assign to it the address of variable x
printf("%p\n", &x); // Print the address of x
printf("%p\n", ptr); // Print the address pointed to by ptr 
``` 

The code above declares an integer variable `x` and an `int` pointer variable `ptr`. The pointer is then assigned the memory of the variable `x`. The last two `printf()` statements print this address; both lines will output the same hexadecimal number as they both refer to the same address in memory.

The address a pointer contains is not constant. A pointer may be reassigned to a new address so long as type consistency is maintained (e.g., `int` pointer points to a variable of type `int`). Consider this example:

```cpp
int* ptr; // Declare pointer to an integer type

int x = 3; // Declare variable x
ptr = &x; // Assigns memory address of variable x to the pointer
printf("%p\n", ptr); // Prints address of variable x 

int y = 14; // Declare variable y
ptr = &y; // Reassigns the pointer to the memory address of variable y
printf("%p\n", ptr); // Prints address of variable y
```

The Reference Operator

If we have a pointer that is assigned the memory address of a variable, eventually we will need to access the data that it contains so we can use or manipulate it. The data contained in the memory address pointed to by a pointer can be accessed using the dereference operator (*). The syntax is as follows:

> *pointerName;

Once a pointer is dereferenced, we can use its contents as we would a regular variable. It is important not to confuse this operator with the multiplication operator as they are represented by the same symbol!

Here is a full example:

```cpp
int x = 4;
int* ptr = &x; // ptr stores the memory address of variable x

int y = *ptr; // Declare variable y and assign to it the data stored in memory pointed to by ptr, which is the value of variable x

printf("%i", y);
```

The code above illustrates how to obtain the data stored in the address pointed to by `ptr` by dereferencing it. Since `ptr` stores the address of variable `x`, the value obtained by dereferencing `ptr` is the value of `x`. If the value of a dereferenced pointer is changed, the value of the corresponding variable will change in the same way:

```cpp
int x = 4;
int* ptr = &x;

*ptr = 200; // The data in the memory address pointed to by ptr now contains the value 200

printf("%i", x); // This will output 200
```

The code above declares a variable `x` with an initial value of four. The pointer `ptr` points to the memory address of `x`. `*ptr = 200` changes the data at the memory address stored in `ptr` to 200. Since this memory address is that of the variable `x`, the value of `x` now changes from four to 200.

The Dereference Operator

In C, a byte of memory can be accessed using a _pointer_. A pointer containing the address of a variable is said to "point" to that variable.

Recall that when you declare a variable, a contiguous block of bytes is reserved in memory. A pointer to a variable is the address of the first of these bytes. A pointer can be created for every type of variable: be it primitive (for example `int`, `char`, or `double`), a custom data type created using a `struct` (we'll cover those in a later lesson), or even another pointer. The syntax of a pointer is the following:

> dataType* nameOfPointer;

or

> dataType *nameOfPointer;


For example, to declare a pointer variable (called `ptr`) that points to an `int`, you would write:

```cpp
int* ptr; // Pointer to an int
int *ptr; // Same as above but different style.
```
In this case, `ptr` stores the address of the first byte of a block of memory containing an `int`. To print this address to the screen, `printf()` is used like so:
```cpp
int x; // Create an int variable
int* ptr = &x; // Pointer to that int (we'll dive into what "&" means in the coming exercises)
printf("%p", ptr); // %p needed to instruct printf() that ptr is of type pointer
```
This will output a hexadecimal integer that represents the address in memory that is storing a variable of type `int`. This number will be different every time the program is executed. 

If we had another pointer named `ptr2` that doesn't point to a declared variable, printing it will result in `(nil)` rather than a hexadecimal address:
```cpp
int* ptr2;
printf("%p", ptr2); // Prints: (nil)
```

In later exercises, we will see how to use pointers.