C++ Chapter 5: Expressions and Arithmetic

• Chapter 5 focuses on expressions and arithmetic in C++.

Class Objectives

• Explain category operators, arithmetic, and expressions.
• Implement category operators, arithmetic, and expressions.

Arithmetic

• Arithmetic refers to basic mathematical operations used for calculations.
• In programming, arithmetic operations typically involve numbers and are used for various purposes.
• Arithmetic operations take two operands, with an operator on each side, and are used for performing numeric calculations.
• Arithmetic can manipulate integral and floating data types.
• There are five types of arithmetic operators:
  • Addition (+)
  • Subtraction (-)
  • Multiplication (*)
  • Division (/)
  • Modulus (%)
• Category operators include:
  • Unary: Single operand, starts from the front (e.g., +a)
  • Binary: Between two operands (e.g., a + b)
  • Ternary: Involves three operands (e.g., a + b - c)
• For division:
  • If both operands are integers, the result is an integer.
  • If one operand is a floating-point number, the result is a floating-point number.
• Modulus (%) in C++:
  • Yields the remainder of a division.
  • Usable if both operands are integers.
  • Cannot be applied to floating-point numbers.
  • Can be used to:
    • Determine odd or even numbers
    • Calculate time
    • Execute repeating algorithms

Expressions

• In programming, an expression is a combination of values, variables, operators, and functions that produces a new value.
• Short formula: Expression = Operand + Operator
• Represents a computation that groups them together and evaluates to a value, variable, and operator.
• Describes a computation that involves values, variables, and operators.
• Expressions in C++ involve a combination of values, variables, operators, or functions that compute a new value within the code.
• Expression Categories:
  • Arithmetic Expression (Pengiraan Matematik)
    • Contains mathematical operations such as +, -, *, /, %, **
  • Comparison Expression (True/False)
  • Logical Expression (True/False)
    • Uses logical operators such as AND, OR, NOT for logical decisions.
• Arithmetic expressions use arithmetic operations to express mathematical expressions in C++.
• Boolean Expressions:
  • Boolean expressions have relational and/or logical operators operating on Boolean variables.
  • Can use operators such as <, <=, >, >=, ==, !=
• Relational Boolean Expressions Example:
  • Given x = 5 and y = 7, expressions like x < y (True), x + 5 < y (False), x != y (True), x + 3 >= y (True), y == x (False), and y == x+2 (True).
• Common usages of Boolean expressions:
  • Check if taxRate is over 15% and income is less than RM7000: (taxRate > 0.15) && (income < 7000)
  • Check if grade is less than 50 or absent is more than 30%: (grade <50) || (absent > 0.30)
  • Check if age is between 18 and 30: (age>=18) && (age<=30)
  • Check if age is equals 18 or 19: (age==18) || (age==19)
  • Check if temperature is not equals 100: !(temperature==100)
• Boolean expressions have three logical operator types (And, Or, Not) and returns either True or False.

Operator Precedence and Associativity

• Precedence is the order in which operators are evaluated (from high to low priority).
• Associativity determines how operators of the same precedence are grouped in the absence of parentheses.
• Grouping can be either from left to right or right to left, which affects the final evaluated result.
• Operator precedence in C++ from highest to lowest priority:
  • Function calls, array access () [] ->
  • Multiplication, division, modulus *, /,%
  • Addition, subtraction + -
  • Comparison < > <= >=
  • Equality == !=
  • Logical AND &&
  • Assignment = += -=
• The operator associativity is the direction from which an expression is evaluated.

Conversion

• Conversion means changing one data type to another.
• Conversion takes place in expressions that contain different numeric data types.

Types of Conversion

• Implicit conversion occurs automatically when changing a smaller data type to a larger one.
  • There is no data loss due to widening conversion.
• Explicit conversion is done manually by the programmer using type casting.
  • Requires care to avoid data loss due to narrowing conversion.
• Unary operators
  • Defined as increment and decrement operators.
  • Two types: Prefix and Postfix
    • Prefix (++variable): Value is incremented (+1) before use.
    • Postfix (variable++): Value is incremented (+1) after use.
• Compound expressions
  • Operators apply an operation to an object, then store the result back into the object
  • E.g. i += 6; which is the same as i = i + 6;
    • i will now be 9
    • Another example: float j = 5.2;' j *= 2.0;, where j` will now be 10.4
• Shorthand assignment operators are used to perform an arithmetic function on an operand and assign a new value to the operand in the same operation.
  • Example operators: +=, -=, *=, /=, %=
• Accumulate value
  • Repeatable variables add to accumulate a total value
  • Examples:
    • int total = 0;' total = total + 2;, where total` will be 2
    • total = total + 4;, where total will be 6
    • total = total + 6;, where total will be 12
    • total = total + 8;, where total will be 20