Bind function and placeholders in C++

3.7

Sometimes we need to manipulate the operation of a function according to the need, i.e changing some arguments to default etc. Predefining a function to have default arguments restricts the versatility of a function and forces us to use the default arguments and that too with similar value each time. From C++11 onwards, the introduction of bind function has made this task easier.

How does bind() work?
Bind function with the help of placeholders, helps to manipulate the position and number of values to be used by the function and modifies the function according to the desired output.

What are placeholders?
Placeholders are namespace which direct the position of a value in a function. They are represented by _1, _2, _3

// C++ code to demonstrate bind() and
// placeholders
#include <iostream>
#include <functional> // for bind()
using namespace std;

// for placeholders
using namespace std::placeholders;

// Driver function to demonstrate bind()
void func(int a, int b, int c)
{
    cout << (a - b - c) << endl;
}

int main()
{
    // for placeholders
    using namespace std::placeholders;

    // Use of bind() to bind the function
    // _1 is for first parameter and assigned
    // to 'a' in above declaration.
    // 2 is assigned to b
    // 3 is assigned to c
    auto fn1 =  bind(func, _1, 2, 3);

    // 2 is assigned to a.
    // _1 is for first parameter and assigned
    // to 'b' in above declaration.
    // 3 is assigned to c.
    auto fn2 =  bind(func, 2, _1, 3);

    // calling of modified functions
    fn1(10);
    fn2(10);

    return 0;
}

Output:

5
-11

In the above code, bind() modified the call of a function to take 1 argument and returned the desired output.

Properties of placeholders

1. The position of placeholder determines the value position in function call statement

// C++ code to demonstrate placeholder
// property 1
#include <iostream>
#include <functional> // for bind()
using namespace std;

// for placeholders
using namespace std::placeholders;

// Driver function to demonstrate bind()
void func(int a, int b, int c)
{
    cout << (a - b - c) << endl;
}

int main ()
{
    // for placeholders
    using namespace std::placeholders;

    // Second parameter to fn1() is assigned
    // to 'a' in fun().
    // 2 is assigned to 'b' in fun
    // First parameter to fn1() is assigned
    // to 'c' in fun().
    auto fn1 =  bind(func, _2, 2, _1);

    // calling of function
    cout << "The value of function is : ";
    fn1(1, 13);

    // First parameter to fn2() is assigned
    // to 'a' in fun().
    // 2 is assigned to 'b' in fun
    // Second parameter to fn2() is assigned
    // to 'c' in fun().
    auto fn2 =  bind(func, _1, 2, _2);

    // calling of same function
    cout << "The value of function after changing"
         " placeholder position is : ";
    fn2(1, 13);

    return 0;
}

Output:

The value of function is : 10
The value of function after changing placeholder position is : -14

In the above code, even though the position of 1 and 13 were same in function call, the change in position of placeholders changed the way function was called.

 

2. The number of placeholders determine the number of arguments required to pass in function
We can use any no. of placeholders in function call statement (obviously less than the maximum number of arguments). The rest values are replaced by the user defined default values.

// C++ code to demonstrate placeholder 
// property 2
#include <iostream>     
#include <functional> // for bind()
using namespace std;

// for placeholders
using namespace std::placeholders; 

// Driver function to demonstrate bind()
void func(int a,int b, int c)
{   
    cout << (a - b - c) << endl;
}

int main() 
{
    // for placeholders
    using namespace std::placeholders;
    
    // 1 placeholder  
    auto fn1 =  bind(func, _1, 2, 4);
     
    // calling of function with 1 argument
    cout << "The value of function with 1 "
             "placeholder is : ";
    fn1(10);
       
    // 2 placeholders 
    auto fn2 =  bind(func,_1,2,_2);
     
    // calling of function with 2 arguments
    cout << "The value of function with 2"
            " placeholders is : ";
    fn2(13, 1);
       
    // 3 placeholders 
    auto fn3 =  bind(func,_1, _3, _2);
     
    // calling of function with 3 arguments
    cout << "The value of function with 3 "
            "placeholders is : ";
    fn3(13, 1, 4);
       
    return 0;  
}

Output:

The value of function with 1 placeholder is : 4
The value of function with 2 placeholders is : 10
The value of function with 3 placeholders is : 8

In the above code, clearly the no. of placeholders equated the number of arguments required to call the function. The binding of function is directed by number and position of placeholders.

This article is contributed by Manjeet Singh. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.

Recommended Posts:



3.7 Average Difficulty : 3.7/5.0
Based on 8 vote(s)










Writing code in comment? Please use ide.geeksforgeeks.org, generate link and share the link here.