Bind-functie en tijdelijke aanduidingen in C++
Soms moeten we de werking van een functie manipuleren op basis van de behoefte, dat wil zeggen het veranderen van enkele argumenten naar de standaardwaarde enz. Het vooraf definiëren van een functie standaardargumenten beperkt de veelzijdigheid van een functie en dwingt ons om de standaardargumenten te gebruiken en dat ook telkens met vergelijkbare waarden. Vanaf C++11 heeft de introductie van de bind-functie deze taak eenvoudiger gemaakt.
Hoe werkt bind()?
De Bind-functie met behulp van tijdelijke aanduidingen helpt bij het manipuleren van de positie en het aantal waarden dat door de functie moet worden gebruikt en past de functie aan op basis van de gewenste uitvoer.
Wat zijn tijdelijke aanduidingen?
Tijdelijke aanduidingen zijn naamruimten die de positie van een waarde in een functie bepalen. Zij worden vertegenwoordigd door _1 _2 _3 ...
Voorbeeld:
CPP // C++ code to demonstrate bind() and // placeholders #include #include // 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 ; }
Uitgang:
5 -11
In de bovenstaande code wijzigde bind() de aanroep van een functie om 1 argument aan te nemen en de gewenste uitvoer terug te geven.
Eigenschappen van tijdelijke aanduidingen
1. De positie van de tijdelijke aanduiding bepaalt de waardepositie in de functieaanroepinstructie
CPP // C++ code to demonstrate placeholder // property 1 #include #include // 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 ; }
Uitgang:
The value of function is : 10 The value of function after changing placeholder position is : -14
Hoewel in de bovenstaande code de posities van 1 en 13 hetzelfde waren in een functieaanroep, veranderde de verandering in de positie van tijdelijke aanduidingen de manier waarop de functie werd aangeroepen.
2. Het aantal tijdelijke aanduidingen bepaalt het aantal argumenten dat moet worden doorgegeven in de functie.
We kunnen elk nr. van tijdelijke aanduidingen in de functieaanroepinstructie (uiteraard minder dan het maximale aantal argumenten). De rustwaarden worden vervangen door de door de gebruiker gedefinieerde standaardwaarden.
CPP // C++ code to demonstrate placeholder // property 2 #include // for bind() #include 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 ; }
Uitgang:
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 de bovenstaande code is duidelijk het nee. van tijdelijke aanduidingen gelijk aan het aantal argumenten dat nodig is om de functie aan te roepen. De binding van de functie wordt bepaald door het aantal en de positie van tijdelijke aanduidingen.
