DataTypesAndVariables.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data, Types and Variables\n",
    "\n",
    "## Topics\n",
    "- data and values\n",
    "- C++ fundamental data types\n",
    "- digital units and number systems\n",
    "- variables and data assignment\n",
    "- keywords and operators\n",
    "- order of operations\n",
    "- operators for numbers and strings\n",
    "- constants\n",
    "- type casting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data and values\n",
    "- data and values are the fundamentals to any computer language and program\n",
    "- a value is one of the fundamental things -- like a letter or a number -- that a program manipulates\n",
    "- almost all computer programs use and manipulate some data values\n",
    "\n",
    "## Literal values and representations\n",
    "- at a high level, we deal with two types of data values: Numbers and Texts\n",
    "- most programming languages need to represent and use these data correctly\n",
    "- numbers can be further divided into two types:\n",
    "    - Whole number literal values: 109, -234, etc.\n",
    "    - Floating point literal values: 123.456, -0.3555, etc.\n",
    "- text is a collection of 1 or more characters (symbols, digits or alpahabets)\n",
    "    - single character is represented using a pair of single quotes ( ' ' )\n",
    "        - char literal values: 'A', 'a', '%', '1', etc.\n",
    "    - 2 or more characters are called string\n",
    "        - represented using a pair of double quotes ( \" \" )\n",
    "        - string literal values: \"CO\", \"John Doe\", \"1100\", \"9.99\", etc.\n",
    "    \n",
    "    \n",
    "## C++ Fundamental Types\n",
    "- there are many fundamental types based on the size of the data program needs to store\n",
    "    - most fundamental types are numeric types\n",
    "- see here for all the supported types: https://en.cppreference.com/w/cpp/language/types\n",
    "- the most common types we use are:\n",
    "\n",
    "| Type | Description | Storage size | Value range |\n",
    "| :---| :--- | :---|---|\n",
    "| **void**   | an empty set of values; no type | system dependent: 4 or 8 bytes | NA |\n",
    "|**bool** | true or false | 1 byte or 8 bits | true or false <br /> 1 or 0 |\n",
    "| **char** | one ASCII character | 1 byte or 8 bits | $-2^7$ to $2^7-1$ |\n",
    "| **unsigned char** | one ASCII character | 1 byte or 8 bits | 0 to $2^8-1$ |\n",
    "| **int** | +/-ve integers  | 4 bytes | $-2^{31}$ to $2^{31}-1$|\n",
    "| **unsigned int** | only positive integers | 4 bytes or 32 bits | 0 to $2^{32}-1$ |\n",
    "| **long** | +ve and -ve big integers | 8 bytes or 64 bits| $-2^{63}$ to $2^{63}-1$|\n",
    "| **unsigned long** | positive big integers | 8 bytes or 64 bits | 0 to $2^{64}-1$ |\n",
    "| **float** | single precision floating points | 32 bits | 7 decimal points |\n",
    "| **double** | double precision floating points | 64 bits |  15 decimal points |\n",
    "\n",
    "\n",
    "- in C++, there's no fundadamental type available to work with string data\n",
    "- two common ways to store string data:\n",
    "    - use C-string or array of characters\n",
    "    - use basic_string defined in `<string>` library\n",
    "        - more on basic_string: https://en.cppreference.com/w/cpp/string/basic_string\n",
    "        - must include `<string>` library and **std** namespace\n",
    "- we'll dive into string more in depth in **Strings** chapter\n",
    "   \n",
    "### sizeof operator\n",
    "- one may want to know the size of memory allocated for the fundamental types\n",
    "    - some of these types are system dependent (e.g., long is 32 bit in x86 and 64 bit in x64)\n",
    "- **sizeof(type)** operator gives size of fundamental types in bytes\n",
    "- let's check the size of some fundamental types on my 64-bit MacBook Pro laptop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sizeof(bool)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sizeof(char)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sizeof(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sizeof(long)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sizeof(float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sizeof(double)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Units of digital data\n",
    "- digital computers use binary number system consisting of two digits (0 and 1)\n",
    "- every data and code is represented using binary values\n",
    "    - hence the name binary or byte code for executable programs\n",
    "    - letter A is encoded as 1000001 (7 binary digits)\n",
    "- humans use decimal number system with 10 digits (0 to 9)\n",
    "    - we have ways to represent texts using alphabets for English language e.g.: Hello Bond 707!\n",
    "    - texts must be encoded into numbers, if we lived in the world that only understood numbers\n",
    "- the following table shows the various units of digital data\n",
    "\n",
    "| Unit | Equivalent |\n",
    "|---|---|\n",
    "| 1 bit (b) | 0 or 1 |\n",
    "| 1 byte (B) | 8 bits (b) |\n",
    "| 1 kilobyte (KB)  | 1,024 B |\n",
    "| 1 megabyte (MB) | 1,024 KB |\n",
    "| 1 gigabtye (GB) | 1,024 MB |\n",
    "| 1 terabyte (TB) | 1,024 GB |\n",
    "| 1 petabyte (PB) | 1,024 TB |\n",
    "| ... | ... |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Number systems\n",
    "- there are several number systems based on the base digits\n",
    "    - base is number of unique digits number system uses to represent numbers\n",
    "- binary (base 2), octal (base 8), decimal (base 10), hexadecimal (base 16), etc.\n",
    "\n",
    "### Decimal number system\n",
    "- also called Hindu-Arabic number system\n",
    "- most commonly used number system that uses base 10\n",
    "    - has 10 digits or numerals to represent numbers: 0..9\n",
    "    - e.g., 1, 79, 1024, 12345, etc.\n",
    "- numerals representing numbers have different place values depending on position:\n",
    "    - ones ($10^0$), tens($10^1$), hundreds($10^2$), thousands($10^3$), ten thousands($10^4$), etc.\n",
    "    - e.g., 543.21 = $(5\\times10^2)+(4\\times10^1)+(3\\times10^0)+(2\\times10^{-1})+(1\\times10^{-2})$\n",
    "    \n",
    "## Number system conversion\n",
    "- since computers understand only binary, everything (data, code) must be converted into binary\n",
    "- all characaters (alphabets and symbols) are given decimal codes for electronic communication\n",
    "    - these codes are called ASCII (American Standard Code for Information Interchange)\n",
    "    - $A \\rightarrow 65; Z \\rightarrow 90; a \\rightarrow 97; z \\rightarrow 122, * \\rightarrow 42$, etc.\n",
    "    - see ASCII chart: https://en.cppreference.com/w/c/language/ascii\n",
    "\n",
    "### Converting decmial to binary number\n",
    "\n",
    "- algorithm steps:\n",
    "    1. repeteadly divide the decimal number by base $2$ until the quotient becomes $0$\n",
    "        - note remainder for each division\n",
    "    2. collect all the remainders in reverse order\n",
    "        - the first remainder is the last (least significant) digit in binary\n",
    "    \n",
    "- example 1: what is decimal $(10)_{10}$ in binary $(?)_2$ ?\n",
    "    - step 1:\n",
    "    \n",
    "        $\\frac{10}{2}$ = quotient: $5$, remainder: $0$ <br /><br />\n",
    "        $\\frac{5}{2}$  = quotient: $2$, remainder: $1$ <br /><br />\n",
    "        $\\frac{2}{2}$  = quotient: $1$, remainder: $0$ <br /><br />\n",
    "        $\\frac{1}{2}$  = quotient: $0$, remainder: $1$ <br /><br />\n",
    "     \n",
    "    - step 2: \n",
    "         - collect remainders from bottom up: $1010$\n",
    "    - so, $(10)_{10}$ = $(1010)_2$\n",
    "     \n",
    "     \n",
    "- example 2: what is decimal $(13)_{10}$ in $(?)_2$ ?\n",
    "    - step 1:\n",
    "    \n",
    "        $\\frac{13}{2}$ = quotient: $6$, remainder: $1$ <br /><br />\n",
    "        $\\frac{6}{2}$  = quotient $3$, remainder: $0$ <br /><br />\n",
    "        $\\frac{3}{2}$  = quotient: $1$, remainder: $1$ <br /><br />\n",
    "        $\\frac{1}{2}$  = quotient: $0$, remainder: $1$ <br /><br />\n",
    "        \n",
    "    - step 2:\n",
    "         - collect remainders from bottom up: $1101$\n",
    "    - so, $(13)_{10}$ = $(1101)_2$\n",
    "     \n",
    "### Converting binary to decimal number\n",
    "- once the computer does the computation in binary, it needs to convert the results back to decimal number system for humans to understand\n",
    "- algorithm steps:\n",
    "    1. multiply each binary digit by its place value in binary\n",
    "    2. sum all the products\n",
    "\n",
    "- example 1: what is binary $(1010)_2$ in decimal $(?)_{10}?$\n",
    "    - step 1:\n",
    "    \n",
    "        - $0\\times2^0 = 0$\n",
    "        - $1\\times2^1 = 2$\n",
    "        - $0\\times2^2 = 0$\n",
    "        - $1\\times2^3 = 8$\n",
    "    - step 2:\n",
    "        - $0 + 2 + 0 + 8 = 10$\n",
    "    - so, $(1010)_2$ = $(10)_{10}$\n",
    "    \n",
    "    \n",
    "- example 2: what is binary $(1101)_2$ in decimal $(?)_{10}?$\n",
    "    - step 1:\n",
    "    \n",
    "        - $1\\times2^0 = 1$\n",
    "        - $0\\times2^1 = 0$\n",
    "        - $1\\times2^2 = 4$\n",
    "        - $1\\times2^3 = 8$\n",
    "\n",
    "    - step 2:\n",
    "        - $1+0+4+8 = 13$\n",
    "    - so, $(1101)_2$ = $(13)_{10}$\n",
    "- we got the same decimal vales we started from in previous examples\n",
    "- food for thought: think how you'd go about writing a program to convert any positive decimal number into binary and vice versa!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Negative (signed) integers - Two's complement\n",
    "- most common method of storing negative numbers on computers is a mathematical operation called Two's complement\n",
    "- Two's complement of an N-bit number is defined as its complement with respect to $2^N$\n",
    "    - the sum of a number and its two's complement is $2^N$\n",
    "- e.g.: for the 3-bit binary number $010_2$, the two's complement is $110_2$\n",
    "    - because $010_2 + 110_2 = 1000_2 = 2^3_{10}$\n",
    "- Two's complement of N-bit number can be found by flipping each bit and adding one to it\n",
    "- e.g. find two's complement of $010$\n",
    "    - Algorithm steps:\n",
    "        1. flipped each bit; $0$ is flipped to $1$ and $1$ is flipped to $0$\n",
    "\n",
    "        $010 \\rightarrow  101$\n",
    "\n",
    "        2. add 1 to the flipped binary \n",
    "\n",
    "        ```bash\n",
    "            101\n",
    "             +1\n",
    "           -----\n",
    "            110\n",
    "        ```\n",
    "\n",
    "### Example: What is -3 decimal in 8-bit binary representation?\n",
    "- convert $3_{10}$ to an 8-bit binary\n",
    "    - $3_{10} \\rightarrow 00000011_{2}$\n",
    "    \n",
    "1. find Two's complement of 8-bit binary\n",
    "    - $00000011_{2} \\rightarrow 11111100_{2} + 1 = 11111101_{2}$\n",
    "\n",
    "2. Sanity check:\n",
    "    - $00000011_{2} + 11111101_{2} = 100000000_{2} = 2^8_{10}$\n",
    "\n",
    "- So, $-3_{10} = 11111101_{2}$ in an 8-bit representation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise\n",
    "1. Convert decimal integer 7 into binary with 16 bits."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Convert -7 decimal integer into binary with 16 bits."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "- programs must load data values into memory to manipulate them\n",
    "- data may be large and used many times during the program\n",
    "    - typing the data values literally all the time is not efficient and fun\n",
    "    - most importantly error prone due to typos\n",
    "    - you may not even know what values may be if they're read from standard input, files, etc.\n",
    "- variables are named memory location where data can be stored for easy access and manipulation\n",
    "- one can declare and use as many variables as necessary\n",
    "- C++ is a static and strongly typed programming language\n",
    "    - variables are tied to their specific data types that must be explictly declared when declaring variables\n",
    "\n",
    "### Variable declaration\n",
    "- statements that create variables/identifiers to store some data values\n",
    "- as the name says, value of variables can vary/change over time\n",
    "- syntax:\n",
    "```c\n",
    "type varName;\n",
    "type varNam1, varName2, ...; //declare several variables all of the same type\n",
    "```\n",
    "\n",
    "![](resources/VariablesAndMemory.png)\n",
    "\n",
    "### Rules for creating variables\n",
    "- variable names are case sensitive\n",
    "- must declare variables before they can be used\n",
    "- can't define variable with the same name more than once\n",
    "- can't use keywords as variable names\n",
    "- data stored must match the type of variable\n",
    "- variable names can't contain symbols (white spaces, #, &, etc.) except for _ and \\$ (underscore and dollar)\n",
    "- variable names can contain digits but can't start with a digit\n",
    "- variable names can start with only alphabets (lower or upper) and _ symbol\n",
    "\n",
    "### Best practices\n",
    "- use descriptive and meaningful but concise name\n",
    "    - one should know quickly what data you're storing\n",
    "- use lowercase; camelCase or ( _ underscore ) to combine multiple words\n",
    "\n",
    "### C++ keywords\n",
    "- keywords are reserved names and words that have specific purpose in C++\n",
    "    - they can only be used what they're intended for\n",
    "- e.g., char, int, unsigned, signed, float, double, bool, if, for, while, return, struct, class, operator, try, etc.\n",
    "- all C++ keywords are listed here: https://en.cppreference.com/w/cpp/keyword"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "// examples of variable declaration\n",
    "bool done;\n",
    "char middleInitial;\n",
    "char middleinitial; // hard to read all lowercase name\n",
    "int temperature;\n",
    "unsigned int age;\n",
    "long richest_persons_networth;\n",
    "float interestRate;\n",
    "float length;\n",
    "float width;\n",
    "double space_shuttle_velocity;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "// TODO:\n",
    "// Declare 10 variables of atleast 5 different types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String variables\n",
    "- declare variables that store string data\n",
    "    - 1 or more string of characters\n",
    "- an easy way to use string is by using C++ advanced type defined in `<string>` header file\n",
    "- must include `<string>` header file or library to use string type\n",
    "- must also use **std** namespace\n",
    "- strings are represented using a pair of double quotes (\"string\")\n",
    "- more on string type is covered in **Strings** chapter\n",
    "- the following are some examples of string variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "// string variables\n",
    "#include <string>\n",
    "\n",
    "using namespace std;\n",
    "\n",
    "string fullName;\n",
    "string firstName;\n",
    "string address1;\n",
    "string country;\n",
    "string state_name;\n",
    "std::string state_code; // :: name resolution operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "// TODO:\n",
    "// Declare 5 string variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assignment operator ( = )\n",
    "\n",
    "- once variables are declared, data can be stored using assignment operator, $ = $\n",
    "- **assignment statements** have the following syntax:\n",
    "\n",
    "```cpp\n",
    "varName = value;\n",
    "```\n",
    "- since C++ is a strongly typed language, the type of value must match the type of variable\n",
    "    - strongly typed languages enforces type safety and matching during the compile time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "950.12346"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// assignment examples\n",
    "done = false;\n",
    "middleInitial = 'J'; // character is represent using single quote\n",
    "middleinitial = 'Q';\n",
    "temperature = 73;\n",
    "age = 45;\n",
    "richest_persons_networth = 120000000000; // 120 billion\n",
    "interestRate = 4.5;\n",
    "length = 10.5;\n",
    "width = 99.99f; // number can end with f to represent as float\n",
    "space_shuttle_velocity = 950.1234567891234567; // 16 decimal points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "// string assignment examples\n",
    "fullName = \"John Doe\";\n",
    "firstName = \"John\";\n",
    "address1 = \"1100 North Avenue\"; // number as string\n",
    "country = \"USA\";\n",
    "state_name = \"Colorado\";\n",
    "state_code = \"CO\";"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "// TODO: assign different values to variables defined above"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variable declartion and initialization\n",
    "- variables can be declared with an initial value at the time of construction\n",
    "- if you know what value a variable should start with, this saves you typing\n",
    "- often times it's the best practice to initialize variable with default value\n",
    "- several ways to initialize variables: https://en.cppreference.com/w/cpp/language/initialization\n",
    "- two common ways:\n",
    "    1. Copy initialization (using `=` operator)\n",
    "    2. Value initialization (using `{ }` curley braces)\n",
    "        - also called uniform initialization\n",
    "        - useful in initializing advanced types such as arrays, objects, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "// Copy initialization\n",
    "float price = 2.99f;\n",
    "char MI = 'B'; //middle initial\n",
    "string school_name = \"Grand Junction High\";"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "// Value/uniform initialization\n",
    "char some_letter{'U'};\n",
    "int some_length{100};\n",
    "float some_float{200.99};\n",
    "string some_string = {\"Hello World!\"}; // can also combine the two!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variable's value can be changed\n",
    "- variable's value can vary through out the program\n",
    "    - hence the name variable\n",
    "- however, type of the value must be same as the type of the variable at the time of declaration\n",
    "- C++ is a strongly and static typed programming language!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "price = 3.99;\n",
    "price = 1.99;\n",
    "MI = 'Q';\n",
    "school_name = \"Fruita Monument High\";\n",
    "some_string = \"Goodbye, World!\";"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[1minput_line_34:2:10: \u001b[0m\u001b[0;1;31merror: \u001b[0m\u001b[1massigning to 'float' from incompatible type 'const char [5]'\u001b[0m\n",
      " price = \"4.99\"; // is this valid?\n",
      "\u001b[0;1;32m         ^~~~~~\n",
      "\u001b[0m"
     ]
    },
    {
     "ename": "Interpreter Error",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "Interpreter Error: "
     ]
    }
   ],
   "source": [
    "price = \"4.99\"; // is this valid?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### auto type\n",
    "- if variable is declared and initialized in one statement, you can use **auto** keyword to let compiler determine type of variable based on the value it's initialized with"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "auto var1 = 10; // integer\n",
    "auto var2 = 19.99f; // float\n",
    "auto var3 = 99.245; // double\n",
    "auto var4 = '@'; // char"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "// char * (pointer) type and not string type\n",
    "auto full_name = \"John Doe\";"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "// can automatically declare string type\n",
    "#include <string>\n",
    "using namespace std;\n",
    "\n",
    "auto full_name1 = string(\"Jake Smith\"); // string type!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "// use typeid function to find the name of the types\n",
    "// typeid is defined in typeinfo library\n",
    "#include <typeinfo>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"NSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE\""
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeid(full_name1).name()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0x7fff67b6373c <invalid memory address>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// should print \"i\" -> short for integer\n",
    "// Note: may also print invalid memory address in Jupyter notebook!\n",
    "typeid(var1).name()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualize variables and memory with [pythontutor.com](http://pythontutor.com/cpp.html#code=%23include%20%3Cstring%3E%0Ausing%20namespace%20std%3B%0A%0Aconst%20double%20PI%20%3D%203.141592653589793238%3B%0A%0Aint%20main%28%29%20%7B%0A%20%20char%20MI%3B%0A%20%20int%20temperature%3B%0A%20%20float%20width%3B%0A%20%20double%20space_shuttle_velocity%3B%0A%20%20string%20fullName%3B%0A%20%20MI%20%3D%20'A'%3B%0A%20%20temperature%20%3D%20-10%3B%0A%20%20float%20length%20%3D%2015.5%3B%0A%20%20double%20distance%7B199.999%7D%3B%0A%20%20space_shuttle_velocity%20%3D%209.9%3B%0A%20%20MI%20%3D%20'Z'%3B%0A%20%20length%20%3D%2099.99f%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": [
    "## Constants\n",
    "- constants are named values that remain unchanged through out the program\n",
    "- useful for declaring values that are fixed\n",
    "    - e.g. value of $\\pi$, earth's gravity, unit conversions, etc.\n",
    "- two ways to define constants in C++\n",
    "    1. use **const** keyword infront of an identifier\n",
    "        - syntax:\n",
    "        ```cpp\n",
    "        const type identifier = value;\n",
    "        ```\n",
    "    2. use **#define** preprocessor directive\n",
    "        - syntax:\n",
    "        ```cpp\n",
    "        #define identifier value\n",
    "        ```\n",
    "        - after an identifier has been defined with a value, preprocessor replaces each occurances of PI with value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "const double pi = 22/7.0; // evaluate 22/7.0 and use it as the const value for pi\n",
    "const float earth_gravity = 9.8; // m/s^2 unit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[1minput_line_13:3:4: \u001b[0m\u001b[0;1;31merror: \u001b[0m\u001b[1mcannot assign to variable 'pi' with const-qualified type 'const double'\u001b[0m\n",
      "pi = 3.141592653589793238;\n",
      "\u001b[0;1;32m~~ ^\n",
      "\u001b[0m\u001b[1minput_line_8:2:15: \u001b[0m\u001b[0;1;30mnote: \u001b[0mvariable 'pi' declared const here\u001b[0m\n",
      " const double pi = 22/7.0; // evaluate 22/7.0 and use it as the const value for pi\n",
      "\u001b[0;1;32m ~~~~~~~~~~~~~^~~~~~~~~~~\n",
      "\u001b[0m"
     ]
    },
    {
     "ename": "Interpreter Error",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "Interpreter Error: "
     ]
    }
   ],
   "source": [
    "// try to assign different value to the constant pi\n",
    "pi = 3.141592653589793238;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Escape sequences\n",
    "- some letters or sequence of letters have special meaning to C++\n",
    "    - e.g., pair of single quote is used to represent a character data, e.g. 'A' or ' ' (space)\n",
    "    - and pair of double quotes is used to represent a string type, e.g., \"Hello World!\"\n",
    "- how can we store single or double quotes as part of data?\n",
    "    - e.g., we need to print: **\"Oh no!\", Alice exclaimed, \"Bob's bike is broken!\"**\n",
    "    - we use backslash `\\` (escape character) to escape the special meaning of single and double quotes or other characters\n",
    "- characters represented using escape character are called escape sequences\n",
    "    - \\\\n - new line\n",
    "    - \\\\\\\\ - back slash\n",
    "    - \\\\t - tab\n",
    "    - \\\\r - carriage return\n",
    "    - \\\\' - single quote\n",
    "    - \\\\\" - double quote"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "// string variables\n",
    "#include <iostream>\n",
    "#include <string>\n",
    "\n",
    "using namespace std;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "string greeting = \"What's up\\n Shaq\\tO'Neal?\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"What's up\n",
       " Shaq\tO'Neal?\""
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "char single_quote = '\\''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'''"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "single_quote"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "char double_quote = '\"'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\"'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "double_quote"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "// need to scape the \" inside strings\n",
    "string line = \"\\\"Oh no!\\\", Alice exclaimed, \\\"Bob's bike is broken!\\\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\"Oh no!\", Alice exclaimed, \"Bob's bike is broken!\"\""
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "how many back slashes will be printed? \\\\"
     ]
    }
   ],
   "source": [
    "cout << \"how many back slashes will be printed? \\\\\\\\\";"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Labs\n",
    "\n",
    "1. Variables Lab \n",
    "    - write a C++ program that produces the following output on console\n",
    "    - use the partial solution provided in [labs/variables/main.cpp](labs/variables/main.cpp)\n",
    "    - observe and note how the special symbols such as single quote, double quotes and black slashes\n",
    "    - run the program as it is using the provided make file in the stdio folder\n",
    "    - complete the rest of the ASCII Art by fixing all the FIXMEs\n",
    "    - write #FIXED next to each FIXME\n",
    "    \n",
    "    ```\n",
    "        |\\_/|       *******************************     (\\_/)\n",
    "       / @ @ \\      *      ASCII Art              *    (='.'=)\n",
    "      ( > 0 < )     *      Author: <Your Name>    *  ( \" )_( \" )\n",
    "        >>x<<       *      CS Foundation Course   *\n",
    "        / O \\       *******************************\n",
    "   ```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "1. Declare some variables required to store information about a student for a university banner system. Assign some values to those variables.\n",
    "    - see sample answer here [exercises/variables/exercise1](exercises/variables/exercise1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Declare some variables required to store information about an employee at a university. Assign some values to those variables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Declare some variables required to store information about a mechandise for an inventory management system of a store. Assign some values to those variables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Declare some variables required to store infomration about a rectangular shape. Calculate area and perimeter of a rectangle. Assign some values to those variables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. Declare variables required to store information about a circle to calculate its area and perimeter. Assign some values to those variables. Calculate area and perimeter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6. Declare some variables required to store information about a hotel room for booking management system."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7. Declare some variables required to store length of sides of a triangle. Calculate area using Herons' formula.\n",
    "    - Search for Heron's formula, if you're not sure what it is."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8. Using pencil and paper or Jupyter Notebook, write your full name in binary. \n",
    " - e.g., Ram Basnet in Binary is: \n",
    " - 01010010 01100001 01101101 00100000 01000010 01100001 01110011 01101110 01100101 01110100 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary\n",
    "- this notebook discussed data and C++ fundamental data types\n",
    "- variables are named memory location that store data values\n",
    "- C++ variables are static and strongly typed\n",
    "- learned that constants are used to store values that should not be changed in program\n",
    "- looked into exercises and sample solutions on data types and variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "C++11",
   "language": "C++11",
   "name": "xcpp11"
  },
  "language_info": {
   "codemirror_mode": "text/x-c++src",
   "file_extension": ".cpp",
   "mimetype": "text/x-c++src",
   "name": "c++",
   "version": "11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}