C++ - Arithmetic Operators

Arithmetic Operators in C++

In C++, arithmetic operators are used to perform mathematical operations on variables and constants. These operators allow us to carry out basic arithmetic operations such as addition, subtraction, multiplication, division, and modulus.

1. List of C++ Arithmetic Operators

C++ provides the following arithmetic operators:

• + : Addition
• - : Subtraction
• * : Multiplication
• / : Division
• % : Modulus (Remainder)

1.1 Addition (+)

The addition operator is used to add two operands.

#include 
using namespace std;

int main() {
    int a = 5, b = 3;
    cout << "Sum: " << a + b << endl;  // Output: 8
    return 0;
}

In this example, a + b adds the values of a and b, resulting in 8.

1.2 Subtraction (-)

The subtraction operator is used to subtract the right operand from the left operand.

#include 
using namespace std;

int main() {
    int a = 5, b = 3;
    cout << "Difference: " << a - b << endl;  // Output: 2
    return 0;
}

In this example, a - b subtracts b from a, resulting in 2.

1.3 Multiplication (*)

The multiplication operator is used to multiply two operands.

#include 
using namespace std;

int main() {
    int a = 5, b = 3;
    cout << "Product: " << a * b << endl;  // Output: 15
    return 0;
}

Here, a * b multiplies a and b, resulting in 15.

1.4 Division (/)

The division operator is used to divide the left operand by the right operand.

#include 
using namespace std;

int main() {
    int a = 6, b = 3;
    cout << "Quotient: " << a / b << endl;  // Output: 2
    return 0;
}

In this example, a / b divides a by b, resulting in 2.

1.5 Modulus (%)

The modulus operator calculates the remainder when the left operand is divided by the right operand.

#include 
using namespace std;

int main() {
    int a = 5, b = 3;
    cout << "Remainder: " << a % b << endl;  // Output: 2
    return 0;
}

In this example, a % b calculates the remainder when 5 is divided by 3, resulting in 2.

2. Precedence and Associativity of Arithmetic Operators

In C++, arithmetic operators follow certain precedence and associativity rules, which determine the order in which operations are performed in an expression. The precedence rules ensure that operations like multiplication and division are performed before addition and subtraction, unless parentheses are used to override the order.

2.1 Operator Precedence

The operator precedence for arithmetic operators from highest to lowest is:

• *, /, % (Multiplication, Division, Modulus)
• +, - (Addition, Subtraction)

2.2 Operator Associativity

Most arithmetic operators in C++ have left-to-right associativity. This means that if operators of the same precedence appear in an expression, they are evaluated from left to right.

Example of Precedence and Associativity:

#include 
using namespace std;

int main() {
    int result = 5 + 3 * 2;  // Multiplication is performed first due to higher precedence
    cout << "Result: " << result << endl;  // Output: 11
    return 0;
}

In this example, the multiplication 3 * 2 is performed first, resulting in 6, and then the addition 5 + 6 is performed, resulting in 11.

3. Floating Point Arithmetic

C++ supports arithmetic operations on floating-point numbers (such as float and double). When dividing two integers, C++ performs integer division (truncating the result). However, if one or both of the operands are floating-point numbers, the result is a floating-point value.

Example with Integer Division:

#include 
using namespace std;

int main() {
    int a = 5, b = 2;
    cout << "Integer division: " << a / b << endl;  // Output: 2 (fraction part is truncated)
    return 0;
}

Example with Floating-Point Division:

#include 
using namespace std;

int main() {
    float a = 5.0, b = 2.0;
    cout << "Floating-point division: " << a / b << endl;  // Output: 2.5
    return 0;
}

In the first example, integer division truncates the fractional part. In the second example, the result is a floating-point value because the operands are floating-point numbers.

4. Common Errors in Arithmetic Operations

4.1 Division by Zero

Division by zero is undefined and will result in a runtime error or undefined behavior. It's important to check if the divisor is zero before performing division.

Example of Division by Zero Error:

#include 
using namespace std;

int main() {
    int a = 5, b = 0;
    if (b != 0) {
        cout << "Division result: " << a / b << endl;
    } else {
        cout << "Error: Division by zero!" << endl;  // Handle division by zero
    }
    return 0;
}

The program checks whether b is zero before performing the division, preventing the error.

4.2 Modulus with Zero

Like division by zero, attempting to calculate the modulus with zero will also result in an error. Always ensure that the divisor is not zero when using the modulus operator.

Example of Modulus by Zero Error:

#include 
using namespace std;

int main() {
    int a = 5, b = 0;
    if (b != 0) {
        cout << "Modulus result: " << a % b << endl;
    } else {
        cout << "Error: Modulus by zero!" << endl;  // Handle modulus by zero
    }
    return 0;
}

5. Summary of C++ Arithmetic Operators

a + b

a - b

a * b

a / b

a % b