logo

TechCodeview

Fonction de liaison et espaces réservés en C++

Parfois, nous devons manipuler le fonctionnement d'une fonction en fonction des besoins, c'est-à-dire changer certains arguments par défaut, etc. Prédéfinir une fonction pour qu'elle ait arguments par défaut restreint la polyvalence d'une fonction et nous oblige à utiliser les arguments par défaut et cela aussi avec des valeurs similaires à chaque fois. Depuis C++11, l’introduction de la fonction bind a rendu cette tâche plus facile. 

Comment fonctionne bind() ?  



La fonction de liaison à l'aide d'espaces réservés permet de manipuler la position et le nombre de valeurs à utiliser par la fonction et modifie la fonction en fonction du résultat souhaité. 

tuple python trié

Que sont les espaces réservés ?  

Les espaces réservés sont des espaces de noms qui dirigent la position d'une valeur dans une fonction. Ils sont représentés par _1 _2 _3 ... 



Exemple:

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

Sortir: 

5 -11

Dans le code ci-dessus, bind() a modifié l'appel d'une fonction pour prendre 1 argument et a renvoyé la sortie souhaitée. 



Propriétés des espaces réservés

1. La position de l'espace réservé détermine la position de la valeur dans l'instruction d'appel de fonction 

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

Sortir: 

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

Dans le code ci-dessus, même si les positions de 1 et 13 étaient les mêmes dans un appel de fonction, le changement de position des espaces réservés a modifié la façon dont la fonction était appelée.   

2. Le nombre d'espaces réservés détermine le nombre d'arguments requis à transmettre dans la fonction.

qu'est-ce que l'objet Java

Nous pouvons utiliser n’importe quel numéro. d'espaces réservés dans l'instruction d'appel de fonction (évidemment inférieur au nombre maximum d'arguments). Les valeurs restantes sont remplacées par les valeurs par défaut définies par l'utilisateur. 

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

Sortir: 

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

Dans le code ci-dessus, le numéro est clairement indiqué. d'espaces réservés équivalant au nombre d'arguments requis pour appeler la fonction. La liaison de la fonction est dirigée par le nombre et la position des espaces réservés.