C++ Operators, Arithmetic, and Conversions

The same operator can produce different behavior for different operand types. With two integers, division produces an integer quotient. If either operand is floating point, floating-point division occurs. That means assigning the final result to double is too late if the division already happened as integers.

Multiplication can overflow before assignment to a wider destination for the same reason. Promote an operand before the operation when the wider range is required. Units matter too: adding seconds to bytes is type-correct at the language level but wrong for the domain.

#include <iostream>

int main()
{
  int total{17};
  int count{4};

  double wrong{total / count};
  double correct{static_cast<double>(total) / count};

  std::cout << "Integer first: " << wrong << '\n';
  std::cout << "Converted first: " << correct << '\n';
}

Integer first: 4
Converted first: 4.25

Multiplication and division bind more tightly than addition and subtraction, so subtotal + tax * quantity does not group like (subtotal + tax) * quantity. Parentheses document the intended formula and protect it during later edits.

Compound assignment such as total += price updates the left operand. Increment is convenient for counters, but avoid putting several increments inside one expression. A separate statement makes evaluation and debugging easier to reason about.

Comparison operators produce bool: equality, inequality, ordering, and range facts. Logical AND requires both facts, logical OR requires at least one, and logical NOT reverses a Boolean. Short-circuit evaluation means the right side of && is skipped when the left side is false, which can safely guard an operation.

Implicit conversions are convenient when no information is lost, but narrowing should be visible. static_cast<int>(measurement) tells the reader that discarding a fraction is intentional; it does not prove the value fits. Validate ranges before narrowing external or large values.

Prefer storing a value in the representation the domain needs. Cents as an integer avoid fractional cents for a simple exercise. Real financial systems still need defined currencies, rounding modes, limits, and decimal rules rather than a single primitive type.