/* This program demonstrates
 * 1. Operator Precedence
 * 2. Implicit and explicit casting
 * 3. shortcut operators
 * 4. Increment and decrement
*/
#include<iostream>

using namespace std;

int main()
{

    /* Demonstrating operator precedence for the math operators
     * Precedence is the ORDER in whcih operators are executed
     */
    int z,a,b,c,d,e,f;
    cout<<"Enter 6 integers: ";
    cin>>a>>b>>c>>d>>e>>f;

    z = a1- b * -c + d / (e-f);     // Demonstrates operator precedence

    /* User entered 10 12 8 7 19 15
	   z = a - b * -c + d / (19 - 15)    // parentheses has highest precedence
	   z = a - b * -8 + d / 4            // unary minus
	   z = a - 12 * -8 + d / 4           // * and / have same precedence, left associative, so * goes first
	   z = a - -96 + 7 /4                // / goes after *
	   z = 10 - -96 + 1                  // - and + have the same precedence, left associative, so - goes first
	   z = 106 + 1                       // + has higher precedence than =
       z = 107                           // assignment
	 */
    cout<<"The result is "<<z<<endl;

    /* Implicit type conversions
   * When we have an operations with operands of different types, C++ will automatically
   * convert the "smaller" (lower range) value's type to the "larger" (higher range)
   * value's type. This is done automatically, without issues
   *
   * If we try to store a value of a "larger" type into a variable of a "smaller" type,
   * C++ will do it, but it will throw a warning about "narrowing type conversion"
   */
    int i1,i2,i3;
    double d1,d2,d3;

    cout<<"Enter 2 integers and 2 floating-point values: ";
    cin>>i1>>i2>>d1>>d2;

    d3 = d1 * d2 - i1 / i2;
    /* i1 = 15, i2 = 6, d1 = 10, d2 = 5.62
     * Multiply first: d1 - double, d2 - double, 10.0 * 5.62 = 56.2
     * 56.2 - i1/i2
     * Divide next: i1 - int, i2 - int 15/6 = 2 (integer math)
     * 56.2 - 2
     * Subtract next: 56.2 - double, 2 - int: autoconverts int to double 56.2 -2.0 = 54.2
     * d3 = 54.2
     * assignment: d3 - double. 54.2 - double , just assign
     */

    cout<<"Floating point result: "<<d3<<endl;

    i3 = d1 * d2 - i1 / i2;
    /* d1 = 15, d2 = 6, i1 = 10, i2 = 5.62
     * Multiply first: d1 - double, d2 - double, 10.0 * 5.62 = 56.2
     * 56.2 - i1/i2
     * Divide next: i1 - int, i2 - int 15/6 = 2 (integer math)
     * 56.2 - 2
     * Subtract next: 56.2 - double, 2 - int: autoconverts int to double 56.2 -2.0 = 54.2
     * i3 = 54.2
     * assignment: i3 - int, 54.2 - double , "narrower type conversion " - throws warning and truncate
     * i3 = 54
     */
    cout<<"Integer result: "<<i3<<endl;

    /* Explicit type conversions
    * If we wish to quash the C++ warnings about narrowing type conversions, or
    * temporarily change the types of variables, we can use explicit casting.
    * Explicit casting can be done using C-style casting or the static_cast keyowrd.
    */
    i3 = (int) d2 * 8;        // c-style
    /* d2 - double, temporarily pretend d2 is int, ONLY for the multiply. 5 * 4 = 20
     * i3= 20 : i3 - int, 20 is int, just assign.
     * will not throw warnings
     */

    cout<<"i3: (c-style cast): "<<i3<<endl;
    cout<<"d2: "<<d2<<endl;

    d3 = d1 * d3 - static_cast<double>(i1) / i2;
    // Pretend for the division only, that i1 is a double
    cout<<"d3 as int: "<<static_cast<int>(d3)<<endl;
    cout<<"C++ style - static cast - d3: "<<d3<<endl;

    /* One of the most common operations performed in programs is updates
	 * This changes the value in a variable RELATIVE to its previous value.
	 * For example, add 5 to the existing value, Multiply the existing value by 7, etc.
	 * For this, we need to extract the value from the variable, evaluate the
	 * operation, and then store the new updated value BACK INTO THE SAME VARIABLE
	 * Thus, the same variable will appear on both sides of the equal sign.
	 */

    double money;
    double income;

    cout<<"Enter current amount: ";
    cin>>money;

    cout<<"Enter income: ";
    cin>>income;

    money = money + income * 0.8;     //update

    cout<<"Money is now : "<<money<<endl;

    /* If we have an assignment of the form
	 * variable = variable operator  expression
     * then, we can rewrite the assignment as
	 * variable op= expression
	 * This is called Shortcutting.
	 * C++ provides us with shortcuts for all 5 binary math operators.
	 */
    int val1 = 10;

    int val2;
    cout<<"Enter a value for val2: ";
    cin>>val2;

    val1 = val1 + (12 * 0.37 - val2 / 19);

    cout<<"Long form operation: "<< val1 <<endl;

    val1 = 10;
    val1 += 12*0.37- val2/19;   // Uses the += shortcut operator
    cout<<"Shortcut operation: "<< val1 <<endl;


    /* The most common forms for updates are increment (adding 1 to a variable) and
	 * decrement (subtracting 1 from a variable).
	 * For these operations, c++ gives us a shortcut to a shortcut.
	 * The ++ operator, called increment, adds 1 to a variable's value.
	 * Similarly, the -- operator, called decrement, subtracts 1 from a variable's value.
	 * The increment and decrement operators are unary operators, and are attached
	 * to only one variable.
	 */
    int val3 = 10;

    // val3 = val3 + 1 is the same as val3 +=1 is the same as val3++
    cout<<"Before increment: val3 is "<< val3 <<endl;
    val3++;     // post-increment
    cout<<"After increment, val3 is "<< val3 <<endl;

    return 0;
}