Comment utiliser bind1st et bind2nd?

Je voudrais savoir comment utiliser les fonctions de liaison.
Voici l'idée:
J'ai cette fonction qui prend en paramètres:

void print_i(int t, std::string separator)
{
        std::cout << t << separator;
}

Et je voudrais faire:

std::vector<int> elements;
//...
for_each(elements.begin(), elements.end(), std::bind2nd(print_i, '\n'));

Mais il ne fonctionne pas !

Voici ce que j'obtiens:

/usr/include/c++/4.3/backward/binders.h: In instantiation of ‘std::binder2nd<void ()(int, std::string)>’:
main.cpp:72:   instantiated from here
/usr/include/c++/4.3/backward/binders.h:138: error: ‘void ()(int, std::string)’ is not a class, struct, or union type
/usr/include/c++/4.3/backward/binders.h:141: error: ‘void ()(int, std::string)’ is not a class, struct, or union type
/usr/include/c++/4.3/backward/binders.h:145: error: ‘void ()(int, std::string)’ is not a class, struct, or union type
/usr/include/c++/4.3/backward/binders.h:149: error: ‘void ()(int, std::string)’ is not a class, struct, or union type
/usr/include/c++/4.3/backward/binders.h:155: error: ‘void ()(int, std::string)’ is not a class, struct, or union type
/usr/include/c++/4.3/backward/binders.h:140: error: field ‘std::binder2nd<void ()(int, std::string)>::op’ invalidly declared function type
/usr/include/c++/4.3/backward/binders.h: In function ‘std::binder2nd<_Operation> std::bind2nd(const _Operation&, const _Tp&) [with _Operation = void ()(int, std::string), _Tp = char]’:
main.cpp:72:   instantiated from here
/usr/include/c++/4.3/backward/binders.h:164: error: ‘void ()(int, std::string)’ is not a class, struct, or union type
/usr/include/c++/4.3/bits/stl_algo.h: In function ‘_Funct std::for_each(_IIter, _IIter, _Funct) [with _IIter = __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, _Funct = std::binder2nd<void ()(int, std::string)>]’:
main.cpp:72:   instantiated from here
/usr/include/c++/4.3/bits/stl_algo.h:3791: error: no match for call to ‘(std::binder2nd<void ()(int, std::string)>) (int&)’
make: *** [all] Error 1

Je pourrais utiliser foncteur, mais il est plus rapide d'utiliser la liaison.

Merci!

Il n'est pas lié à la question, donc un petit commentaire à la place. La plus courte de code à la sortie d'une gamme est probablement le copiant dans ostream_iterator, par exemple std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, "\n"));.

OriginalL'auteur Arthur | 2009-09-13

  1. 11

    L'argument de bind2nd doit être un AdaptableBinaryFunction. Une simple fonction binaire ne remplit pas cette condition (adaptable en fonction typedefs pour son retour et les types d'argument, un simple type de fonction ne fournit pas toutes les typedefs). Vous pouvez utiliser std::bind qui est probablement le meilleur choix de toute façon.

    Pourriez-vous me donner un exemple d'une AdaptableBinaryFunction ?<br>Merci
    std::ptr_fun pouvez convertir fonction binaire en AdaptableBinaryFunction: sgi.com/tech/stl/ptr_fun.html

    OriginalL'auteur Rüdiger Hanke

  2. 26

    Vous devez utiliser un Copiable/Refrencable objet, les ouvrages suivants:

    #include <iostream> 
#include <string> 
#include <vector> 
#include <algorithm> 
#include <fonctionnel> 
void print_i(int t, std::string separator) 
{ 
std::cout << t << séparateur; 
} 
int main() 
{ 
std::vector<int> éléments; 
std::string delim = "\n"; 
for_each(éléments.begin(), 
éléments.end(), 
std::bind2nd(std::ptr_fun(&print_i),delim)); 
return 0; 
}

    Normalement, vous pouvez obtenir le même effet, simplement en procédant de la manière suivante:

    #include <iostream> 
#include <vector> 
#include <algorithm> 
#include <iterator> 
int main() 
{ 
std::vector<int> éléments; 
std::copy(éléments.begin(), 
éléments.end(), 
std::ostream_iterator<int>(std::cout,"\n")); 
return 0; 
}

    Aussi en supposant que vous avez accès à TR1 dans la STL que vous utilisez, il est toujours mieux de réviser et remplacer les utilisations de bind1st et bind2nd avec std::bind

    OriginalL'auteur

  3. 3

    Vous devez faire les étapes suivantes:

    1. créer une structure (ou de classe) qui hérite de std::binary_function

    2. définir votre fonction de prédicat dans l'opérateur() la fonction de membre de la structure créée à l'étape 1

    3. utilisation bind2nd pour lier une valeur appropriée de la structure créée à l'étape 1

    J'ai fait tout cela dans un exemple. Vous pouvez lire l'article et télécharger le code complet sur le lien suivant: lier et de trouver

    Bienvenue DONC ! n'hésitez pas à inclure le code, il y a une option dans le mode d'édition sur le bouton ressemble à ça:{}, et avoir un bref explicatif exemple de code est toujours bon, comme class A{public: bool operator()(const B& b){ doSomething(); return true;}... juste un exemple 🙂

    OriginalL'auteur Waqqas Farooq

  4. 1

    Ces fonctions sont obsolètes depuis C++11, et retiré en C++17. Comme mentionné dans un commentaire ci-dessus, la meilleure solution maintenant est d'utiliser std::bind et les espaces réservés:

    void callable(int a, int b);
auto f = std::bind1st(&callable, 42); //returns a 1-arg function

    devient:

    //returns a 1-arg function
auto f = std::bind(&callable, 42, std::placeholders::_1);
    Bien que vous êtes techniquement, on devrait utiliser des lambdas au lieu de std::bind variantes de toute façon, c'est une baisse-dans le remplacement.
    Personnellement, je trouve parfois std::bind plus lisible que les lambdas, selon le code environnant. Ce n'est qu'une préférence cependant, je suis d'accord à la fois, beau travail.

    OriginalL'auteur James Turner