Pointers.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pointers and Applications\n",
    "http://www.cplusplus.com/doc/tutorial/pointers/\n",
    "\n",
    "## Computer Memory (RAM)\n",
    "- the primary memory of computer is also called RAM (Random Access Memory)\n",
    "- program must be loaded into RAM before it can be executed \n",
    "- data must be loaded into RAM before program can use it\n",
    "- literal values or variables are all stored in memory\n",
    "    - literaly values do not have identifiers associated with them\n",
    "- variables are programmer-controlled identifiers that maps to some memory location (address)\n",
    "    - program uses memory addresses\n",
    "    - programmers uses identifiers/variables\n",
    "- the following figure depicts a simple representation of RAM\n",
    "\n",
    "![](media/memory-layout.png)\n",
    "\n",
    "## Pointers\n",
    "- special variables that can store physical memory addresses of variables and identifiers\n",
    "- variables represent values and are used interchangebly\n",
    "- pointers represent memory address and and are used interchangebly\n",
    "- like any variable, you must declare a pointer before you can use it\n",
    "- the following figure helps visualize pointer variable\n",
    "\n",
    "![](media/pointers-in-cpp.jpg)\n",
    "\n",
    "## Pointer applications\n",
    "- pointers are powerful features of C/C++ programs\n",
    "- allows you to directly manipulate memory!\n",
    "- there are many applications of pointers; some basic applications are demonstrated below\n",
    "\n",
    "### Address-of operator (&)\n",
    "- the address of a variable can be obtained by *address-of-operator (&)* infront of a variable name\n",
    "- `&` is also used in function parameters for pass-by reference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <iostream>\n",
    "#include <cstdio>\n",
    "\n",
    "using namespace std;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "int num = 100;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value of num = 100\n",
      "address of num = 0x1045c4630\n"
     ]
    }
   ],
   "source": [
    "cout << \"value of num = \" << num << endl;\n",
    "cout << \"address of num = \" << &num << endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dereference operator (\\*)\n",
    "- `*` - *(dereference operator)* can be used to read the **value pointed to by** some memory address"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value pointed to by &num = 100\n"
     ]
    }
   ],
   "source": [
    "// what is stored at the address of num?\n",
    "cout << \"value pointed to by &num = \" << *(&num) << endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Declaring pointers\n",
    "- pointers can be declared using `*` de-reference/pointer operator\n",
    "- syntax:\n",
    "```c++\n",
    "    type * pointerVarName;\n",
    "```\n",
    "### visualize pointers in pythontutor.com: https://goo.gl/zhCr3G"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "// declare pointers\n",
    "int num1; // variable NOT a pointer\n",
    "int * pNum1; // declare pNum1 of type int or pointer to int\n",
    "// declare and initialize pointers\n",
    "float * fltPtr = nullptr; // initialize with nullptr (pointing to no address)\n",
    "int * somePtr = &num1; // initialize somePtr with the address of num1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "200"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pNum1 = &num1; // assiging value to a pointer\n",
    "*pNum1 = 200; // dereferencing pNum1; assigning value to the location pointed to by pNum1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*pNum1 = 200\n",
      "pNum = 0x1045c4a60\n",
      "num1 = 200\n",
      "&num1 = 0x1045c4a60\n"
     ]
    }
   ],
   "source": [
    "// access values of variables and pointers\n",
    "cout << \"*pNum1 = \" << *pNum1 << endl;\n",
    "cout << \"pNum = \" << pNum1 << endl;\n",
    "cout << \"num1 = \" << num1 << endl;\n",
    "cout << \"&num1 = \" << &num1 << endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pointer arithmetic\n",
    "- you can add or subtract values to or from pointers\n",
    "    - pointers will simply point to a different memory location!\n",
    "- one can move the pointer around pointing to various memory locations\n",
    "    - that can be dangerous from security point of view!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "@0x7ffee5c388d0"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pNum1 += 10; // add 10 to pNum1 value (address)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pNum1 = 0x10e34dfa8"
     ]
    }
   ],
   "source": [
    "cout << \"pNum1 = \" << pNum1;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*pNum1 = 0"
     ]
    }
   ],
   "source": [
    "// now what value is pNum1 pointing to\n",
    "cout << \"*pNum1 = \" << *pNum1;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "// let's subtract 10\n",
    "pNum1 -= 10;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pNum1 = 0x10e34df80\n",
      "*pNum1 = 200"
     ]
    }
   ],
   "source": [
    "cout << \"pNum1 = \" << pNum1 << endl;\n",
    "cout << \"*pNum1 = \" << *pNum1;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Invalid pointers and null pointers\n",
    "- pointers are meant to point to valid addresses, in principle\n",
    "- pointers can also point to any any address, including addresses that do not refer to any valid element\n",
    "    - e.g., uninitialized pointers and pointers to non-existent elements of an array\n",
    "- neither p nor q point to addresses known to contain a value in the following cell\n",
    "- they do not cause error while declaring...\n",
    "- but can cause error/problem if dereferenced such pointers\n",
    "    - may crash program or point to a random data in memory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "// invalid pointers\n",
    "int * p; // uninitialized pointer\n",
    "int some_num; // uninitialized variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "@0x7ffee5c388d0"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = (&some_num); // add 10 to address of some_num"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "cout << *p << endl;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "cout << * << endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dynamic memory\n",
    "- memory needs from auto/local variables are determined during compile time before program executes\n",
    "- at times memory needs of a program can only be determined during the runtime\n",
    "    - e.g., when amount and type of memory needed depends on user input\n",
    "- in such cases, program needs to dynamically allocate memory\n",
    "- pointers are used along with other keywords **new** and **delete** to allocate and deallocate dynamic memory\n",
    "- dynamic memory is allocated in **heap** segment\n",
    "    - unlike regular auto variables that are declared on **stack**\n",
    "- dynamic memory must be deallocated to prevent memory leak in the program\n",
    "- syntax to allocate and deallocate dynamic memory:\n",
    "\n",
    "```c++\n",
    "    // allocate memory\n",
    "    type * pointer = new type;\n",
    "\n",
    "    // deallocate memory\n",
    "    delete pointer;\n",
    "```\n",
    "- visualize in pythontutor.com: https://goo.gl/5qse7L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "// allocate dynamic memory\n",
    "int * numb1 = new int;\n",
    "int * numb2 = new int;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 + 50 = 150\n",
      "100 - 50 = 50\n",
      "100 * 50 = 5000\n"
     ]
    }
   ],
   "source": [
    "// use dynamic memory\n",
    "*numb1 = 100;\n",
    "*numb2 = 50;\n",
    "cout << *numb1 << \" + \" << *numb2 << \" = \" << *numb1 + *numb2 << endl;\n",
    "cout << *numb1 << \" - \" << *numb2 << \" = \" << *numb1 - *numb2 << endl;\n",
    "cout << *numb1 << \" * \" << *numb2 << \" = \" << *numb1 * *numb2 << endl;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "// delete dynamic memory\n",
    "// intialize them to nullptr just incase garbage collector has not deallocated numb1 and numb2 yet!\n",
    "numb1 = nullptr;\n",
    "numb2 = nullptr;\n",
    "delete numb1;\n",
    "delete numb2;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Void pointers and pointer types\n",
    "- pointers do have types\n",
    "- the type of pointer is the data type of the memory address it's pointing to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "char charArray[5] = {'a', 'b', 'c', '1', '2'};"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "// cast the type of charArray to void *\n",
    "void * voidPtr = (void *)charArray;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[char pointer] points to 0x7ffff7e45028 with value 'a'\n",
      "[char pointer] points to 0x7ffff7e45029 with value 'b'\n",
      "[char pointer] points to 0x7ffff7e4502a with value 'c'\n",
      "[char pointer] points to 0x7ffff7e4502b with value '1'\n",
      "[char pointer] points to 0x7ffff7e4502c with value '2'\n"
     ]
    }
   ],
   "source": [
    "// use voidPtr to traverse the charArray\n",
    "for(int i=0; i<5; i++) {\n",
    "    printf(\"[char pointer] points to %p with value '%c'\\n\", voidPtr, *((char *) voidPtr));\n",
    "    voidPtr = (void *)((char *) voidPtr + 1);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Passing pointers to functions\n",
    "- pointers can be passed to functions\n",
    "- similar to passed-by-reference \n",
    "    - if value pointed to by formal pointer parameter is changed, the value pointed to by actual pointer parameter will also be changed!\n",
    "- pass pointers as constants (read-only) to prevent the side effect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "// function that takes two int pointers\n",
    "int addInts(int * p1, int * p2) {\n",
    "    return *p1 + *p2;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "// example 1: pass address of regular variables\n",
    "int n1, n2 = 0;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 + 15 = 25\n"
     ]
    }
   ],
   "source": [
    "n1 = 10; n2 = 15;\n",
    "cout << n1 << \" + \" << n2 << \" = \" << addInts(&n1, &n2) << endl;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "// example 2: pass ptr/dynamic variables\n",
    "int * ptr1 = new int;\n",
    "int * ptr2 = new int;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 + 200 = 300\n"
     ]
    }
   ],
   "source": [
    "*ptr1 = 100;\n",
    "*ptr2 = 200;\n",
    "cout << *ptr1 << \" + \" << *ptr2 << \" = \" << addInts(ptr1, ptr2) << endl;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "C++14",
   "language": "C++14",
   "name": "xcpp14"
  },
  "language_info": {
   "codemirror_mode": "text/x-c++src",
   "file_extension": ".cpp",
   "mimetype": "text/x-c++src",
   "name": "c++",
   "version": "14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}