UserDefinedFunctionsTesting.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# User Defined Functions and Testing\n",
    "\n",
    "## Topics\n",
    "- adding new functions\n",
    "- using functions\n",
    "- function types\n",
    "- ways to pass data to functions\n",
    "- function prototypes and their purpose\n",
    "- debugging and automatically testing functions\n",
    "- scopes and name resolution process"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding new functions\n",
    "\n",
    "- we've used several functions provided in various standard libraries\n",
    "- **main( )** is a function that is required for any C++ program\n",
    "    - indicates where the execution of the program begins\n",
    "- one can add as many functions as required in the program\n",
    "- function is a block of code that execute as a group\n",
    "- the ultimate goal of the function is to break the given problem into smaller sub-problems\n",
    "    - solve each sub-problem with a function\n",
    "- if you have many tasks/steps in algoritm steps, function can be used to solve each task/step\n",
    "- using function is a two-step process\n",
    "    1. define a function\n",
    "    2. call or use the function\n",
    "\n",
    "### Why functions?\n",
    "\n",
    "- dividing a program into functions or sub-programs has several advantages:\n",
    "    - each sub-problem can be solved using a function\n",
    "    - makes it easier to design a solution to a big problem\n",
    "    - makes the solution modular\n",
    "    - helps reuse the code\n",
    "        - function once defined can be used many times!\n",
    "    - makes the solution or main() concise\n",
    "    - helps test and update a part of program without affecting the rest\n",
    "    - makes it easier to work in a team where each member can focus on a function\n",
    "\n",
    "\n",
    "### Syntax to define a function\n",
    "\n",
    "- function gives a block of code (body) a name of your choice\n",
    "\n",
    "```cpp\n",
    "    type FUNCTION_NAME ( ) {\n",
    "       // body \n",
    "    }\n",
    "```\n",
    "\n",
    "- new function naming conventions:\n",
    "    - can't call it main()\n",
    "    - can't reuse identifiers or keywords\n",
    "    - plus same as variable naming conventions!\n",
    "  \n",
    "### Syntax to call a function\n",
    "\n",
    "- functions are called by their name\n",
    "\n",
    "```cpp\n",
    "    NAME();\n",
    "```\n",
    "\n",
    "- typically, functions are defined outside **main( )** in global scope and called inside **main( )**\n",
    "- however, one function can call another function\n",
    "- the function that calls another function is called **caller**\n",
    "- the function being called is called **callee**\n",
    "- let's define some functions and use them..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <iostream>\n",
    "using namespace std;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "//1. define a function that prints Hello World!\n",
    "void sayHello() {\n",
    "    cout << \"Hello World!\" << endl;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "// 2. call sayHello\n",
    "sayHello();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "// define a function that prints Hello World! three times\n",
    "// caller function\n",
    "void sayHelloThrice() {\n",
    "    // caller calls other functions\n",
    "    sayHello(); // callee\n",
    "    sayHello(); // callee\n",
    "    cout << \"Hello World!\" << endl;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n",
      "Hello World!\n",
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "// call sayHelloThrice\n",
    "sayHelloThrice();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parameters and arguments\n",
    "\n",
    "- functions are sub-programs/sub-routines that can take some data/values to manipulate\n",
    "- we've used some built-in functions that take arguments\n",
    "    - `float(val)`, `int(val)`, `char(val)`, `setw(arg)`, etc.\n",
    "- `parameter` is the way to send/pass data to function so the function can do its job\n",
    "    - placeholders for data to be copied into\n",
    "    - also called **formal parameters**\n",
    "- in algebra we may define equations as:\n",
    "\n",
    "```\n",
    "    y = f(x) = x^2 + x + 2\n",
    "    find y, given x = 1: f(1) = 1^2 + 1 + 2 = 4\n",
    "    find y, given x = -10: f(-10) = (-10)^2 + (-10) + 2 = 92\n",
    "```\n",
    "\n",
    "- programming functions burrow the notion from algebraic functions\n",
    "- parameters help us define generic functions that computes answer based on the given data value\n",
    "- the data/value that is passed into the parameter is called argument\n",
    "- `x` is parameter and `1` and `-10` are arguments\n",
    "- functions with parameters are more useful because they can work on a range of different values\n",
    "- syntax to define function with parameters:\n",
    "```cpp\n",
    "    type NAME(type PARAMETER1, type PARAMETER2, ...) {\n",
    "        // body\n",
    "    }\n",
    "```\n",
    "- parameters are variables (have types and names)\n",
    "    - eventually will have values of same type when the function is called\n",
    "- syntax to call function with parameters:\n",
    "```cpp\n",
    "    NAME(argument1, argument2, ...);\n",
    "```\n",
    "- function must be called passing the same number of arguments as the no. of parameters\n",
    "- types of corresponding arguments and parameters must match from left to right\n",
    "- arguments can be literal values or variables\n",
    "- by default values of arguments are copied to corresponding parameters\n",
    "    - value/argument1 is copied to PARAMETER1\n",
    "    - value/argument2 is copied to PARAMETER2, and so on...\n",
    "- arguments passed to functions are also called **actual parameters**\n",
    "    - represent the actual data that are acutally passed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "// define a function that greets a person by their name\n",
    "#include <string>\n",
    "\n",
    "// name is the only parameter of type string\n",
    "void greeting(string name) {\n",
    "    cout << \"Hello there, \" << name << endl;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[1minput_line_16:3:1: \u001b[0m\u001b[0;1;31merror: \u001b[0m\u001b[1mno matching function for call to 'greeting'\u001b[0m\n",
      "greeting();\n",
      "\u001b[0;1;32m^~~~~~~~\n",
      "\u001b[0m\u001b[1minput_line_15:2:6: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate function not viable: requires single argument 'name', but no arguments were provided\u001b[0m\n",
      "void greeting(string name) {\n",
      "\u001b[0;1;32m     ^\n",
      "\u001b[0m"
     ]
    },
    {
     "ename": "Interpreter Error",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "Interpreter Error: "
     ]
    }
   ],
   "source": [
    "// wrong way... calling greeting without argument will generate error!\n",
    "greeting();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello there, John\n"
     ]
    }
   ],
   "source": [
    "// right way: calling greeting with one string argument\n",
    "greeting(\"John\"); // passing literal value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[1minput_line_18:3:1: \u001b[0m\u001b[0;1;31merror: \u001b[0m\u001b[1mno matching function for call to 'greeting'\u001b[0m\n",
      "greeting(123);\n",
      "\u001b[0;1;32m^~~~~~~~\n",
      "\u001b[0m\u001b[1minput_line_15:2:6: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate function not viable: no known conversion from 'int' to 'std::__1::string' (aka\n",
      "      'basic_string<char, char_traits<char>, allocator<char> >') for 1st argument\u001b[0m\n",
      "void greeting(string name) {\n",
      "\u001b[0;1;32m     ^\n",
      "\u001b[0m"
     ]
    },
    {
     "ename": "Interpreter Error",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "Interpreter Error: "
     ]
    }
   ],
   "source": [
    "// wrong way to call greeting passing wrong type of argument\n",
    "greeting(123);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "// calling greeting with passing the data in variable\n",
    "// name of the argument has nothing to do with name of the parameter\n",
    "// only the type needs to match!\n",
    "string somename;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello there, Jake\n"
     ]
    }
   ],
   "source": [
    "somename = \"Jake\";\n",
    "greeting(somename); // access the value of somename and pass/copy to greeting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "// define a function that takes two numbers and prints the sum as result\n",
    "void sum(int num1, int num2) {\n",
    "    long total = num1 + num2;\n",
    "    cout << num1 << \" + \" << num2 << \" = \"  << total << endl; \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 + 20 = 30\n"
     ]
    }
   ],
   "source": [
    "// call sum passing to int values\n",
    "sum(10, 20);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Types of functions\n",
    "- functions can be roughly divided into two types:\n",
    "    1. void functions or fruitless functions\n",
    "        - functions that do not return any value\n",
    "        - all the functions defined previously in this notebook are void functions\n",
    "        - NOTE: printing result/value is NOT the same as returning value\n",
    "    2. type functions or fruitful functions\n",
    "        - functions that return a value\n",
    "- syntax of fruitful functions\n",
    "\n",
    "```cpp\n",
    "    type NAME(type PARAMETER1, ...) {\n",
    "        // body\n",
    "        return someValue;\n",
    "    }\n",
    "```\n",
    "\n",
    "- type of the return value must match the type of the function NAME\n",
    "- fruitful parameterized functions are the most useful ones\n",
    "    - can use the returned value however you want!\n",
    "    - can automatically test the results from the functions\n",
    "    - most library functions are fruitful and parameterized"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "// define a function that takes two numbers and returns their sum\n",
    "long find_sum(int num1, int num2) {\n",
    "    long total = num1 + num2;\n",
    "    return total;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// call function with values\n",
    "find_sum(12, 8);\n",
    "// where is the returned value or result?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "// you must find a way to use the returned value\n",
    "// print the returned value from find_sum function\n",
    "cout << find_sum(12, 8) << endl;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "// assign the returned value from find_sum(...) to a variable\n",
    "long ans = find_sum(99, 1);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// let's see the value of ans\n",
    "ans"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Passing data/value or reference\n",
    "- C++ provides two ways to pass data to functions:\n",
    "    1. pass by value\n",
    "    2. pass by reference\n",
    "    \n",
    "### Pass by value\n",
    " - data of argument or actual parameter is copied into formal parameter\n",
    " - the default way of passing data/values to the functions\n",
    " - easier to understand; no side effect\n",
    "     - changing the formal parameter doesn't affect the actual parameter\n",
    " - slower, however, to copy large amount of data\n",
    " - since the data is copied, anything done to the data via parameter doesn't affect the data in actual argument\n",
    "     - if the formal parameter is modified, the actual parameter or argument is not modified!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "// function to demonstrate pass by value\n",
    "// num1 and num2 are also called formal parameters\n",
    "long another_sum(int num1, int num2) {\n",
    "  num1 += 10; // we don't do this, but only to demonstrate pass by value\n",
    "  num2 += 20;\n",
    "  long total = num1 + num2;\n",
    "  return total;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "// pass data stored in variables; declare variables\n",
    "int n1, n2;\n",
    "long answer;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20 + 30 = 80\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "@0x10b918558"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n1 = 20;\n",
    "n2 = 30;\n",
    "// n1 and n2 are actual parameters or arguments\n",
    "answer = another_sum(n1, n2);\n",
    "cout << n1 << \" + \" << n2 << \" = \" << answer << endl;\n",
    "// gives wrong answer because another_sum() is not correctly implemented\n",
    "// at least values of n1 and n2 remain intact, because of the way pass by value works!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualize pass by value on [pythontutor.com](http://pythontutor.com/cpp.html#code=//%20pass%20by%20value%20demo%0A%23include%20%3Ciostream%3E%0Ausing%20namespace%20std%3B%0A%0Along%20sum%28int%20num1,%20int%20num2%29%20%7B%0A%20%20num1%20%2B%3D%2010%3B%0A%20%20num2%20%2B%3D%2020%3B%0A%20%20long%20total%20%3D%20num1%20%2B%20num2%3B%0A%20%20return%20total%3B%0A%7D%0A%0Aint%20main%28%29%20%7B%0A%20%20int%20n1,%20n2%3B%0A%20%20n1%20%3D%2020%3B%0A%20%20n2%20%3D%2030%3B%0A%20%20cout%20%3C%3C%20n1%20%3C%3C%20%22%20%2B%20%22%20%3C%3C%20n2%20%3C%3C%20%22%20%3D%20%22%20%3C%3C%20sum%28n1,%20n2%29%20%3C%3C%20endl%3B%0A%20%20//%20n1%20and%20n2%20still%20have%20same%20original%20values%0A%20%20return%200%3B%0A%7D&curInstr=0&mode=display&origin=opt-frontend.js&py=cpp&rawInputLstJSON=%5B%5D)\n",
    "\n",
    "### Pass by reference\n",
    "- copying data is expensive/slow operation in terms of memory usage and CPU time\n",
    "    - avoid copying data with **pass by reference** technique\n",
    "- pass by reference occurs when the parameter has **&** symbol in-between the type and name\n",
    "- syntax for pass by reference:\n",
    "\n",
    "```cpp\n",
    "    // function definition\n",
    "    type NAME(type & PARAMETER1, type & PARAMETER2,...) {\n",
    "        // body\n",
    "    }\n",
    "    // function call\n",
    "    NAME(argument1, argument2, ...);\n",
    "```\n",
    "\n",
    "- data is not copied but the reference (memory address of data) is passed to function's parameters\n",
    "    - meaning actual and formal parameter reference the same memory location\n",
    "- ONLY variable arguments (NOT literal) can be passed to the reference parameters\n",
    "- if the formal parameter is modified, the actual parameter is also modified!\n",
    "- it's efficient (only memory address of actual parameter is passed)\n",
    "    - but may have unintended side effect\n",
    "    - if the formal parameter is modified, the actual parameter is also modified\n",
    "- it also provides a way to retrieve data from functions!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "// function to demonstrate pass by reference\n",
    "// num1 and num2 are also called formal parameters that are passed by reference\n",
    "long yet_another_sum(int & num1, int & num2) {\n",
    "  num1 += 10; // for whatever reason we modify formal parameters;\n",
    "  num2 += 20; // could be a mistake\n",
    "  long total = num1 + num2;\n",
    "  return total;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[1minput_line_37:3:1: \u001b[0m\u001b[0;1;31merror: \u001b[0m\u001b[1mno matching function for call to 'yet_another_sum'\u001b[0m\n",
      "yet_another_sum(20, 30)\n",
      "\u001b[0;1;32m^~~~~~~~~~~~~~~\n",
      "\u001b[0m\u001b[1minput_line_36:3:6: \u001b[0m\u001b[0;1;30mnote: \u001b[0mcandidate function not viable: expects an l-value for 1st argument\u001b[0m\n",
      "long yet_another_sum(int & num1, int & num2) {\n",
      "\u001b[0;1;32m     ^\n",
      "\u001b[0m"
     ]
    },
    {
     "ename": "Interpreter Error",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "Interpreter Error: "
     ]
    }
   ],
   "source": [
    "// ERROR: can't pass literals for pass by reference parameters\n",
    "yet_another_sum(20, 30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30 + 50 = 80\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "@0x10b918558"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// n1 and n2 are already declared as integers above\n",
    "n1 = 20;\n",
    "n2 = 30;\n",
    "// n1 and n2 are actual parameters or arguments\n",
    "answer = yet_another_sum(n1, n2);\n",
    "cout << n1 << \" + \" << n2 << \" = \" << answer << endl;\n",
    "// gives right answer n1 and n2 values are modified"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "// swap function \n",
    "// swaps/exchanges the values of two variables\n",
    "void intSwap(int & n1, int & n2) {\n",
    "    int temp = n1;\n",
    "    n1 = n2;\n",
    "    n2 = temp;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "// let's swap the values of these two variables\n",
    "int value1 = 10;\n",
    "int value2 = 1000;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "intSwap(value1, value2);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000 10\n"
     ]
    }
   ],
   "source": [
    "cout << value1 << \" \" << value2 << endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualize pass by reference on [pythontutor.com](http://pythontutor.com/cpp.html#code=void%20intSwap%28int%20%26%20n1,%20int%20%26%20n2%29%20%7B%0A%20%20%20%20int%20temp%20%3D%20n1%3B%0A%20%20%20%20n1%20%3D%20n2%3B%0A%20%20%20%20n2%20%3D%20temp%3B%0A%7D%0Aint%20main%28%29%20%7B%0A%20%20//%20let's%20swap%20the%20values%20of%20these%20two%20variables%0A%20%20int%20value1%20%3D%2010%3B%0A%20%20int%20value2%20%3D%201000%3B%0A%20%20intSwap%28value1,%20value2%29%3B%0A%20%20return%200%3B%0A%7D&curInstr=0&mode=display&origin=opt-frontend.js&py=cpp&rawInputLstJSON=%5B%5D)\n",
    "\n",
    "\n",
    "### Constant parameters\n",
    "- C++ allows constant parameters\n",
    "    - prevents the formal parameters' values from being changed inside the function\n",
    "    - thus, prevents the unintended side effects\n",
    "- constant parameters are READ ONLY\n",
    "- the following example doesn't compile due to syntax error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[1minput_line_44:3:8: \u001b[0m\u001b[0;1;31merror: \u001b[0m\u001b[1mcannot assign to variable 'n1' with const-qualified type 'const int &'\u001b[0m\n",
      "    n1 += 10;\n",
      "\u001b[0;1;32m    ~~ ^\n",
      "\u001b[0m\u001b[1minput_line_44:1:44: \u001b[0m\u001b[0;1;30mnote: \u001b[0mvariable 'n1' declared const here\u001b[0m\n",
      "long sum_with_const_parameters(const int & n1, const int n2){\n",
      "\u001b[0;1;32m                               ~~~~~~~~~~~~^~\n",
      "\u001b[0m\u001b[1minput_line_44:4:8: \u001b[0m\u001b[0;1;31merror: \u001b[0m\u001b[1mcannot assign to variable 'n2' with const-qualified type 'const int'\u001b[0m\n",
      "    n2 += 20;\n",
      "\u001b[0;1;32m    ~~ ^\n",
      "\u001b[0m\u001b[1minput_line_44:1:58: \u001b[0m\u001b[0;1;30mnote: \u001b[0mvariable 'n2' declared const here\u001b[0m\n",
      "long sum_with_const_parameters(const int & n1, const int n2){\n",
      "\u001b[0;1;32m                                               ~~~~~~~~~~^~\n",
      "\u001b[0m"
     ]
    },
    {
     "ename": "Interpreter Error",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "Interpreter Error: "
     ]
    }
   ],
   "source": [
    "long sum_with_const_parameters(const int & n1, const int n2){\n",
    "    // modifying n1 and n2 constants are not allowed\n",
    "    n1 += 10;\n",
    "    n2 += 20;\n",
    "    return n1 + n2;\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Retrieving data from void functions\n",
    "- pass-by-reference can be used to retrieve one or more values/results from functions\n",
    "- since, C++ function can only return one value, pass-by-reference technique can be used to retrive more than one values from a function\n",
    "- typically, if the function's return value is too large to copy, use pass-by-reference instead of return "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "// extracting value from a function with passed by reference technique\n",
    "// num1 is passed by value num2 and sum are passed by reference\n",
    "void computeSum(int num1, int& num2, long &sum) {\n",
    "    sum = num1 + num2; // sum is modified\n",
    "    // notice void function, no return value!\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 + 300 = 400\n"
     ]
    }
   ],
   "source": [
    "n1 = 100;\n",
    "n2 = 300;\n",
    "ans = 0; // initilize ans to 0; just in case!\n",
    "// n1, n2, and ans are actual parameters or arguments\n",
    "computeSum(n1, n2, ans);\n",
    "cout << n1 << \" + \" << n2 << \" = \" << ans << endl;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "// define a function that computes and returns both area and perimeter\n",
    "// C++ doesn't allow returning multiple values from a function\n",
    "// use pass-by-reference technique!\n",
    "void area_and_perimeter(const float & l, const float & w, float & area, float & peri) {\n",
    "    area = l*w;\n",
    "    peri = 2*(l+w);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "float len = 4.5;\n",
    "float width = 3.99;\n",
    "float area, perimeter;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "area_and_perimeter(len, width, area, perimeter);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17.9550f"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16.9800f"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "perimeter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualize retrieving data from function using pass-by-reference on [pythontutor.com](http://pythontutor.com/cpp.html#code=//%20pass%20by%20value%20demo%0A%23include%20%3Ciostream%3E%0Ausing%20namespace%20std%3B%0A%0A//%20extracting%20value%20from%20a%20function%20with%20passed%20by%20reference%20technique%0A//%20num1%20is%20passed%20by%20value%20num%202%20and%20sum%20are%20passed%20by%20reference%0Avoid%20computeSum%28int%20num1,%20int%26%20num2,%20long%20%26sum%29%20%7B%0A%20%20%20%20sum%20%3D%20num1%20%2B%20num2%3B%20//%20sum%20is%20modified%0A%20%20%20%20//%20notice%20void%20function,%20no%20return%20value!%0A%7D%0A%0Aint%20main%28%29%20%7B%0A%20%20int%20n1,%20n2%3B%0A%20%20n1%20%3D%2020%3B%0A%20%20n2%20%3D%2030%3B%0A%20%20long%20ans%20%3D%200%3B%0A%20%20computeSum%28n1,%20n2,%20ans%29%3B%0A%20%20cout%20%3C%3C%20n1%20%3C%3C%20%22%20%2B%20%22%20%3C%3C%20n2%20%3C%3C%20%22%20%3D%20%22%20%3C%3C%20ans%20%3C%3C%20endl%3B%0A%20%20return%200%3B%0A%7D&curInstr=0&mode=display&origin=opt-frontend.js&py=cpp&rawInputLstJSON=%5B%5D)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dead code\n",
    "- code in the program that computer will never execute\n",
    "- e.g., returning from function prematurely from the middle of the body\n",
    "- visualize dead code example on [pythontutor.com](https://pythontutor.com/visualize.html#code=%23include%20%3Ciostream%3E%0Ausing%20namespace%20std%3B%0A%0Along%20sum%28int%20n1,%20int%20n2%29%20%7B%0A%20%20return%200%3B%0A%20%20long%20result%20%3D%20n1%20%2B%20n2%3B%0A%20%20return%20result%3B%0A%7D%0A%0Aint%20main%28%29%20%7B%0A%20%20cout%20%3C%3C%20sum%2810,%2020%29%3B%0A%20%20return%200%3B%0A%7D&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=cpp_g%2B%2B9.3.0&rawInputLstJSON=%5B%5D&textReferences=false)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Function prototype\n",
    "\n",
    "- we know functions must be defined before they're called\n",
    "- function signature or prototype can be used to tell the compiler that the function body will be defined later\n",
    "- helps us write the main function towards the top of the source file\n",
    "- define the actual functions after main without having to worry about the order of definitions\n",
    "- syntax of function prototype:\n",
    "\n",
    "```cpp\n",
    "type NAME(type, type, ...);\n",
    "```\n",
    "\n",
    "- only the function type, name and parameter types are required\n",
    "- can provide prameter names but are meaningless\n",
    "- NOTE: function prototype demostration doesn't work in Jupyter\n",
    "- see [demos/functions/func_prototype/func_prototype.cpp](demos/functions/func_prototype/func_prototype.cpp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Debugging and unit testing with assert( )\n",
    "- if a problem is broken into sub-problems, it can be solved using the bottom up design approach\n",
    "- sub-problems can be solved by independent functions which can be designed, tested and debugged independently\n",
    "- testing code at the functional level is called **unit testing**\n",
    "- we'll learn the basics of unit testing by automatically testing functions\n",
    "- C++ doesn't provide standard library for unit testing\n",
    "- $3^{rd}$ party frameworks such as googletest can be used for comprehensive unit testing\n",
    "- however, we can do basic unit testing using **assert()** macro function provided in **&lt;cassert&gt;** library\n",
    "- syntax to use assert:\n",
    "\n",
    "```cpp\n",
    "    assert(boolean expression);\n",
    "```\n",
    "- boolean expression is created comparing two data values using e.g., `==` equality comparison operator\n",
    "    - more on comparison operators covered in Conditionals chapter\n",
    "- if expression evaluates to true (two values are indeed equal), assertion is correct!\n",
    "    - otherwise, assertion fails and the program halts immidiately!\n",
    "- more on assert: https://en.cppreference.com/w/cpp/error/assert\n",
    "- **NOTE: assert( ) doesn't work in Jupyter notebook**; see the following demo programs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Debugging demo\n",
    "- debugging with assert function [demos/functions/assert/assertdebug.cpp](demos/functions/assert/assertdebug.cpp)\n",
    "\n",
    "### Unit testing demos\n",
    "- using this concept, we can automatically test if the returned results from functions are correct or not\n",
    "- floating point computation is accurate upto 7 digits (single precision) and double is accurate upto 15 digits (double precision)\n",
    "- see unit testing fruitful function with assert here [demos/functions/unittest1/unittesting.cpp](demos/functions/unittest1/unittesting.cpp)\n",
    "\n",
    "- see improved version 2.0 unit testing example [demos/functions/unittest2/unittesting2.cpp](demos/functions/unittest2/unittesting2.cpp)\n",
    "\n",
    "- see unit testing void function with assert here [demos/functions/unittest3/unittesting3.cpp](demos/functions/unittest3/unittesting3.cpp)\n",
    "\n",
    "\n",
    "\n",
    "### Demo program finding area and perimeter of a triangle using functions and unit testing\n",
    "- ultimate way of solving problems using functions is demonstrated by this demo: [demos/functions/rectangle/main.cpp](demos/functions/rectangle/main.cpp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Function overloading and templating\n",
    "- often times we do similar operations on different data types\n",
    "- e.g., we add floating point numbers and integers or concatenate strings\n",
    "- e.g. we want to add two numbers or strings using functions called add( )\n",
    "    - `add(10, 20);` // adding two integers\n",
    "    - `add(20.5, 5);` // adding double and int\n",
    "    - `add(5.6f, 6.1f);` // adding two floats\n",
    "    - `add(56.66, 4646.444);` // adding two doubles\n",
    "    - `add(12.23f, 32.343);` // adding two doubles\n",
    "    - `add(\"hello\", \"world\");` // returns \"helloworld\"\n",
    " \n",
    "- you'd need to define 6 `add()` function for adding each pair of data types stated above\n",
    "- what about adding various combination of types? such as adding `int` and `float`, `short` and `double`... etc.\n",
    "- two solutions:\n",
    "    1. function overloading\n",
    "    2. function templating"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "// Problem: just this one function doesn't correctly add all numeric types\n",
    "int addNumbers(int n1, int n2) {\n",
    "    return n1+n2;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    }
   ],
   "source": [
    "// gives correct answer!\n",
    "cout << addNumbers(10, 20) << endl;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[1minput_line_12:3:20: \u001b[0m\u001b[0;1;35mwarning: \u001b[0m\u001b[1mimplicit conversion from 'float' to 'int' changes value from 10.5 to 10 [-Wliteral-conversion]\u001b[0m\n",
      "cout << addNumbers(10.5f, 30);\n",
      "\u001b[0;1;32m        ~~~~~~~~~~ ^~~~~\n",
      "\u001b[0m"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40"
     ]
    }
   ],
   "source": [
    "// gives wrong answer!\n",
    "cout << addNumbers(10.5f, 30);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function overloading\n",
    "- functions can be redefined as long as the prototypes are different\n",
    "    - same function name can be used with different parameter types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "// function overloading for float type\n",
    "float addNumbers(float n1, float n2) {\n",
    "    return n1+n2;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "// overaloading for double type\n",
    "double addNumbers(double n1, double n2) {\n",
    "    return n1 + n2;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40.5"
     ]
    }
   ],
   "source": [
    "// now we can add two floating point numbers\n",
    "cout << addNumbers(10.5f, 30.0f);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19"
     ]
    }
   ],
   "source": [
    "// we can also add two doubles\n",
    "cout << addNumbers(10.1, 8.9);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15.500000"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// how about adding int and float?\n",
    "// compiler gets confused, as we don't have addNumbers defined for int and float\n",
    "addNumbers(5, 10.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function templates\n",
    "- ways to create functions that work with **generic types**\n",
    "- better approach as we write one template function that works for any types\n",
    "    - without having to repeat the function for each type\n",
    "- can be achieved using **template parameters**\n",
    "- template parameter allows us to pass actual types to a function\n",
    "- syntax to define a template function:\n",
    "\n",
    "```cpp\n",
    "    template <class type1, class type2,...>\n",
    "    type1 functionName(type1 PARAMETER1, type2 PARAMETER2, ...) {\n",
    "        // body\n",
    "    }\n",
    "```\n",
    "- type1 and type2 in definitions are identifiers\n",
    "    - you can choose any names\n",
    "    \n",
    "- syntax to call template function:\n",
    "\n",
    "```cpp\n",
    "    functionName<type1, type2,...>(arg1, arg2, ...);\n",
    "```\n",
    "- type1 and type2 in function call are actual data types that C++ understands"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "// define a function that adds two values\n",
    "// let's assume T2 is the bigger type if T1 and T2 are differnt types\n",
    "template<class T1, class T2>\n",
    "T2 addTwo(T1 val1, T2 val2) {\n",
    "    return val1 + val2;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15"
     ]
    }
   ],
   "source": [
    "// call addTwo providing types and arguments\n",
    "cout << addTwo<int, int>(10, 5);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15.9"
     ]
    }
   ],
   "source": [
    "cout << addTwo<int, float>(5, 10.9f);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "155.9"
     ]
    }
   ],
   "source": [
    "cout << addTwo<int, double>(56, 99.90);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b"
     ]
    }
   ],
   "source": [
    "// can also add two chars\n",
    "cout << addTwo<char, char>('1', '1');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "helloworld"
     ]
    }
   ],
   "source": [
    "// let's add two strings\n",
    "#include <string>\n",
    "using namespace std;\n",
    "\n",
    "cout << addTwo<string, string>(\"hello\", \"world\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scope and name resolution\n",
    "- scope is the area of visibility of identifiers such as variables and constants within the program\n",
    "    - scope determines where the variables and identifiers are valid\n",
    "- scopes can be conceptualized as nested box frames\n",
    "- C++ provides 3 common types of identifiers' scopes\n",
    "    1. global scope\n",
    "    2. local scope\n",
    "    3. block scope\n",
    "    \n",
    "### Global scope\n",
    "- any identifiers (variables, constants, functions) decalared outside any function have global scope\n",
    "- most functions have global scopes\n",
    "- can be used anywhere in the program\n",
    "\n",
    "### Local scope\n",
    "- any variables and constants defined inside function scope\n",
    "    - including parameters have local scope\n",
    "- local identifiers can be used anywhere within the function scope\n",
    "\n",
    "### Block scope\n",
    "- smallest region that is enclosed inside curly braces `{ }`\n",
    "- any identifiers declared inside curly braces can be used only withing that block\n",
    "- very limited scope and rarely used\n",
    "\n",
    "### Name resolution\n",
    "- program needs to know and resolve what different names are\n",
    "    - where the names are declared and their scope or visibility\n",
    "- compiler first looks into the current scope or frame then the frame it's immidiately inside and so on until global frame to try to resolve any name used in the program\n",
    "\n",
    "- the following figure depicts the various scopes and name resolution in C++\n",
    "\n",
    "![](resources/scopesandnameresolution.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### visualize identifiers' scopes on [pythontutor.com](http://pythontutor.com/cpp.html#code=//%20program%20to%20demonstrate%20variable%20scope%0A//%20libraries%20have%20global%20scope%0A%23include%20%3Ciostream%3E%0A%23include%20%3Cstring%3E%0A%0Ausing%20namespace%20std%3B%0A%0A//%20global%20identifiers%0Aint%20global_var%20%3D%2010%3B%0Aconst%20double%20PI%20%3D%203.141592653589793238%3B%0A%23define%20LF%20'%5Cn'%0A%0Aint%20area_of_circle%28const%20float%20radius%29%20%7B%0A%20%20global_var%20%3D%20200%3B%0A%20%20return%202*PI*radius%3B%0A%7D%0A%0Aint%20main%28%29%20%7B%0A%20%20float%20rad%20%3D%202.5%3B%0A%20%20global_var%20%3D%20100%3B%0A%20%20cout%20%3C%3C%20%22area%20of%20circle%20%3D%20%22%20%3C%3C%20area_of_circle%28rad%29%20%3C%3C%20LF%3B%0A%20%20cout%20%3C%3C%20%22global%20var%20%3D%20%22%20%3C%3C%20global_var%20%3C%3C%20LF%3B%0A%20%20%7B%0A%20%20%20%20char%20block_var%20%3D%20'A'%3B%0A%20%20%20%20cout%20%3C%3C%20%22block_var%20within%20block%20%3D%20%22%20%3C%3C%20block_var%20%3C%3C%20LF%3B%0A%20%20%20%20rad%20%3D%2010.99f%3B%0A%20%20%7D%0A%20%20//%20trying%20to%20access%20block%20variable%20outside%20block%0A%20%20//%20TODO%3A%20uncomment%20the%20following%20and%20compile%0A%20%20//%20block_var%20%3D%20'a'%3B%0A%20%20return%200%3B%0A%7D&curInstr=0&mode=display&origin=opt-frontend.js&py=cpp&rawInputLstJSON=%5B%5D)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Labs\n",
    "\n",
    "1.  Write a C++ program that prompts the user to enter two points on a 2D geometry and finds the distance between the two points.\n",
    "    - Use the partial solution provide in `pointDistance.cpp` file in [labs/functions/](labs/functions/)\n",
    "    - Fix all the FIXMEs and write FIXED when each FIXME is fixed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "        \n",
    "1. Write a C++ program including algorithm steps that calculates area and circumference of a circle.\n",
    "    - must write functions to compute area and perimeter and automatically test each function with atleast 3 test cases\n",
    "    \n",
    "    \n",
    "2. Write a C++ program including algorithm steps that calculates Body Mass Index (BMI) of a person.\n",
    "    - must use as many functions as possible\n",
    "    - write at least 3 test cases for each function\n",
    "    - more info on BMI - https://www.nhlbi.nih.gov/health/educational/lose_wt/BMI/bmicalc.htm\n",
    "    - Formula [here]( https://www.cdc.gov/healthyweight/assessing/bmi/childrens_bmi/childrens_bmi_formula.html#:~:text=The%20formula%20for%20BMI%20is,to%20convert%20this%20to%20meters.&text=When%20using%20English%20measurements%2C%20pounds%20should%20be%20divided%20by%20inches%20squared).\n",
    "    - a sample solution is provided at [exercises/functions/BMI](exercises/functions/BMI)\n",
    "\n",
    "\n",
    "3. Write a C++ program including algorithm steps that calculates area and perimeter of a triangle given three sides.\n",
    "    - must write and use separate functions to calculate area and perimeter\n",
    "    - write at least 3 test cases for each function\n",
    "    - Hint: use Heron's formula to find area with three sides.\n",
    "    \n",
    "    \n",
    "4. Write a C++ program that converts hours into seconds.\n",
    "    - must write and use function(s) to computer answer(s)\n",
    "    - must write at least 3 test cases for each function\n",
    "    - e.g. given 2 hours, program should print 7200 as answer.\n",
    "   \n",
    "   \n",
    "5. Write a C++ program that converts seconds into hours, minutes and seconds.\n",
    "    - must define and use function(s)\n",
    "    - write at least 3 test cases for each function\n",
    "    - sample input: 3600 sample output: 1 hour, 0 minute and 0 second\n",
    "    - sample input: 3661 sample output: 1 hour, 1 minute and 1 second\n",
    "    - Hint: use series of division and modulo operations\n",
    "    \n",
    "    \n",
    "6. Write a C++ program that finds area and perimeter of a rectangle.\n",
    "    - must define and use function(s)\n",
    "    - write at least 3 test cases for each function\n",
    "    - a sample solution is provided her [demos/functions/rectangle](demos/functions/rectangle)\n",
    "    \n",
    "    \n",
    "## Kattis Problems\n",
    "- functions are not required to solve Kattis problems\n",
    "- however, it's best practices to use function to learn to be able to sovle harder and bigger problems\n",
    "\n",
    "\n",
    "1. Hello World! - https://open.kattis.com/problems/hello\n",
    "    - solve the problem using function(s)\n",
    "    - write a test case for the function using assert\n",
    "    \n",
    "    \n",
    "2. Solving for Carrots - https://open.kattis.com/problems/carrots\n",
    "    - solve the problem using function(s)\n",
    "    - using assert write at least three test cases for each function\n",
    "    \n",
    "    \n",
    "3. R2 - https://open.kattis.com/problems/r2\n",
    "    - solve the problem using function(s)\n",
    "    - using assert write at least three test cases for each function\n",
    "    \n",
    "    \n",
    "4. Spavanac - https://open.kattis.com/problems/spavanac\n",
    "    - solve the problem using function(s)\n",
    "    - using assert write at least three test cases for each function\n",
    "    \n",
    "    \n",
    "5. Add Two Numbers - https://open.kattis.com/problems/addtwonumbers\n",
    "    - solve the problem using function(s)\n",
    "    - using assert write at least three test cases for each function\n",
    "    \n",
    "    \n",
    "6. Solve rest of the problems from Chapter 3 - Std IO using as many functions as possible.\n",
    "    - using assert write at least three test cases for each function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary\n",
    "- this chapter covered concepts on functions; how to create new functions and use them\n",
    "- went over various types of functions (fruitful and fruitless)\n",
    "- learned about why and how to pass data to functions\n",
    "- learned about debugging using assert(), cerr (stderr stream)\n",
    "- learned about important foundation concept of automatically testing functions\n",
    "- covered function overloading and templating\n",
    "- finally, 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": 4
}