C++ Basics (Part 2)

Operators

• Special built-in symbols that have functionality, and work on operands
  • Operators are actually functions that use a more familiar notation. We'll discuss this further when we get to functions
• operand -- an input to an operator
• Arity - how many operands an operator takes
  • unary operator -- has one operand
  • binary operator -- has two operands
  • ternary operator -- has three operands
• Examples:

    int x, y = 5, z;
  
    z = 10;		// assignment operator (binary)
    x = y + z;		// addition (binary operator)
    x = -y;		// -y is a unary operation (negation)
    x++;			// unary (increment)
  

• cascading - linking of multiple operators, especially of related categories, together in a single statement:

    x = a + b + c - d + e;	// cascading arithmetic operators
    x = y = z = 3;		// cascading assignment operators
  

  This works because the result of one operation sends back the answer (i.e. a return value) in its place, to be used in the next piece of the statement. In the above, (a + b) happens first, then the answer becomes the first operand in the next + operation.
   
• Precedence - rules specifying which operators come first in a statement containing multiple operators

    x = a + b * c;	// b * c happens first, since * has higher 
  			//  precedence than +
  

• Associativity - rules specifying which operators are evaluated first when they have the same level of precedence.
  • Most (but not all) operators associate from left to right.

Assignment Operator

• Value on the right side (R-value) is assigned to (i.e. stored in) the location (variable) on the left side (L-value)
  • R-value -- any expression that evaluates to a single value (name comes from "right" side of assignment operator)
  • L-value -- A storage location! (not any old expression). A variable or a reference to a location. (name comes from "left" side of assignment operator
  • Typical usage:
    

    variable_name = expression

• The assignment operator returns a reference to the L-value
• Examples

    x = 5; 
    y = 10.3; 
    z = x + y;   // right side can be an expression 
  
    a + 3 = b;   // ILLEGAL!  Left side must be a storage location 
  

• Associates right-to-left

    x = y = z = 5;    // z = 5 evaluated first, returns z
  

• Use appropriate types when assigning values to variables:

    int x, y;
    x = 5843;		
    y = -1234;		// assigning integers to int variables
  
  double a, b;
    a = 12.98;
    b = -345.8;		// can assign decimal numbers to float types
  
    char letter, symb;
    letter = 'Z';
    symb = '$';		// can assign character literals to char types
  
    bool flag;
    flag = true;
    flag = false;		// can assign true or false to bool variables
  

• Be careful to not confuse assignment = with comparison ==

Arithmetic Operators

• Division is a special case
  • Modulus % not legal for floating point types. / gives floating point result

      double x = 19.0, y = 5.0, z;
      z = x / y;			// z is now 3.8
     

  • For integer types, / gives the quotient, and % gives the remainder (as in long division)

      int x = 19, y = 5, q, r;
      q = x / y;			// q is 3
      r = x % y;			// r is 4
     

• An operation on two operands of the same type returns the same type
• An operation on mixed types (if compatible) returns the "larger" type (see "Automatic Type Conversions" below).

    int x = 5; 
    float y = 3.6; 
    z = x + y;		// what does z need to be?  x + y returns a float.
  

Operator precedence

• Arithmetic has usual precedence
  1. parentheses
  2. Unary minus
  3. *, /, and %
  4. + and -
  5. operators on same level associate left to right
• Many different levels of operator precedence (about 18)
• When in doubt, can always use parentheses
• Example:

    z = a - b * -c + d / (e - f);	     // 7 operators in this statement
  

  What order are they evaluated in?

Example of basic arithmetic operations
 

Some short-cut assignment operators (with arithmetic)

  v += e;    means    v = v + e; 
  v -= e;    means    v = v - e; 
  v *= e;    means    v = v * e; 
  v /= e;    means    v = v / e; 
  v %= e;    means    v = v % e; 

Increment and Decrement Operators

  ++x;	// pre-increment (returns reference to new x)
  x++;	// post-increment (returns value of old x)
		// shortcuts for x = x + 1

  --x;	// pre-decrement
  x--;  // post-decrement
		// shortcuts for x = x - 1

• Pre-increment: incrementing is done before the value of x is used in the rest of the expression
• Post-increment: incrementing is done after the value of x is used in the rest of the expression
• Note - this only matters if the variable is actually used in another expression. These two statements by themselves have the same effect:

   x++;
   ++x;
  

• Examples

    int x = 5, count = 7;
    result = x * ++count;		// result = 40, count = 8
  
    int x = 5, count = 7;
    result = x * count++;		// result = 35, count = 8
  

Automatic Type Conversions

• Typically, matching types are expected in expressions
• If types don't match, ambiguity must be resolved
• There are some legal automatic conversions bewteen built-in types. Rules can be created for doing automatic type conversions between user-defined types, too
• For atomic data types, can go from "smaller" to "larger" types when loading a value into a storage location. General rule of thumb: Allowed if no chance for partial data loss

    char -> short -> int -> long -> float -> double -> long double
  

• Should avoid mixing unsigned and signed types, if possible
• Examples:

   int          i1, i2; 
   double       d1, d2; 
   char         c1; 
   unsigned int u1;
  
   d1 = i1;       // legal.  
   c1 = i1;       // illegal.  trying to stuff int into char (usually 1 byte) 
   i1 = d1;       // illegal.  Might lose decimal point data.
   i1 = c1;       // legal 
   u1 = i1;	// dangerous (possibly no warning)
   d2 = d1 + i2;  // result of double + int is a double
   d2 = d1 / i2;  // floating point division (at least one operand a float type) 
  

Explicit type conversions (casting)

• Older C-style cast operations look like:

   c1 = (char)i2;   // cast a copy of the value of i2 as a char, and assign to c1 
   i1 = (int)d2;    // cast a copy of the value of d2 as an int, and assign to i1 
  

• Better to use newer C++ cast operators. For casting between regular variables, use static_cast

    c1 = static_cast<char>(i2); 
    i1 = static_cast<int>(d2); 
  

• Just for completeness, the newer C++ cast operators are:
  • static_cast
  • dynamic_cast
  • const_cast
  • reinterpret_cast