/* This program demonstrates
 *  * 1. Constants and symbolic constants
 * 2. Using cin for input
 * 3. Formatting floating point output
 * 4. Introduction to operators
*/
#include<iostream>
#include<iomanip>       // used for floating-point formatting
using namespace std;

/* A symbolic constant is a way of defining a constant that C++ inherited from C.
 * We use the #define directive to define a symbol (identifier) as a constant.
 * A symbolic constant is not a variable, since it doesn;t technically have a defined
 * data type and it is not stored in memory.
 * Intead, the preprocessor will REPLACE evey mention of the name with the value
 * BEFORE the program is compiled.
 * This is called macro expansion and creates several security vulnerabilities.
 * While we introduce it for enabling legacy code, they are not recommended while
 * writing new programs.
 * The following line defines a symbolic costant E of the value 2.87.
 */

#define E 2.87      // please note - no "=", no semicolon

int main()
{
   /* A constant is a value that does not change.
     * This is a variable prefixed with the keyword "const". In this case, a variable
     * is created and stored in memory. Also, we cannot separate the declaration and
     * initialization steps for const variables. It has to be done in one line. */

    const double PI= 3.14159;
    // PI = 22/7;           //error - cannot change a constant
    cout<<PI<<endl;
    cout<<"Area: "<<PI * 15 * 15<<endl;

    /* Using the symbolic constant defined above
     */
    cout<<"E: "<<E<<endl;
    double etimes5 = E * 5;
    cout<<"etimes5: "<<etimes5<<endl;

    /* User input with cin
     * If we just use cin, then the cursor is going to blink, waiting for
     * user input. However, the user does not know what to do. So, it is
     * standard practice to "prompt" the user. A prompt is a cout statement
     * that tells the user about the computer's expectations. */
    cout<<"Enter 2 integers and a float: ";

    /* The cin statement is the opposite of cout. It takes values from the screen
     * and brings it into the program. The arrows point towards the variable.
     * We need to wait till the user presses Enter or enters some whitespace, for
     * the transfer to happen. 
     * cin can be cascaded just like cout.
	 * cin >> x; is equivalent to x = <user entered value>
	 */
    int x,y;            // first 2 inputs
    double a;           // third input
    cin >> x >> y >> a;

    /* We can now use those values in our calculations */
    double sum = x + y + a;
    cout<<"Sum: "<<sum<<endl;

    /* Most C++ compilers have a "default" formatting for a floating point number,
     * where they would print a certain number of digits after the decimal point.
     * Usually this number is 4, 5 or 6.
     * cout has a few qualifiers that can be used to format data. These are in
     * the iomanip library. These are not printed. However, every following cout
     * statement is formatted according to these qualifiers until they are
     * changed or the program ends.
     * 1. To print in fixed notation, say "fixed". To print in scientific
     *    notation, say "scientific".
     * 2. setprecision defines the number of digits to be printed after the
     *    decimal point. In the example below, we round it off to 3 digits
     *    after the decimal point.
     * 3. Say "showpoint" if we want the decimal point to be displayed even
     *    if the number is whole, like 5.0*/

    cout<<fixed<< showpoint << setprecision (3);
    cout<<"Rounded sum: "<<sum<<endl;

    /* Please note that this 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<<setprecision(6);
    cout<<"sum * 100: "<<sum*100<<endl;

    /* Assignment
	 * In programming '=' is the assigment operator. When used in a program,
	 * it is not asserting that the two quantities on either side are the same.
	 * Instead, the expression on the right is evaluated into a single value and then
	 * that value is stored in the variable on the left.
	 * Thus, the quantity on the left (L-value) can ONLY be  a variable
	 * The expression on the right can be a variable, a number literal, a mathematical
	 * expression comprised of variables and/or literals.
	 * Use of the assignment operator will CHANGE the value in the left operand. The old
	 * value can no longer be recovered.
	 * Assignment has lower precedence than most other operators.
	 */

    x = y + 5;  // ok - change x to y+5. Comment this out to use the user entered value

    // y + 5 = x;  // Not ok. y+5 is not an L-value

    /* Prompt the user and read in the values for 2 ints
	 */
    cout<<"Enter the values of x and y: ";
    cin>>x>>y;

    /* The 4 basic arithmetic operators work as usual.
     * Using a mathematical expression in a program DOES NOT CHANGE the values
     * of the variables in the expression (unless the shortcut operators are involved).
     */

    cout<<"x + y : "<< x + y<<endl;
    cout<<" x - y : "<< x - y <<endl;
    cout<<" x * y : "<< x * y <<endl;
    cout<<" x / y : "<< x/y <<endl;

    /* The modulus (%) is an operation defines only for integers.
     * When we perform the operation num1 % num2, the result is the
     * remainder when we divide num1 with num2. It is what's left after the
     * division, since integers cannot store fractional parts.
     * For example, 39%6 = 3.
     */
    cout<<" x % y : "<< x%y <<endl;
    
    return 0;
}