/* This program demonstrates
 *  he 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.
 *
 *
 */
#include<iostream>
using namespace std;
int main()
{
    /* Looping on a user-determined range - all 3 loops */
    int high, low;
    cout<<"Enter the range: ";
    cin>>low>>high;
    cout<<"While loop: \n";
    int i = low;
    while (i <= high)
    {
        cout<<i<<endl;
        i++;
    }
    cout<<"While loop done\nDo-while loop:\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<<"do-while loop done\nFor 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(int i=low; i<high; i++)
    {
        cout<<i<<endl;
    }
    cout<<"For loop done"<<endl;


    /* 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;
    }
    return 0;
}