C++ - Difference between Functors and Functions

In this article, you will learn the difference between the functors and the function. But before discussing their differences, you must know about the functors and the functions in C++.

What are Functors in C++?

A functor is sometimes known as a "function object". It is an object that may be called much like a function in C++. Class instances that override the operator() function call are called functors. It makes it possible to utilize objects similarly to functions, giving classes a means of encapsulating behavior.

Key Elements of Functors:

There are several key elements of the functors. Some main elements of the functors are as follows:

1. Object-Oriented Callability

Functions are objects with the capacity to be called like functions. It is known as object-oriented callability. It renders them adaptable in situations where a more complex function is needed.

2. Encapsulation of State

In contrast to normal functions, functors are capable of containing internal states. Information can be maintained over several invocations by modifying and retaining this state in between calls.

3. Flexibility in Usage

The design and use of functions are both flexible. Code that is more expressive and reusable can be produced by customizing it to encapsulate particular behaviors and to include member variables for state maintenance.

4. Nature

Objects instantiated from a class that overrides the operator() function call are known as functors.

5. Statefulness

Functors that possess an internal state can preserve data in between calls, which is known as statefulness.

6. Usage

As functors may preserve state, they offer greater flexibility and are appropriate in situations where encapsulated behavior and state are needed.

Syntax:

It has the following syntax:

class AddFunctor
 {
public:
 int operator()(int a, int b) 
 {
 return a + b;
 }
};

Advantages of Functors

There are several advantages of the functors. Some main advantages of the functors are as follows:

Customization: Using functors, developers can construct highly customized callable entities by encapsulating state and modifying behavior as appropriate.
Code Reusability: Code reusability is improved by grouping related behaviors into classes. Reusing functors in various codebase sections is simple.
Functional Programming Style: Functors help make C++ programming more functional by giving you an object-passing method that's particularly helpful for algorithms and standard library functions.

Example:

Let's take an example to illustrate the use of functors in C++:

#include <iostream>
class MultiplyFunctor
{
private:
 int factor;
public:
 MultiplyFunctor(int f) : factor(f) {}
 int operator()(int value) const 
 {
 return value * factor;
 }
};
int main()
{
 MultiplyFunctor multiplyByTwo(2);
 MultiplyFunctor multiplyByThree(3);
 int result1 = multiplyByTwo(5);
 int result2 = multiplyByThree(5);
 std::cout << "Result of multiplying by two: " << result1 << std::endl;
 std::cout << "Result of multiplying by three: " << result2 << std::endl;
 return 0;
}

Output:

Result of multiplying by two: 10
Result of multiplying by three: 15

Explanation:

1. Header inclusion

The <iostream> header is included in the code, which is required for C++ input and output operations.

2. Functor Class Definition

The code defines a functor class called MultiplyFunctor.
The class contains a public constructor and a private member variable factor to initialize it.
The overloading of the operator() function call, which enables instances of the class to be called as functions, is the primary feature of this class.

3. Constructor

Upon receiving an integer f as an argument, the MultiplyFunctor constructor initializes the private member factor with the provided value.

4. Function Call Operator Overloading

The operator() function multiplies an integer value using the internal factor when it receives it as an input.
This operator overloading allows instances of MultiplyFunctor to be used as if they were functions.

5. Main function

The program's entry point serves as its principal purpose.
A pair of MultiplyFunctor instances are generated, denoted as multiplyByTwo and multiplyByThree with a factor of 2 and 3.

6. Using Functors

After that, the multiplication is carried out using the functors like calling functions.
multiplyByTwo(5) and multiplyByThree(5) multiply the number 5 by the corresponding factors, 2 and 3.

7. Finding and Displaying Results

The results are displayed using std::cout to print messages to the console.

8. Return Statement

The return 0; statement indicates that the program executed successfully.

What are C++ Functions?

A function in C++ is a reusable code block that carries out a particular task. Coding can be made more legible, maintainable, and efficient by using functions to organize and modularize it. A key component of C++ program organization and code reuse is the use of functions.

Key Features of Functions in C++

There are several key features of the functions. Some main features of the functions are as follows:

1. The Declaration and Definition

Function names, return types, and any parameters are included in the signature that is appended to a declared function. After that, the function's real implementation is specified when they are defined independently.

2. Return Type

A value of a given type may be returned by functions. In the function signature, the return type is declared before the function name. The return type of a function is designated as 'void' if it returns nothing.

3. Parameters

Functions can accept zero or more parameters, which are values that are supplied to them as input. The function signature contains a list of parameters, which are utilized in the function body.

4. Function Call

When calling a function from another section of the program, you can use the function name followed by a parenthesis; if the function requires arguments, one may also pass them.

5. Organization of Code

Functions support a structured and intelligible codebase by helping to arrange code into modular components. It aids in collaboration, maintenance, and debugging.

Syntax:

It has the following syntax:

//Function declaration
return_type function_name(parameter_type1 parameter_name1, parameter_type2 parameter_name2, ...) 
{
 // Function body
 // Code to perform a specific task
 return result; 
// Optional: Return a value of return_type
}
// Example of a function call
return_type result_variable = function_name(argument1, argument2, ...);

return_type: The value type that a function can return. If the function yields no value, use 'void'.

function_name: The function's name. It needs to follow C++'s variable naming rules.

parameter_type: The kind of parameters that can be entered into the function. There can be zero or more parameters in a function; they are optional.

Function Body: It consists of the statements defining the function's behavior.

Return statement: It is not required. It is used to give the function's value back. It omitted in cases where the function's return type is 'void'.

Advantages of functions:

There are several advantages of the functions. Some main advantages of the functions are as follows:

Code Reusability: Code reuse is encouraged throughout the program by developers using functions to encapsulate certain functionality.
Abstraction: Programmers may concentrate on high-level logic without worrying about the implementation specifics because of the abstraction level that functions offer.
Readability and Maintainability: Dividing a program into functions improves the readability of the code and facilitates its understanding, maintenance, and debugging.

Example:

Let's take an example to illustrate the use of functions in C++:

#include <iostream>
// Function declaration
int add(int a, int b);
int main() 
{
 // Function call
 int result = add(3, 5);
 // Displaying the result
 std::cout << "Result of addition: " << result << std::endl;
 return 0;
}
// Function definition
int add(int a, int b)
{
 // Function body
 int sum = a + b;
 // Return the result
 return sum;
}

Output:

Result of addition: 8

Explanation:

1. Function Declaration

The Function Declaration part defines the name, parameters (int a and int b), and return type (int in this example) of the function.

2. Function Definition

This definition describes how the function is implemented. It consists of the function body, where the actual operation is done.

3. In this example, the add function computes the sum of its parameters (a and b) and returns the result as a number.

4. Function Call

The values 3 and 5 are passed as arguments when the add(3, 5) function in the main function is called.

5. After being stored in the variable result, the outcome is displayed.

Difference between Functors and Functions

There are several difference between the Functors and Functions. Some main differences between the Functors and Functions are as follows:

1. Flexibility

Functions:

Functions are inflexible about behavior and statelessness.
Restricted flexibility in contrast to functors.

Functors:

Functors have an internal state, which gives them a greater degree of flexibility.
They are flexible enough to hold information and encapsulate particular behaviors.

2. Invocation

Functions:

It is used to call the function by giving the arguments inside the brackets after the function name.

Functors:

It is called by invoking the functor object in parentheses and giving arguments, much like a function.

3. Usage Scenarios

Functions:

It is applied to stateless activities and ordinary procedural programming.

Functors:

It is usually utilized in situations where a callable entity must maintain state and encapsulate behavior.
It is useful when a callable object must keep information between calls, such as in custom sorting algorithms.

4. Nature and the Object-Centered Aspect

Functions:

The programming paradigm used by traditional C++ functions is procedural.
Based on their input parameters, they function as independent entities.

Functors:

Class instances that overload the operator() function call are known as functors.
They can be invoked like functions because of their object-oriented nature.

5. Statefulness

Functions:

Functions are stateless because their behavior is entirely dependent on their input parameters.

Functors:

Functors are capable of having internal states because they are instances of classes.
Functors can maintain information in between calls because of this internal state.