Expressions, and how to compute their value

Definitions.

• An expression (such as 20*30) is how you tell the computer to perform arithmetic (and/or other more exotic operations).
  We use an asterisk (*) for multiplication.
• Every expression has a value.
  For example, the value of the expression 20*30 is 600.
  
• Since the expression 20*30 has a value, it can be used as part of a larger expression such as 10+20*30.
• Every value has a type, just as every variable has a type.
  For example, the value 610 is of type int, and the value 'A' is of type char.
• An expression is made of operators and operands.
• Some examples of operators are     +     -     *     /     etc.
  They stand for addition, subtraction, multiplication, and division.
  Why don’t we use lowercase x for multiplication?
• The operands in an expression could be literals such as     10     20     3.14
  The operands in an expression could also be variables such as     i     j     k     price
  So here are three expressions:     10+20     price+20     i-j+10
• In C++, an operator has one of three possible arities:
  • unary (one operand):     -a     +a
  • binary (two operands):     a+b     a-b     b=a     cout<<a     cin>>a
  • ternary (three operands):     a?b:c

1. places.C: three places where we can write an expression in a C++ program.
2. An expression could be built out of literals

   	int i {10 + 20}; //i is born holding 30
   

   or out of variables that are currently holding a value:

   	int j {10};      //j is born holding 10
   	int k {j + 20};  //k is born holding 30
   

   Don’t do this:

   	int j;           //j is born containing unpredictable garbage
   	int k {j + 20};  //k is born containing bigger unpredictable garbage
   

   And the following snippet will be totally rejected by our C++ compiler c++. The program won’t even “compile”.

   	int k {j + 20};  //The computer doesn't know yet what "j" means.
   	int j {10};
   

3. precedence.C:
   * (multiplication, line 5) has higher precedence then + (addition, line 6).
   - (negative, line 3) has higher precedence then - (subtraction, line 6).
   See lines 5 and 6 of this table.
   Note that - (negative, line 3) is a unary operator, while - (minus, line 6) is a binary operator. That’s how you tell them apart.
4. associativity.C: addition and subtraction have left-to-right associativity.
   See line 6 of this table (the rightmost column).
5. lobster.C. Example of an expression.

   	Then you bank the heat and let the kettle simmer—ten minutes for the first pound of lobster, then three minutes for each pound after that. (This is assuming you’ve got hard shell lobsters, which, again, if you don’t live between Boston and Halifax is probably what you’ve got. For shedders [soft-shell], you’re supposed to subtract three minutes from the total.)
   	—David Foster Wallace, Consider the Lobster