/* This program demonstrates
 * 1. Counting down and accumulation
 * 2. Counting loops
 * 3. for loop
 * 4. break and continue
 * 5. overflow and underflow
 * 6. variable scope
 * 7. Looping on a sentinel
 *
 * Accumulation
 * Most of the time, we have to accumulate an operation.
 * For example, we want to add a bunch of numbers.
 * Accumulation is the process of keeping a running result.
 * For example, we might need to add all the numbers the user enters, stopping
 * at the first negative number. However, we can only add 2 numbers at
 * a time. So, we add the first number to the sum, then we add the next
 * number to the sum and store the result back in the sum, and we repeat
 * this process until we have added in the last number.
 *
 * The for loop
 * The for loop is the third kind of loop available in C++
 * It is used primarily as a counting loop.
 * That is, we like while loops when we don't know how many times a loop would run.
 * We like do-while loops when we have a situation similar to the while loop,
 * but the loop would run at least once.
 * We like for loops when we know exactly how many times the loop would run.
 * The syntax for the for loop is:
 * for ( initialization; condition; increment)
 * {
 *      body of the loop
 * }
 * Control Flow: the initialization part is executed first, and only once.
 * Then the condition is checked. If the condition were false, it skips over
 * the loop and moves on to the line after the loop. If the condition were
 * true, it enters the loop and executes the statements in the body of the
 * loop.
 * Once we are done with the loop body, the increment part is executed, and
 * then the condition is checked again. This process is repeated until the
 * condition is false.
 * A few more things to note:
 * 1. We can have multiple comma separated statements in the initialization
 * 	 and the increment part, but only one standalone condition.
 * 2. Any variables declared as a part of the for loop are not available
 *   outside the loop.
 *
 * break and continue statements in the context of loops
 * We took a look at the break statement when we discussed the switch
 * control structure. When used in a switch statement, the break statement
 * broke program control out of the case and took it to the end of the switch.
 * When used in a loop, it will take program control out of the loop, even
 * if the loop condition is still true.
 * 1. It doesn't matter if the break is in a big complicated if...else
 * statement in the loop. It will still end the loop.
 * 2. If the break is inside a nested loop, it will only exit the
 * immediately enclosing loop. The outer loops will still exectue normally.
 * 3. If the break is a part of a switch statement inside the loop, the loop
 * is unaffected.
 * BREAK STATEMENTS ARE CONSIDERED POTENTIAL SECURITY HOLES. THERE ARE VERY
 * FEW SITUATIONS WHERE BREAKING OUT OF A LOOP CANNOT BE REWORKED INTO A MODIFIED
 * LOOP CONDITION.
 * IF YOUR HOMEWORK PROGRAMS USE BREAK ANYWHERE EXCEPT IN A SWITCH STATEMENT,
 * YOU WILL BE DOCKED 10 POINTS FOR "BAD PROGRAMMING PRACTICE"
 *
 * The continue statement, on the other hand, will ignore the rest of the lines
 * in the loop body for this current iteration of the loop and move on to the
 * next iteration. (Iteration is defined as one run of the loop - condition ->
 * loop body -> increment).
 * If a continue statement is in a for loop, it will take control to the increment
 * In a while or do-while loop, it will take it to the condition
 * CONTINUE STATEMENTS ARE ALSO CONSIDERED POTENTIAL SECURITY HOLES. THERE ARE
 * SITUATIONS THAT CALL FOR ITS USE. BUT MOST OF THOSE ALGORITHMS ARE A BIT TOO
 * ADVANCED FOR THIS COURSE. SAME RULE AS BREAK - USING CONTINUE IN YOUR HOMEWORKS
 * WOULD RESULT IN A LOSS OF 10 POINTS.
 *
 * Scope with respect to for loops
 * We can declare variables in the initialization part of the for loop, and
 * these variables are only available or "alive" inside the loop
 *
 * Looping on a sentinel
 * There are several instances where we have to do some processing several
 * times, but we no not always know how many entries we have. So, the programmer
 * and the user can agree on a pre-determined "sentinel" value. We read in the first
 * entry, and as long as the entry is not the sentinel, we do the processing and
 * grab the next entry.
 */

#include<iostream>
using namespace std;
int i = 45; // global - don't do this
int main()
{
    /* Accumulation
     * "collecting" a series of values into 1 variable - build off update
     * Problem Statement - Calculate the cumulative class participation grade over 4 weeks
     * Step 1:  Initialize a sum variable to 0, and a counter to 4.
     *          Also declare a weekly grade variable.
     * Step 2:  We're counting down here, so check if the number of weeks
     *          left (counter) is over 0
     *          Step 2.a: Read the weekly value
     *          Step 2.b: Add value to the sum
     *          Step 2.c: Decrement the counter
     *          Step 2.d: Go back to step 2
     * Step 3: Print the total
     */
    double weekly, total=0;
    int numWeeks = 4;
    while ( numWeeks > 0)
    {
        cout<<"Enter the weekly grade:";
        cin>>weekly;
        total = total + weekly;     // accumulation
        numWeeks--;
    }
    cout<<"Total grade: "<<total<<endl;

    /* Looping on a user-determined range - all 3 loops */
    int low, high;
    cout<<"Enter the lower and higher ends of the range: ";
    cin>>low>>high;
    cout<<"While loop: \n";
    int i=low;
    while( i<=high)
    {
        cout<<i<<endl;
        i++;
    }
    cout<<"\nEnd of while \ndo-while lopp\n";
    /* The do-while loop will behave the same way as the while
     * for all runs that have at least 1 number between "low" and "high"
     * However, since it runs at least once before checking the condition,
     * it would print (incorrectly) the first number if the range input
     * were incorrect.
     * Most of the time, when we confuse "run once" with "check once"
     * the do-while loop is only suitable in a small set of situations.
     */
    i = low;
    do
    {
        cout<<i<<endl;
        i++;
    }while(i <= high);

    cout<<"End of do-while\n For loop"<<endl;


    /* The for loop - best suited for situations where we can, at least
     * algebraically, determine the number of times a loop runs.
     * The same
     * This example, counts up from a lower limit to the higher limit
     * just like the while loop in conditionals.cpp
     * The for loop is preferred as a counting loop because of its
     * structure - the initialization, condition and increment are all in
     * the same place.
     */

    for (short i = low; i <= high; i++)
    {
        cout<<i<<" ";
    }
    /* Infinite loops:
      * One of the common errors in looping is forgetting the increment, which will
      * result in an "infinite" loop  - a loop that runs forever, since the loop
      * condition is never false.
      * Depending on the body of the loop - this might just run forver, or will result
      * in the program crashing.
      * The following is an example of an infinite loop.
      * To "fix" it, uncomment the increment line.
      */
    i = 20;
    while ( i<25)
    {
        cout<<i<<endl;
        // i++;      // increment. Will infinite loop without this line
    }

    int num;
    cout<<"Enter a number: ";
    cin>>num;

    /* The following loop will stop executing the very first time i is a
    * multiple of the number entered by teh user
    */
    cout<<"break - example"<<endl;
    for(int i=1; i<50; i++)
    {
        if( i % num == 0)
            break;
        cout<<i<<endl;
    }

    cout<<"Out of the loop - break example"<<endl;

    /* The following loop will skip over the "cout<<i<<endl;" line when i is a multiple
    * of the number entered by the user
    */
    cout<<"continue - example"<<endl;

    for(int i=1; i<50; i++)
    {
        if(i % num == 0)
            continue;
        cout<<i<<endl;
    }
    cout<<"out of the loop - continue"<<endl;

    /* Overflow and underflow
   * Consider the following loop. It starts at 100, and counts up, but checks
   * if the loop variable is more than 0, which it will be. This will
   * continue until we hit the largest value possible for the loop
   * variable and then overflow, which might finally trigger the
   * false condition and exit the loop. This is however not guaranteed, and
   * depends on the condition. We demonstrate this with shorts, because the range
   * of a short is - 32768 to + 32767, and we can easily see the effects.
   */
    // shorts are 16 bit ints - (-2^15) to (+2^15) -1 or -32768 to + 32767
    short s;
    for (s = 100; s>0; s++) {
        cout << s << endl;
    }

    cout<<"After loop, s: "<<s<<endl;

    /* This is another example of overflow - where we store integer values in
     * a char variable. We can do that, since chars ate integer types.
     * The range of a char (numerically is -128 to +127.
     * We cast the value to int when we print, to get the actual numbers.
     * Otherwise, it would print an equivalent character (which might not make sense
     */

    char k;
    for (k = 90; k >0 ; k++ )
    {
        cout<<static_cast<int>(k)<<endl;
    }

    /* The for loop can take multiple comma separated values in the initialiation
     * and increment parts, as shown below.
     * We can even leave out those parts.
     * And, while multiple comma separated conditions in the loop condition part
     * is syntactically ok, ONLY ONE CONDITION WOULD BE CONSIDERED AND WHICH ONE
     * DEPENDS ON THE COMPILER. THIS WOULD GIVE YOU LOGICAL ERRORS AND UNEXPECTED
     * RESULTS. PLEASE AVOID
     * Ideally, only one eventual condition - if there are multiple conditions, they
     * should be combined with &&, || or ! into one condition.
     * HAVING MORE THAN 2 SEMICOLONS IN A FOR LOOP WOULD RESULT IN A COMPILATION ERROR
     */

    for(int i= 0, j = 5; i<25 || j > 0; i++ , j--)
    {
        cout<<"i is "<<i<<", j is "<<j <<endl;
        if(i % 7 == 0)
            cout<<i<<" is divisible by 7"<<endl;
    }




    /* Scope of variables
    * When we open a set of {}, we open a new scope. A variable declared in a scope
    * is only available in that scope.
    * When a scope is closed, all the variables declared in that scope are destroyed.
    * In a for loop,, the variables declared in the parentheses are considered to be
    * declared in the scope of the for loop, and so, are only available for the
    * duration of the loop.
    * Whenever we refer to a variable, c++ will look at the most recent valid declaration
    * of that variable.
    * In the following example, the fist "i" is declared outside the loop. The second "i"
    * is in the loop. So, the loop would use the second "i" and the lines before and
    * after the loop would refer to the first "i".
    */
    i = 60;
    cout<<"Before the loop: i= "<<i<<endl;

    for(int i=40; i>0; i--)
    {
        cout<<i<<endl;
    }

    cout<<"Out of the loop, i= "<<i<<endl;
    cout<<"Global i: "<< ::i<<endl;     // Uses the scope resolution operator without a
                                        // namespace to refer to the general global scope

    /* Looping on a sentinel
    * Sentinel - guard value - any value other than the sentinel is considered valid input
    * Loop as long as the loop variable is NOT the sentinel
    * Problem description:  Read a series of amounts, accumulate them into a current bank balance
     * Positive numbers are deposits. Negative numbers are withdrawals. 
    * Sentinel 0 - Stop when user enters 0
    */

    double amount, inBank;
    cout<<"Enter current money in the bank: ";
    cin>>inBank;
    cout<<"Enter transaction amount: ";
    cin>>amount;
    while(amount !=0)       // 0 is sentinel
    {
        inBank += amount;       // add amount to current balance
                                // a negative amoutn for a withdrawal will auto-subtract
        cout<<"Enter next transaction: ";
        cin>> amount;
    }
    cout<<"Current balance is now $ "<<inBank<<endl;


    return 0;
}