Legați funcția și locașii în C ++

Uneori trebuie să manipulăm funcționarea unei funcții în funcție de necesitate, adică schimbarea unor argumente la implicit etc. argumente implicite restricționează versatilitatea unei funcții și ne obligă să folosim argumentele implicite și asta cu valori similare de fiecare dată. De la C ++ 11 înainte, introducerea funcției de legare a făcut această sarcină mai ușoară. 

Cum funcționează Bind ()?  

Funcția de legare cu ajutorul deținătorilor de locații ajută la manipularea poziției și a numărului de valori care trebuie utilizate de funcție și modifică funcția în funcție de ieșirea dorită. 

Ce sunt localitarii?  

Locatorii sunt spații de nume care direcționează poziția unei valori într -o funcție. Sunt reprezentate de _1 _2 _3 ... 

Exemplu:

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  ;   }   

Ieșire:

5 -11 

În codul de mai sus Bind () a modificat apelul unei funcții pentru a lua 1 argument și a returnat ieșirea dorită. 

Proprietățile deținătorilor

1. Poziția Placeholder determină poziția valorii în declarația de apel funcțională 

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  ;   }   

Ieșire:

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

În codul de mai sus, chiar dacă poziția de 1 și 13 a fost aceeași într -o funcție numită schimbarea în poziția deținătorilor de locații a schimbat modul în care a fost numită funcția.   

2. Numărul de proprietari determină numărul de argumente necesare pentru a trece în funcție.

Putem folosi orice nr. a locatarilor din declarația de apel funcțional (evident mai puțin decât numărul maxim de argumente). Valorile REST sunt înlocuite cu valorile implicite definite de utilizator. 

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  ;   }   

Ieșire:

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 

În codul de mai sus, în mod clar, nr. de deținători de localități echivalate cu numărul de argumente necesare pentru a apela funcția. Legarea funcției este direcționată de numărul și poziția deținătorilor.