~~SLIDESHOW~~
~~NOTOC~~

====== Pointers 1 slides ======
Pointer fundamentals, syntax, and operations.((Portions loosely adapted from:
Deitel, Harvey M., and Paul J. Deitel. "Pointers and Strings." In //C++: How to Program//. 3 ed. Upper Saddle River, NJ: Prentice Hall, 2001. 304-388.))\\ 
Mithat Konar\\
October 19, 2021

===== Introduction =====
  * **Pointers** found in many programming languages.
  * Important in C++ because a close relationship between pointers and arrays, C strings, and references.

===== Pointer variables =====
  * Variables are stored in blocks of computer memory.
  * **base address**: the memory address of the first byte of this block.
  * **pointer variable**: a variable that stores the base address of some other variable.
  * Usefulness will be seen after understanding how to use them.

===== Two ways to think about pointers =====
  * Pointers hardware model
  * Pointer visual model

===== Pointer hardware model =====
  * Assume an ''int'' named ''count'' storing the value 7 and ''int''s occupy 4 bytes.

^ Variable name ^ Memory location ^ Memory contents across all four bytes (32 bits)^
|''count''|58000|''00000000000000000000000000000111''\\ (i.e. 7 in decimal)|
|:::|58001|:::|
|:::|58002|:::|
|:::|58003|:::|

  * The address of ''count'' is the base address 58000. 

===== Pointer hardware model =====

  * A //pointer// variable set to point to ''count'' would store the value 58000.

^ Variable name ^ Memory location ^ Memory contents across all 8 bytes (64 bits) ^
|''countPtr''|64002|''00000000000000000000000000000000\\ 00000000000000001110001010010000''\\ (58000 in decimal)|
|:::|64003|:::|
|:::|...|:::|
|:::|64009|:::|

  * The //value// of a pointer variable is the base address of another variable.

===== Pointer visual model =====

Given the ''count'' variable used above:
{{ :cplusplus:ptr01.png?nolink |}}
a pointer variable ''countPtr'' pointing to ''count'' would be represented as:
{{ :cplusplus:ptr02.png?nolink |}}

The //value// of ''countPtr'' is the box the arrow points to (i.e., the integer  ''count'').

===== Pointer visual model =====

Changing the value of ''countPtr'' to point to ''num'':
{{ :cplusplus:ptr03.png?nolink |}}

===== Pointer syntax basics =====

===== Pointer declaration =====
  * ''*'' character is used to indicate pointer variables in declarations and function parameter lists.
  * Type of data being pointed to must also be indicated.

<code cpp>
int *myPtr;     // declare a pointer to an int
bool *yourPtr;  // declare a pointer to a bool
</code>

  * Location of the ''*'' character is flexible:

<code cpp>
int *myPtr;
int* myPtr;
int * myPtr;
</code>

===== Pointer declaration =====

  * You can declare more than one pointer variable at a time:

<code cpp>int *myPtr, *anotherOne;   // declare two pointers to an int</code>

  * But be careful::

<code cpp>int* myPtr, anotherOne;   // a pointer and an int</code>

===== Address operator =====
  * To set the value of a pointer, you need the address of something.
  * **address operator** ''&'' returns the base address of a variable:

<code cpp>
int num = 42;
cout << num << endl;   // prints value held in variable num
cout << &num << endl ; // prints the base address of variable num
</code>

  * Most environments show base addresses as [[http://www.cplusplus.com/doc/hex/|hexadecimal]] numbers.

===== Pointer assignment =====

  *  Declare an integer variable ''y'' and a pointer variable ''myPtr'' set to store the address of ("point to") ''y''.
<code cpp>
int y = 5;   // declare an integer variable y
int *myPtr;  // declare a pointer to int
myPtr = &y;  // myPtr gets address of ("points to") y
</code>

{{:cplusplus:ptr04a.png?nolink|}}

===== Pointer assignment =====

  *  Declare an integer variable ''y'' and a pointer variable ''myPtr'' set to store the address of ("point to") ''y''.
<code cpp>
int y = 5;   // declare an integer variable y
int *myPtr;  // declare a pointer to int
myPtr = &y;  // myPtr gets address of ("points to") y
</code>

^ Variable name ^ Memory location ^ Memory contents  ^
|''y''|52000|5|
|:::|...|:::|
|:::|52003|:::|
|...|...|...|
|''myPtr''|63002|52000|
|:::|...|:::|
|:::|63009|:::|


===== Pointer assignment =====

  * Changing the value of pointer variables:

<code cpp>
double z = 3.33;
double x = 42.0;
double *myPtr;

myPtr = &z;   // myPtr gets address of z
myPtr = &x;   // myPtr now has address of x
</code>

===== Pinter initialization =====
  * Local pointer variables in C++ are not automatically initialized. 
  * Uninitialized pointers point to arbitrary memory. //Very dangerous.//
  * You can initialize when declared:

<code cpp>
int y = 5;
int *myPtr = &y;  // myPtr gets address of y
</code>

===== nullptr/NULL pointers =====

  * You can set a pointer to a value that indicates that it is //pointing to nothing//: ''nullptr'' (C++11) or ''NULL'' (earlier versions).
  * Otherwise uninitialized pointers should be set to ''nullptr'' (or ''NULL'').

<code cpp>
int *yourPtr = nullptr; // yourPtr points to nothing
int y = 5;
yourPtr = &y;           // yourPtr gets address of y</code>

  * ''nullptr'' and ''NULL'' have an integer value of ''0'', so sometimes programmers use ''0'' or '''\0'''.

===== Operators for pointers =====

  *  **address operator** ''&'' (already covered).
  *  **indirection** or **dereferencing operator** ''*'' (covered next).

===== Indirection/dereferencing operator =====

  * **indirection** or **dereferencing** operator, ''*'', accesses the value of what its operand points to.

<code cpp>
int y = -1;       // declare y and initialize its value
int *myPtr = &y;  // declare pointer and set it to point to y

cout << *myPtr;   // defererence myPtr (prints -1)</code>

===== Indirection/dereferencing operator =====

  * Dereferencing can be used to assign a value to a location in memory:

<code cpp>
int y = -1;       // declare y and initialize its value
int *myPtr = &y;  // declare pointer and set it to point to y

*myPtr = 7;       // change value in y to 7
cout << y;        // prints 7</code>

  * You can think of the indirection/dereferencing operator as meaning, “the_thing_at_the_end_of_”, as in:

<code>the_thing_at_the_end_of_myPtr = 7;</code>

===== Indirection/dereferencing operator =====

  * ''*'' and ''&'' operators complement each other.
  * The following expressions all evaluate as true:

<code cpp>
*&y == y
&*myPtr == myPtr
*&myPtr == myPtr</code>

===== Example =====

<file cpp pointer-example.cpp>/** Demonstrate basic pointer usage. */
#include <iostream>
using namespace std;
int main()
{
    int a;                  // a is an integer
    int *aPtr = nullptr;    // aPtr is a pointer to an integer
 
    a = 7;      // give a a value
    aPtr = &a;  // set aPtr to the address of a
 
    cout << "The value of a is:     " << a << endl
         << "The address of a is:   " << &a << endl
         << "The value of aPtr is:  " << aPtr << endl;
    cout << endl;
 
    cout << "The value of a is:     " << a << endl
         << "The value of *aPtr is: " << *aPtr << endl;
    cout << endl;
 
    cout << "Showing that * and & are inverses of each other:"
         << endl
         << "&*aPtr = " << &*aPtr << endl
         << "*&aPtr = " << *&aPtr << endl;

    return 0;
}
</file>