Introduction to Parameterized Functions:

A parameterized function in C++ is a function that accepts one or more arguments, which are used within the function to perform a specific task. The primary advantage of parameterized functions is their flexibility. By passing different values to the parameters, the same function can be used to perform various operations, making your code reusable and more concise.

Code Example: Simple Calculator Class with Parameterized Functions

#include <iostream>
using namespace std;

class Calculator {
private:
    int a; // Attributes of the class
    int b;

public:
    // Method for sum
    int sum(int a, int b) {
        return a + b;
    }

    // Method for subtraction
    int subtract(int a, int b) {
        return a - b;
    }

    // Method for multiplication
    int multiply(int a, int b) {
        return a * b;
    }
};

int main() {
    // Creating an instance of the Calculator class
    Calculator calc;

    // Calling methods and printing the results
    cout << "Sum: " << calc.sum(10, 5) << endl;
    cout << "Subtraction: " << calc.subtract(10, 5) << endl;
    cout << "Multiplication: " << calc.multiply(10, 5) << endl;

    return 0;
}

Explanation of Code:

1. Class Definition (Calculator):
   • Attributes:
     • int a, int b: These are private attributes of the Calculator class. While they are declared, they are not used directly within the methods in this case, as we are passing arguments to the functions. However, they could be used to store state for more complex operations.
   • Parameterized Methods:
     • sum(int a, int b): This method takes two integer arguments (a and b) and returns their sum. The parameters a and b are local to the function and are used within it.
     • subtract(int a, int b): Similar to the sum method, this method accepts two integer arguments and returns their difference (the result of subtracting b from a).
     • multiply(int a, int b): This method accepts two integers and returns their product.
   • Why Use Parameters in Functions?
     • The methods sum(), subtract(), and multiply() are parameterized because they need input values to compute the result. This allows the functions to work with different inputs without needing to rewrite the code.
2. Main Function:
   • Creating an Instance (Calculator calc):
     • An object calc of the Calculator class is created. This object will be used to access the methods of the class.
   • Calling Parameterized Functions:
     • calc.sum(10, 5): The sum method is called on the calc object with the values 10 and 5. The method will compute 10 + 5 and return the result, which is 15.
     • calc.subtract(10, 5): The subtract method is called with 10 and 5. It computes 10 - 5, which is 5.
     • calc.multiply(10, 5): The multiply method is called with 10 and 5. It computes 10 * 5, which is 50.
   • Output: The results are printed using cout. Each method call performs a calculation and displays the result on the screen.

Output of the Program:

Sum: 15
Subtraction: 5
Multiplication: 50

Explanation of Output:

• Sum: The sum() method adds the two input numbers, 10 and 5, and outputs 15.
• Subtraction: The subtract() method subtracts 5 from 10, resulting in 5.
• Multiplication: The multiply() method multiplies 10 and 5, yielding 50.

Why Parameterized Functions?

• Reusability: The same function can be used to perform operations with different inputs. For example, the sum() method can calculate the sum of any two integers, not just 10 and 5.
• Cleaner Code: Instead of writing separate methods for every combination of input values, parameterized functions allow you to create more general-purpose code.
• Flexibility: The values passed to the parameters can change each time the function is called, giving flexibility in the computations.

Key Points to Note:

• Parameterized methods allow us to pass values to functions, making the code reusable for different inputs.
• Class attributes store the values that can be used across different methods within the class.
• The main method is where the object is created, and the methods of the class are called to perform specific tasks.

Conclusion:

Parameterized functions are an essential concept in C++ that allows you to write flexible and reusable code. By accepting input values as arguments, these functions can perform a wide range of operations on different inputs. This makes them especially useful in scenarios where you need to perform repetitive tasks with varying data. In the provided example of a simple calculator, the parameterized methods sum(), subtract(), and multiply() perform arithmetic operations based on user-provided values, demonstrating the power of parameterized functions in C++.