Pointers.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pointers\n",
    "http://www.cplusplus.com/doc/tutorial/pointers/\n",
    "\n",
    "## Topics\n",
    "- Computer Memory (RAM)\n",
    "- Pointers - declaring and using pointers\n",
    "- Pointer arithmetics\n",
    "- Dynamic memory (Heap)\n",
    "- Function pointers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Headers\n",
    "- run include headers and helper function cells if Kernel crashes or is restarted\n",
    "- you do not need to include any special header to use pointers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "// include headers\n",
    "#include <iostream>\n",
    "#include <string>\n",
    "\n",
    "using namespace std;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 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",
    "    - literal values do not have identifiers associated with them\n",
    "- variables are programmer-controlled identifiers that maps to some memory location (address)\n",
    "    - CPU uses memory addresses\n",
    "    - programmers use identifiers/variables\n",
    "- the following figure depicts a simple representation of RAM\n",
    "\n",
    "![](resources/memory-layout.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"pointers\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pointers\n",
    "- special variables that can store physical memory addresses identifiers (variables and functions)\n",
    "- variables represent values and are used interchangebly\n",
    "- pointers represent memory addresses 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",
    "![](resources/pointers-in-cpp.jpg)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pointer applications\n",
    "- pointers are powerful features of C/C++ programming language\n",
    "- pointers allow programmers to directly manipulate memory!\n",
    "- there are many advanced applications of pointers; some basic examples are demonstrated below"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Address of operator  (&)\n",
    "- the address of a variable can be obtained by *address-of-operator (& - ampersand symbol)* infront of a variable name\n",
    "- `&` is also used in function parameters for pass-by reference"
   ]
  },
  {
   "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"
     ]
    }
   ],
   "source": [
    "cout << \"value of num = \" << num << endl;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "address of num = 0x1093fc620\n"
     ]
    }
   ],
   "source": [
    "cout << \"address of num = \" << &num << endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dereference operator (\\*)\n",
    "- `*` - *(dereference operator represented by asterick)* can be used to read the **value pointed to by** some memory address"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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": 1,
   "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": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "200"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pNum1 = &num1; // assigning 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",
      "pNum1 = 0x10614b2d8\n",
      "num1 = 200\n",
      "&num1 = 0x10614b2d8\n"
     ]
    }
   ],
   "source": [
    "// access values of variables and pointers\n",
    "cout << \"*pNum1 = \" << *pNum1 << endl;\n",
    "cout << \"pNum1 = \" << 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": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0x10614b2d8"
     ]
    }
   ],
   "source": [
    "cout << pNum1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "@0x7ffeee048040"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pNum1 += 424000; // add 10 to pNum1 value (address)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pNum1 = 0x1062ee1f8"
     ]
    }
   ],
   "source": [
    "cout << \"pNum1 = \" << pNum1;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*pNum1 = 1089434379"
     ]
    }
   ],
   "source": [
    "// now what value is pNum1 pointing to\n",
    "cout << \"*pNum1 = \" << *pNum1;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "// let's subtract 10\n",
    "pNum1 -= 10;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pNum1 = 0x10614b2d8\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",
    "- however, pointers can 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 valid 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": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "// invalid pointers\n",
    "string *p, *q; // uninitialized pointer\n",
    "string some_num; // uninitialized variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = &some_num;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "cout << *p << endl;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0x10694d5d0"
     ]
    }
   ],
   "source": [
    "cout << p;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "// add 10 to address of some_num\n",
    "p += 10;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "cout << *p << endl;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0x10694d6c0"
     ]
    }
   ],
   "source": [
    "cout << p;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[1minput_line_56:2:11: \u001b[0m\u001b[0;1;35mwarning: \u001b[0m\u001b[1mnull passed to a callee that requires a non-null argument [-Wnonnull]\u001b[0m\n",
      " cout << *q << endl;\n",
      "\u001b[0;1;32m          ^\n",
      "\u001b[0m"
     ]
    },
    {
     "ename": "Interpreter Exception",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "Interpreter Exception: "
     ]
    }
   ],
   "source": [
    "cout << *q << 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** segment\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",
    "\n",
    "### visualize in pythontutor.com: https://goo.gl/5qse7L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "// allocate dynamic memory\n",
    "int * numb1 = new int;\n",
    "int * numb2 = new int;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0x7fd15449e140 0x7fd1544d7d20"
     ]
    }
   ],
   "source": [
    "cout << numb1 << \" \" << numb2;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "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": 44,
   "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": [
    "## 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": 6,
   "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": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "// example 1: pass address of regular variables\n",
    "int n1, n2 = 0;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "// example 2: pass values of dynamic variables/pointers\n",
    "int * ptr1 = new int;\n",
    "int * ptr2 = new int;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "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": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "// side effect example!\n",
    "int myAdd(const int * p1, const int * p2) {\n",
    "    //*p1 = 1000;\n",
    "    //*p2 = 2000;\n",
    "    return *p1 + *p2;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 + 200 = 3000\n"
     ]
    }
   ],
   "source": [
    "cout << *ptr1 << \" + \" << *ptr2 << \" = \" << myAdd(ptr1, ptr2) << endl;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// however, values pointed to by ptr1 and ptr2 have been changed by myAdd!\n",
    "cout << *ptr1 << \" + \" << *ptr2 << endl; "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// prevent side effect by passing pointers as const (read-only)\n",
    "int myAddBetter(const int * p1, const int * p2) {\n",
    "    *p1 = 1000; // not allowed as compiler will throw error!\n",
    "    *p2 = 2000; // not allowed!\n",
    "    return *p1 + *p2;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// prevent side effect by passing pointers as const (read-only)\n",
    "int myAddBetter(const int * p1, const int * p2) {\n",
    "    return *p1 + *p2;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "*ptr1 = 100;\n",
    "*ptr2 = 200;\n",
    "cout << *ptr1 << \" + \" << *ptr2 << \" = \" \n",
    "    << myAddBetter(ptr1, ptr2) << endl;\n",
    "cout << *ptr1 << \" + \" << *ptr2 << endl; \n",
    "// values of *ptr1 and *ptr2 guaranteed to stay the same!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pointers to functions\n",
    "- pointers can store addresses of functions as well; called function pointers\n",
    "- used for passing a function as an argument to another higher order function\n",
    "- declaring function pointer is very similar to declaring functions\n",
    "- parenthesis around function pointer name is required!\n",
    "- syntax:\n",
    "```c++\n",
    "    type (* functionPtrName) ( parameter list... );\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "// function that takes two integers and returns the sum\n",
    "int addition (int a, int b) { \n",
    "    return a + b; \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1"
     ]
    }
   ],
   "source": [
    "cout << &addition;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "int subtraction (int a, int b) {\n",
    "    return a - b;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "// function pointer; copy the address of subtraction into sub function pointer\n",
    "int (*sub)(int, int) = subtraction;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-10\n",
      "-10"
     ]
    }
   ],
   "source": [
    "// calling a function pointer is very similar to calling a function\n",
    "cout << (*sub)(10, 20) << endl;\n",
    "cout << subtraction(10, 20);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "// passing function to a function!\n",
    "// operation function takes 3 arguments\n",
    "// two integers and one function pointer\n",
    "int operation (int x, int y, int (*func)(int, int)) {\n",
    "  int ans;\n",
    "  ans = (*func)(x, y); // dereferece function; call func and store the result in ans\n",
    "  return ans;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "int x=10, y;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y = 90\n"
     ]
    }
   ],
   "source": [
    "y = operation(100, x, sub);\n",
    "cout << \"y = \" << y << endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Labs\n",
    "\n",
    "1. The following lab demonstrates the usage of pointers, enum type and user-defined namespace.\n",
    "    - use `pointers.cpp` file found in [labs/pointers](./labs/pointers) folder as a hint to complete the program\n",
    "    - use Makefile to compile and build the program\n",
    "    - fix al the FIXMEs and write #FIXED next to each fixme once fixed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "\n",
    "1. Write a program that determines area and perimeter of a rectangle.\n",
    "    - must use pointers and dynamic memory to store data\n",
    "    - must use functions to find area and perimeter\n",
    "    - prompt user to enter length and widht of a rectangle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// Solution to exercise 1\n",
    "#include <iostream>\n",
    "#include <cmath>\n",
    "\n",
    "using namespace std;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "float areaRectangle(float * length, float * width) {\n",
    "    return (*length) * (*width);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "float perimeterRectangle(float * length, float * width) {\n",
    "    return 2*(*length + *width);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "void solve() {\n",
    "    float * length = new float; //dynamic memory\n",
    "    float * width = new float; //dynamic memory\n",
    "    cout << \"Enter length and width of a rectangle separated by space: \";\n",
    "    cin >> *length >> *width;\n",
    "    cout << \"rectangle dimension: \" << *length << \" x \" << *width << endl;\n",
    "    cout << \"area of the rectangle: \" << areaRectangle(length, width) << endl;\n",
    "    cout << \"perimeter of the rectangle: \" << perimeterRectangle(length, width) << endl;\n",
    "    // deallocate dynamic memory pointed to by length and width\n",
    "    length = nullptr;\n",
    "    width = nullptr;\n",
    "    delete length;\n",
    "    delete width;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// you'd call this function in main() in a complete C++ program file\n",
    "solve();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### a complete demo program\n",
    "- complete C++ using all the concepts covered so far using pointers and dynamic memory is provided here [demos/pointers/rectangle](demos/pointers/rectangle)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Write a program using dynamic memory that determines area and circumference of a circle.\n",
    "    - must use functions to find the required answers\n",
    "    - prompt user to enter radius of a circle\n",
    "    \n",
    "\n",
    "\n",
    "## Kattis problems\n",
    "\n",
    "- pointers and dynamic variables are not requirement to solve any Kattis problems\n",
    "- as you solve harder problems requiring advanced data structrues and algorithms, you'll naturally use pointers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary\n",
    "- learned about the basics of RAM and pointers\n",
    "- declaring and using pointers\n",
    "- function pointers and passing pointers to functions\n",
    "- exercises and sample solutions"
   ]
  },
  {
   "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": 2
}