Namespaces
Variants

std:: binary_function

From cppreference.net
C++
Utilities library
Function objects
Function invocation
(C++17) (C++23)
Identity function object
(C++20)
Old binders and adaptors
( until C++17* )
binary_function
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* ) ( until C++17* ) ( until C++17* ) ( until C++17* )
( until C++20* )
( until C++20* )
( until C++17* ) ( until C++17* )
( until C++17* ) ( until C++17* )

( until C++17* )
( until C++17* ) ( until C++17* ) ( until C++17* ) ( until C++17* )
( until C++20* )
( until C++20* )
Défini dans l'en-tête <functional>
template <

class Arg1,
class Arg2,
class Result

> struct binary_function ;
(obsolète en C++11)
(supprimé en C++17)

std::binary_function est une classe de base pour créer des objets fonction avec deux arguments.

std::binary_function ne définit pas operator ( ) ; il est attendu que les classes dérivées définissent celui-ci. std::binary_function fournit seulement trois types - first_argument_type , second_argument_type et result_type - définis par les paramètres du template.

Certains adaptateurs de fonctions objets de la bibliothèque standard, tels que std::not2 , exigent que les fonctions objets qu'ils adaptent possèdent certains types définis ; std::not2 requiert que la fonction objet adaptée ait deux types nommés first_argument_type et second_argument_type . Dériver les fonctions objets qui prennent deux arguments de std::binary_function est un moyen simple de les rendre compatibles avec ces adaptateurs.

std::binary_function est déprécié en C++11 et supprimé en C++17.

Types membres

Type Définition
first_argument_type Arg1
second_argument_type Arg2
result_type Result

Exemple

Exécuter ce code 
#include <algorithm>
#include <functional>
#include <iostream>
#include <vector>
struct same : std::binary_function<int, int, bool>
{
    bool operator()(int a, int b) const { return a == b; }
};
int main()
{
    std::vector<char> v1{'A', 'B', 'C', 'D', 'E'};
    std::vector<char> v2{'E', 'D', 'C', 'B', 'A'};
    std::vector<bool> v3(v1.size());
    std::transform(v1.begin(), v1.end(), v2.begin(), v3.begin(), std::not2(same()));
    std::cout << std::boolalpha;
    for (std::size_t i = 0; i < v1.size(); ++i)
        std::cout << v1[i] << " != " << v2[i] << " : " << v3[i] << '\n';
}

Sortie : 

A != E : true
B != D : true
C != C : false
D != B : true
E != A : true

Voir aussi

(C++11)
enveloppe copiable de tout objet appelable copiable
(modèle de classe)
(C++23)
enveloppe non copiable de tout objet appelable prenant en charge les qualificateurs dans une signature d'appel donnée
(modèle de classe)
(obsolète en C++11) (supprimé en C++17)
crée un wrapper d'objet fonction compatible avec les adaptateurs à partir d'un pointeur de fonction
(modèle de fonction)
(obsolète en C++11) (supprimé en C++17)
wrapper compatible avec les adaptateurs pour un pointeur vers une fonction binaire
(modèle de classe)
(obsolète en C++11) (supprimé en C++17)
classe de base de fonction unaire compatible avec les adaptateurs
(modèle de classe)