/* This program demonstrates
 * 1. The sizeof operator
 * 2. Unsigned integers
 * 3. shortcut operators
 * 4. Increment and decrement
 
#include<iostream>
#include<iomanip>
using namespace std;

int main()
{
	/* The sizeof operator gives us the size (in bytes) of a dtat type or a variable */
    int num1;
    cout<<"The size of num1: "<< sizeof(num1)<<" bytes"<<endl;
    cout<<"Size of doubles: "<< sizeof(double)<<" bytes"<<endl;

    /* Typically, the numeric types can store both positive and negative values. However, this
   * reduces the largest/smallest numbers we can store in the variable to half the domain size.
   * If we're sure that the value in a variable will only be positive, we can make use of the
   * entire domain size, by qualifying the variable as "unsigned"
   * This is only defined for integer types - char, short, int, and long
   */

    num1 = 0xfffffffffffffff9;  // value close to 2 ^ 32
    // count of possible values: 2^32
    // range: -2^31 : 2^31 -1

    cout<<"Signed int: "<< num1<<endl; // will print a negative number, since value is greater than 2^31-1

    unsigned num2 = 0xfffffffffffffff9; // store the same value in an unsigned int variable
    // count of possible values: 2^32
    // range: 0 : 2^32 -1

    cout<<"Unsigned int, num2: "<<num2<<endl;    // will print the actual value
	
	double sum = 2695.926591;
	cout<<fixed<<setprecision(3);
	cout<<"Sum rrounded to 3 digits after the decimal point: "<< sum <<endl;
	
	/* Please note that setprecision only "formats" the number for printing. The actual
     * data in the variable does not change. For example, the following line will
     * use the "unrounded" original data in "sum" for the calculation, even if
     * the previous line printed the rounded value
     * */

    cout<<"sum * 1000: "<<sum*1000<<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.
	 * If attached before the variable, it's called pre increment/decrement.
	 * If attached after the variable, it's called post increment/decrement.
	 */
    int val3 = 10;

    // val3 = val3 + 1
    // val3 += 1

    cout<<"Before increment: val3 is "<< val3 <<endl;
    val3++;     // post-increment
    cout<<"After increment, val3 is "<< val3 <<endl;
    ++val3;     // pre-increment
    cout<<"After second increment: "<< val3 <<endl;

    val3 = val3 - 1;
    val3 -= 1;
    val3--;
    --val3;
    cout<<"After 4 decrements: "<< val3 <<endl;

    /* Pre and post increment/decrement function the same way, when in a line by themselves.
    * When a part of another R-value expression, pre-increment/decrement has higher precedence
    * than any other math operator, and will be done first.
    * Post-increment/decrement has lower precedence than even assignment, and will
    * be done last, after assignment.
    */
    int exp = 20 * val3++;
    cout<<"Exp, post increment: "<< exp <<"\nval3: "<< val3 <<endl;

    exp = 20 * ++val3;
    cout<<"Exp, pre-increment: "<< exp <<"\nval3: "<< val3 <<endl;

	return 0;
}