functional (STL/CLR)

Incluez l’en-tête <cliext/functional> STL/CLR pour définir des modèles de classe fonctionnelle et des délégués et fonctions de modèle associés.

Syntaxe

#include <functional>

Spécifications

Header :<cliext/fonctionnel>

Espace de noms :cliext

Déclarations

Délégué(e)	Description
binary_delegate (STL/CLR)	Délégué à deux arguments.
binary_delegate_noreturn (STL/CLR)	Délégué à deux arguments retournant void.
unary_delegate (STL/CLR)	Délégué à un argument.
unary_delegate_noreturn (STL/CLR)	Délégué à un argument retournant void.

Classe	Description
binary_negate (STL/CLR)	Fonctor pour négation d’un fonctor à deux arguments.
binder1st (STL/CLR)	Fonctor pour lier le premier argument à un fonctor à deux arguments.
binder2nd (STL/CLR)	Fonctor pour lier le deuxième argument à un fonctor à deux arguments.
divides (STL/CLR)	Divisez le functor.
equal_to (STL/CLR)	Fonctor de comparaison égal.
greater (STL/CLR)	Plus grand fonctor de comparaison.
greater_equal (STL/CLR)	Fonctor de comparaison supérieur ou égal.
less (STL/CLR)	Moins de fonctor de comparaison.
less_equal (STL/CLR)	Fonctor de comparaison inférieur ou égal.
logical_and (STL/CLR)	Fonctor logique ET.
logical_not (STL/CLR)	Fonctor logique NOT.
logical_or (STL/CLR)	Fonctor or logique.
minus (STL/CLR)	Soustraire le fonctor.
modulus (STL/CLR)	Fonctor modulus.
multiplies (STL/CLR)	Multipliez le fonctor.
negate (STL/CLR)	Fonctor pour renvoyer son argument n’a pas été supprimé.
not_equal_to (STL/CLR)	Le fonctor de comparaison n’est pas égal.
plus (STL/CLR)	Ajouter un fonctor.
unary_negate (STL/CLR)	Fonctor pour négation d’un fonctor à argument unique.

Fonction	Description
bind1st (STL/CLR)	Génère un binder1st pour un argument et un fonctor.
bind2nd (STL/CLR)	Génère un binder2nd pour un argument et un fonctor.
not1 (STL/CLR)	Génère une unary_negate pour un fonctor.
not2 (STL/CLR)	Génère une binary_negate pour un fonctor.

Membres

binary_delegate (STL/CLR)

La classe générique décrit un délégué à deux arguments. Vous l’utilisez pour spécifier un délégué en termes d’argument et de types de retour.

Syntaxe

generic<typename Arg1,
    typename Arg2,
    typename Result>
    delegate Result binary_delegate(Arg1, Arg2);

Paramètres

Arg1
Type du premier argument.

Arg2
Type du deuxième argument.

Result
Type de retour.

Notes

Le délégué générique décrit une fonction à deux arguments.

Dans ces modèles de fonction :

binary_delegate<int, int, int> Fun1;

binary_delegate<int, int, int> Fun2;

les types Fun1 et Fun2 sont des synonymes, tandis que pour :

delegate int Fun1(int, int);

delegate int Fun2(int, int);

ils ne sont pas du même type.

Exemple

// cliext_binary_delegate.cpp
// compile with: /clr
#include <cliext/functional>

bool key_compare(wchar_t left, wchar_t right)
    {
    return (left < right);
    }

typedef cliext::binary_delegate<wchar_t, wchar_t, bool> Mydelegate;
int main()
    {
    Mydelegate^ kcomp = gcnew Mydelegate(&key_compare);

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();
    return (0);
    }

compare(L'a', L'a') = False
compare(L'a', L'b') = True
compare(L'b', L'a') = False

binary_delegate_noreturn (STL/CLR)

La classe générique décrit un délégué à deux arguments qui retourne void. Vous l’utilisez pour spécifier un délégué en termes d’argument.

Syntaxe

generic<typename Arg1,
    typename Arg2>
    delegate void binary_delegate(Arg1, Arg2);

Paramètres

Arg1
Type du premier argument.

Arg2
Type du deuxième argument.

Notes

Le délégué générique décrit une fonction à deux arguments qui retourne void.

Dans ces modèles de fonction :

binary_delegate_noreturn<int, int> Fun1;

binary_delegate_noreturn<int, int> Fun2;

les types Fun1 et Fun2 sont des synonymes, tandis que pour :

delegate void Fun1(int, int);

delegate void Fun2(int, int);

ils ne sont pas du même type.

Exemple

// cliext_binary_delegate_noreturn.cpp
// compile with: /clr
#include <cliext/functional>

void key_compare(wchar_t left, wchar_t right)
    {
    System::Console::WriteLine("compare({0}, {1}) = {2}",
        left, right, left < right);
    }

typedef cliext::binary_delegate_noreturn<wchar_t, wchar_t> Mydelegate;
int main()
    {
    Mydelegate^ kcomp = gcnew Mydelegate(&key_compare);

    kcomp(L'a', L'a');
    kcomp(L'a', L'b');
    kcomp(L'b', L'a');
    System::Console::WriteLine();
    return (0);
    }

compare(a, a) = False
compare(a, b) = True
compare(b, a) = False

binary_negate (STL/CLR)

La classe de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne la logique NOT de son fonctor à deux arguments stocké. Vous l’utilisez pour spécifier un objet de fonction en termes de fonctor stocké.

Syntaxe

template<typename Fun>
    ref class binary_negate
    { // wrap operator()
public:
    typedef Fun stored_function_type;
    typedef typename Fun::first_argument_type first_argument_type;
    typedef typename Fun::second_argument_type second_argument_type;
    typedef bool result_type;
    typedef Microsoft::VisualC::StlClr::BinaryDelegate<
        first_argument_type, second_argument_type, result_type>
        delegate_type;

    explicit binary_negate(Fun% functor);
    binary_negate(binary_negate<Arg>% right);

    result_type operator()(first_argument_type left,
        second_argument_type right);
    operator delegate_type^();
    };

Paramètres

Fun
Type du fonctor stocké.

Fonctions de membre

Définition de type	Description
delegate_type	Type du délégué générique.
first_argument_type	Type du premier argument du fonctor.
result_type	Type du résultat du fonctor.
second_argument_type	Type du deuxième argument du fonctor.
stored_function_type	Type du functor.

Membre	Description
binary_negate	Construit le functor.

Opérateur	Description
operator()	Calcule la fonction souhaitée.
operator delegate_type^()	Convertit le fonctor en délégué.

Notes

La classe de modèle décrit un fonctor à deux arguments qui stocke un autre fonctor à deux arguments. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne la logique NOT du fonctor stocké appelé avec les deux arguments.

Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.

Exemple

// cliext_binary_negate.cpp
// compile with: /clr
#include <cliext/algorithm>
#include <cliext/functional>
#include <cliext/vector>

typedef cliext::vector<int> Myvector;
int main()
    {
    Myvector c1;
    c1.push_back(4);
    c1.push_back(3);
    Myvector c2;
    c2.push_back(4);
    c2.push_back(4);
    Myvector c3(2, 0);

// display initial contents " 4 3" and " 4 4"
    for each (int elem in c1)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

    for each (int elem in c2)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display
    cliext::less<int> less_op;

    cliext::transform(c1.begin(), c1.begin() + 2,
        c2.begin(), c3.begin(),
        cliext::binary_negate<cliext::less<int> >(less_op));
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display with function
    cliext::transform(c1.begin(), c1.begin() + 2,
        c2.begin(), c3.begin(), cliext::not2(less_op));
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();
    return (0);
    }

4 3
4 4
1 0
1 0

bind1st (STL/CLR)

Génère un argument et un binder1st fonctor.

Syntaxe

template<typename Fun,
    typename Arg>
    binder1st<Fun> bind1st(Fun% functor,
        Arg left);

Paramètres du modèle

Arg
Type de l’argument.

Fun
Type du functor.

Paramètres de fonction

functor
Le functor à envelopper.

left
Premier argument à encapsuler.

Notes

Le modèle de fonction retourne binder1st<Fun>(functor, left). Vous l’utilisez comme moyen pratique d’encapsuler un fonctor à deux arguments et son premier argument dans un fonctor à un argument qui l’appelle avec un deuxième argument.

Exemple

// cliext_bind1st.cpp
// compile with: /clr
#include <cliext/algorithm>
#include <cliext/functional>
#include <cliext/vector>

typedef cliext::vector<int> Myvector;
int main()
    {
    Myvector c1;
    c1.push_back(4);
    c1.push_back(3);
    Myvector c3(2, 0);

// display initial contents " 4 3"
    for each (int elem in c1)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display
    cliext::minus<int> sub_op;
    cliext::binder1st<cliext::minus<int> > subfrom3(sub_op, 3);

    cliext::transform(c1.begin(), c1.begin() + 2, c3.begin(),
        subfrom3);
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display with function
    cliext::transform(c1.begin(), c1.begin() + 2, c3.begin(),
        bind1st(sub_op, 3));
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();
    return (0);
    }

4 3
-1 0
-1 0

bind2nd (STL/CLR)

Génère un argument et un binder2nd fonctor.

Syntaxe

template<typename Fun,
    typename Arg>
    binder2nd<Fun> bind2nd(Fun% functor,
        Arg right);

Paramètres du modèle

Arg
Type de l’argument.

Fun
Type du functor.

Paramètres de fonction

functor
Le functor à envelopper.

right
Deuxième argument à encapsuler.

Notes

Le modèle de fonction retourne binder2nd<Fun>(functor, right). Vous l’utilisez comme moyen pratique d’encapsuler un fonctor à deux arguments et son deuxième argument dans un fonctor à un argument qui l’appelle avec un premier argument.

Exemple

// cliext_bind2nd.cpp
// compile with: /clr
#include <cliext/algorithm>
#include <cliext/functional>
#include <cliext/vector>

typedef cliext::vector<int> Myvector;
int main()
    {
    Myvector c1;
    c1.push_back(4);
    c1.push_back(3);
    Myvector c3(2, 0);

// display initial contents " 4 3"
    for each (int elem in c1)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display
    cliext::minus<int> sub_op;
    cliext::binder2nd<cliext::minus<int> > sub4(sub_op, 4);

    cliext::transform(c1.begin(), c1.begin() + 2, c3.begin(),
        sub4);
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display with function
    cliext::transform(c1.begin(), c1.begin() + 2, c3.begin(),
        bind2nd(sub_op, 4));
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();
    return (0);
    }

4 3
0 -1
0 -1

binder1st (STL/CLR)

La classe de modèle décrit un fonctor à argument unique qui, lorsqu’elle est appelée, retourne son fonctor à deux arguments stocké appelé avec son premier argument stocké et le deuxième argument fourni. Vous l’utilisez pour spécifier un objet de fonction en termes de fonctor stocké.

Syntaxe

template<typename Fun>
    ref class binder1st
    { // wrap operator()
public:
    typedef Fun stored_function_type;
    typedef typename Fun::first_argument_type first_argument_type;
    typedef typename Fun::second_argument_type second_argument_type;
    typedef typename Fun:result_type result_type;
    typedef Microsoft::VisualC::StlClr::UnaryDelegate<
        second_argument_type, result_type>
        delegate_type;

    binder1st(Fun% functor, first_argument_type left);
    binder1st(binder1st<Arg>% right);

    result_type operator()(second_argument_type right);
    operator delegate_type^();
    };

Paramètres

Fun
Type du fonctor stocké.

Fonctions de membre

Définition de type	Description
delegate_type	Type du délégué générique.
first_argument_type	Type du premier argument du fonctor.
result_type	Type du résultat du fonctor.
second_argument_type	Type du deuxième argument du fonctor.
stored_function_type	Type du functor.

Membre	Description
binder1st	Construit le functor.

Opérateur	Description
operator()	Calcule la fonction souhaitée.
operator delegate_type^()	Convertit le fonctor en délégué.

Notes

La classe de modèle décrit un fonctor à argument unique qui stocke un fonctor à deux arguments et un premier argument. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne le résultat de l’appel du fonctor stocké avec le premier argument stocké et le deuxième argument fourni.

Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.

Exemple

// cliext_binder1st.cpp
// compile with: /clr
#include <cliext/algorithm>
#include <cliext/functional>
#include <cliext/vector>

typedef cliext::vector<int> Myvector;
int main()
    {
    Myvector c1;
    c1.push_back(4);
    c1.push_back(3);
    Myvector c3(2, 0);

// display initial contents " 4 3"
    for each (int elem in c1)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display
    cliext::minus<int> sub_op;
    cliext::binder1st<cliext::minus<int> > subfrom3(sub_op, 3);

    cliext::transform(c1.begin(), c1.begin() + 2, c3.begin(),
        subfrom3);
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display with function
    cliext::transform(c1.begin(), c1.begin() + 2, c3.begin(),
        bind1st(sub_op, 3));
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();
    return (0);
    }

4 3
-1 0
-1 0

binder2nd (STL/CLR)

La classe de modèle décrit un fonctor à argument unique qui, lorsqu’elle est appelée, retourne son fonctor à deux arguments stocké appelé avec le premier argument fourni et son deuxième argument stocké. Vous l’utilisez pour spécifier un objet de fonction en termes de fonctor stocké.

Syntaxe

template<typename Fun>
    ref class binder2nd
    { // wrap operator()
public:
    typedef Fun stored_function_type;
    typedef typename Fun::first_argument_type first_argument_type;
    typedef typename Fun::second_argument_type second_argument_type;
    typedef typename Fun:result_type result_type;
    typedef Microsoft::VisualC::StlClr::UnaryDelegate<
        first_argument_type, result_type>
        delegate_type;

    binder2nd(Fun% functor, second_argument_type left);
    binder2nd(binder2nd<Arg>% right);

    result_type operator()(first_argument_type right);
    operator delegate_type^();
    };

Paramètres

Fun
Type du fonctor stocké.

Fonctions de membre

Définition de type	Description
delegate_type	Type du délégué générique.
first_argument_type	Type du premier argument du fonctor.
result_type	Type du résultat du fonctor.
second_argument_type	Type du deuxième argument du fonctor.
stored_function_type	Type du functor.

Membre	Description
binder2nd	Construit le functor.

Opérateur	Description
operator()	Calcule la fonction souhaitée.
operator delegate_type^()	Convertit le fonctor en délégué.

Notes

La classe de modèle décrit un fonctor à argument unique qui stocke un fonctor à deux arguments et un deuxième argument. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne le résultat de l’appel du fonctor stocké avec le premier argument fourni et le deuxième argument stocké.

Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.

Exemple

// cliext_binder2nd.cpp
// compile with: /clr
#include <cliext/algorithm>
#include <cliext/functional>
#include <cliext/vector>

typedef cliext::vector<int> Myvector;
int main()
    {
    Myvector c1;
    c1.push_back(4);
    c1.push_back(3);
    Myvector c3(2, 0);

// display initial contents " 4 3"
    for each (int elem in c1)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display
    cliext::minus<int> sub_op;
    cliext::binder2nd<cliext::minus<int> > sub4(sub_op, 4);

    cliext::transform(c1.begin(), c1.begin() + 2, c3.begin(),
        sub4);
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display with function
    cliext::transform(c1.begin(), c1.begin() + 2, c3.begin(),
        bind2nd(sub_op, 4));
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();
    return (0);
    }

4 3
0 -1
0 -1

divides (STL/CLR)

La classe de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne le premier argument divisé par la seconde. Vous l’utilisez pour spécifier un objet de fonction en termes de son type d’argument.

Syntaxe

template<typename Arg>
    ref class divides
    { // wrap operator()
public:
    typedef Arg first_argument_type;
    typedef Arg second_argument_type;
    typedef Arg result_type;
    typedef Microsoft::VisualC::StlClr::BinaryDelegate<
        first_argument_type, second_argument_type, result_type>
        delegate_type;

    divides();
    divides(divides<Arg>% right);

    result_type operator()(first_argument_type left,
        second_argument_type right);
    operator delegate_type^();
    };

Paramètres

Arg
Type des arguments et valeur de retour.

Fonctions de membre

Définition de type	Description
delegate_type	Type du délégué générique.
first_argument_type	Type du premier argument du fonctor.
result_type	Type du résultat du fonctor.
second_argument_type	Type du deuxième argument du fonctor.

Membre	Description
divides	Construit le functor.

Opérateur	Description
operator()	Calcule la fonction souhaitée.
operator delegate_type^()	Convertit le fonctor en délégué.

Notes

La classe de modèle décrit un fonctor à deux arguments. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne le premier argument divisé par la seconde.

Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.

Exemple

// cliext_divides.cpp
// compile with: /clr
#include <cliext/algorithm>
#include <cliext/functional>
#include <cliext/vector>

typedef cliext::vector<int> Myvector;
int main()
    {
    Myvector c1;
    c1.push_back(4);
    c1.push_back(3);
    Myvector c2;
    c2.push_back(2);
    c2.push_back(1);
    Myvector c3(2, 0);

// display initial contents " 4 3" and " 2 1"
    for each (int elem in c1)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

    for each (int elem in c2)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display
    cliext::transform(c1.begin(), c1.begin() + 2,
        c2.begin(), c3.begin(), cliext::divides<int>());
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();
    return (0);
    }

4 3
2 1
2 3

equal_to (STL/CLR)

La classe de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne true uniquement si le premier argument est égal à la seconde. Vous l’utilisez pour spécifier un objet de fonction en termes de son type d’argument.

Syntaxe

template<typename Arg>
    ref class equal_to
    { // wrap operator()
public:
    typedef Arg first_argument_type;
    typedef Arg second_argument_type;
    typedef bool result_type;
    typedef Microsoft::VisualC::StlClr::BinaryDelegate<
        first_argument_type, second_argument_type, result_type>
        delegate_type;

    equal_to();
    equal_to(equal_to<Arg>% right);

    result_type operator()(first_argument_type left,
        second_argument_type right);
    operator delegate_type^();
    };

Paramètres

Arg
Type des arguments.

Fonctions de membre

Définition de type	Description
delegate_type	Type du délégué générique.
first_argument_type	Type du premier argument du fonctor.
result_type	Type du résultat du fonctor.
second_argument_type	Type du deuxième argument du fonctor.

Membre	Description
equal_to	Construit le functor.

Opérateur	Description
operator()	Calcule la fonction souhaitée.
operator delegate_type^()	Convertit le fonctor en délégué.

Notes

La classe de modèle décrit un fonctor à deux arguments. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne true uniquement si le premier argument est égal à la seconde.

Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.

Exemple

// cliext_equal_to.cpp
// compile with: /clr
#include <cliext/algorithm>
#include <cliext/functional>
#include <cliext/vector>

typedef cliext::vector<int> Myvector;
int main()
    {
    Myvector c1;
    c1.push_back(4);
    c1.push_back(3);
    Myvector c2;
    c2.push_back(4);
    c2.push_back(4);
    Myvector c3(2, 0);

// display initial contents " 4 3" and " 4 4"
    for each (int elem in c1)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

    for each (int elem in c2)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display
    cliext::transform(c1.begin(), c1.begin() + 2,
        c2.begin(), c3.begin(), cliext::equal_to<int>());
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();
    return (0);
    }

4 3
4 4
1 0

greater (STL/CLR)

La classe de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne true uniquement si le premier argument est supérieur à la seconde. Vous l’utilisez pour spécifier un objet de fonction en termes de son type d’argument.

Syntaxe

template<typename Arg>
    ref class greater
    { // wrap operator()
public:
    typedef Arg first_argument_type;
    typedef Arg second_argument_type;
    typedef bool result_type;
    typedef Microsoft::VisualC::StlClr::BinaryDelegate<
        first_argument_type, second_argument_type, result_type>
        delegate_type;

    greater();
    greater(greater<Arg>% right);

    result_type operator()(first_argument_type left,
        second_argument_type right);
    operator delegate_type^();
    };

Paramètres

Arg
Type des arguments.

Fonctions de membre

Définition de type	Description
delegate_type	Type du délégué générique.
first_argument_type	Type du premier argument du fonctor.
result_type	Type du résultat du fonctor.
second_argument_type	Type du deuxième argument du fonctor.

Membre	Description
greater	Construit le functor.

Opérateur	Description
operator()	Calcule la fonction souhaitée.
operator delegate_type^	Convertit le fonctor en délégué.

Notes

La classe de modèle décrit un fonctor à deux arguments. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne true uniquement si le premier argument est supérieur à la seconde.

Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.

Exemple

// cliext_greater.cpp
// compile with: /clr
#include <cliext/algorithm>
#include <cliext/functional>
#include <cliext/vector>

typedef cliext::vector<int> Myvector;
int main()
    {
    Myvector c1;
    c1.push_back(4);
    c1.push_back(3);
    Myvector c2;
    c2.push_back(3);
    c2.push_back(3);
    Myvector c3(2, 0);

// display initial contents " 4 3" and " 3 3"
    for each (int elem in c1)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

    for each (int elem in c2)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display
    cliext::transform(c1.begin(), c1.begin() + 2,
        c2.begin(), c3.begin(), cliext::greater<int>());
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();
    return (0);
    }

4 3
3 3
1 0

greater_equal (STL/CLR)

La classe de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne true uniquement si le premier argument est supérieur ou égal à la seconde. Vous l’utilisez pour spécifier un objet de fonction en termes de son type d’argument.

Syntaxe

template<typename Arg>
    ref class greater_equal
    { // wrap operator()
public:
    typedef Arg first_argument_type;
    typedef Arg second_argument_type;
    typedef bool result_type;
    typedef Microsoft::VisualC::StlClr::BinaryDelegate<
        first_argument_type, second_argument_type, result_type>
        delegate_type;

    greater_equal();
    greater_equal(greater_equal<Arg>% right);

    result_type operator()(first_argument_type left,
        second_argument_type right);
    operator delegate_type^();
    };

Paramètres

Arg
Type des arguments.

Fonctions de membre

Définition de type	Description
delegate_type	Type du délégué générique.
first_argument_type	Type du premier argument du fonctor.
result_type	Type du résultat du fonctor.
second_argument_type	Type du deuxième argument du fonctor.

Membre	Description
greater_equal	Construit le functor.

Opérateur	Description
operator()	Calcule la fonction souhaitée.
operator delegate_type^	Convertit le fonctor en délégué.

Notes

La classe de modèle décrit un fonctor à deux arguments. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne true uniquement si le premier argument est supérieur ou égal à la seconde.

Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.

Exemple

// cliext_greater_equal.cpp
// compile with: /clr
#include <cliext/algorithm>
#include <cliext/functional>
#include <cliext/vector>

typedef cliext::vector<int> Myvector;
int main()
    {
    Myvector c1;
    c1.push_back(4);
    c1.push_back(3);
    Myvector c2;
    c2.push_back(4);
    c2.push_back(4);
    Myvector c3(2, 0);

// display initial contents " 4 3" and " 4 4"
    for each (int elem in c1)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

    for each (int elem in c2)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display
    cliext::transform(c1.begin(), c1.begin() + 2,
        c2.begin(), c3.begin(), cliext::greater_equal<int>());
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();
    return (0);
    }

4 3
4 4
1 0

less (STL/CLR)

La classe de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne true uniquement si le premier argument est inférieur à la seconde. Vous l’utilisez pour spécifier un objet de fonction en termes de son type d’argument.

Syntaxe

template<typename Arg>
    ref class less
    { // wrap operator()
public:
    typedef Arg first_argument_type;
    typedef Arg second_argument_type;
    typedef bool result_type;
    typedef Microsoft::VisualC::StlClr::BinaryDelegate<
        first_argument_type, second_argument_type, result_type>
        delegate_type;

    less();
    less(less<Arg>% right);

    result_type operator()(first_argument_type left,
        second_argument_type right);
    operator delegate_type^();
    };

Paramètres

Arg
Type des arguments.

Fonctions de membre

Définition de type	Description
delegate_type	Type du délégué générique.
first_argument_type	Type du premier argument du fonctor.
result_type	Type du résultat du fonctor.
second_argument_type	Type du deuxième argument du fonctor.

Membre	Description
less	Construit le functor.

Opérateur	Description
operator()	Calcule la fonction souhaitée.
operator delegate_type^	Convertit le fonctor en délégué.

Notes

La classe de modèle décrit un fonctor à deux arguments. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne true uniquement si le premier argument est inférieur à la seconde.

Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.

Exemple

// cliext_less.cpp
// compile with: /clr
#include <cliext/algorithm>
#include <cliext/functional>
#include <cliext/vector>

typedef cliext::vector<int> Myvector;
int main()
    {
    Myvector c1;
    c1.push_back(4);
    c1.push_back(3);
    Myvector c2;
    c2.push_back(4);
    c2.push_back(4);
    Myvector c3(2, 0);

// display initial contents " 4 3" and " 4 4"
    for each (int elem in c1)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

    for each (int elem in c2)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display
    cliext::transform(c1.begin(), c1.begin() + 2,
        c2.begin(), c3.begin(), cliext::less<int>());
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();
    return (0);
    }

4 3
4 4
0 1

less_equal (STL/CLR)

La classe de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne true uniquement si le premier argument est inférieur ou égal à la seconde. Vous l’utilisez pour spécifier un objet de fonction en termes de son type d’argument.

Syntaxe

template<typename Arg>
    ref class less_equal
    { // wrap operator()
public:
    typedef Arg first_argument_type;
    typedef Arg second_argument_type;
    typedef bool result_type;
    typedef Microsoft::VisualC::StlClr::BinaryDelegate<
        first_argument_type, second_argument_type, result_type>
        delegate_type;

    less_equal();
    less_equal(less_equal<Arg>% right);

    result_type operator()(first_argument_type left,
        second_argument_type right);
    operator delegate_type^();
    };

Paramètres

Arg
Type des arguments.

Fonctions de membre

Définition de type	Description
delegate_type	Type du délégué générique.
first_argument_type	Type du premier argument du fonctor.
result_type	Type du résultat du fonctor.
second_argument_type	Type du deuxième argument du fonctor.

Membre	Description
less_equal	Construit le functor.

Opérateur	Description
operator()	Calcule la fonction souhaitée.
operator delegate_type^	Convertit le fonctor en délégué.

Notes

La classe de modèle décrit un fonctor à deux arguments. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne true uniquement si le premier argument est inférieur ou égal à la seconde.

Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.

Exemple

// cliext_less_equal.cpp
// compile with: /clr
#include <cliext/algorithm>
#include <cliext/functional>
#include <cliext/vector>

typedef cliext::vector<int> Myvector;
int main()
    {
    Myvector c1;
    c1.push_back(4);
    c1.push_back(3);
    Myvector c2;
    c2.push_back(3);
    c2.push_back(3);
    Myvector c3(2, 0);

// display initial contents " 4 3" and " 3 3"
    for each (int elem in c1)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

    for each (int elem in c2)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display
    cliext::transform(c1.begin(), c1.begin() + 2,
        c2.begin(), c3.begin(), cliext::less_equal<int>());
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();
    return (0);
    }

4 3
3 3
0 1

logical_and (STL/CLR)

La classe de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne true uniquement si le premier argument et le deuxième test sont vrais. Vous l’utilisez pour spécifier un objet de fonction en termes de son type d’argument.

Syntaxe

template<typename Arg>
    ref class logical_and
    { // wrap operator()
public:
    typedef Arg first_argument_type;
    typedef Arg second_argument_type;
    typedef bool result_type;
    typedef Microsoft::VisualC::StlClr::BinaryDelegate<
        first_argument_type, second_argument_type, result_type>
        delegate_type;

    logical_and();
    logical_and(logical_and<Arg>% right);

    result_type operator()(first_argument_type left,
        second_argument_type right);
    operator delegate_type^();
    };

Paramètres

Arg
Type des arguments.

Fonctions de membre

Définition de type	Description
delegate_type	Type du délégué générique.
first_argument_type	Type du premier argument du fonctor.
result_type	Type du résultat du fonctor.
second_argument_type	Type du deuxième argument du fonctor.

Membre	Description
logical_and	Construit le functor.

Opérateur	Description
operator()	Calcule la fonction souhaitée.
operator delegate_type^	Convertit le fonctor en délégué.

Notes

La classe de modèle décrit un fonctor à deux arguments. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne true uniquement si le premier argument et le deuxième test sont vrais.

Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.

Exemple

// cliext_logical_and.cpp
// compile with: /clr
#include <cliext/algorithm>
#include <cliext/functional>
#include <cliext/vector>

typedef cliext::vector<int> Myvector;
int main()
    {
    Myvector c1;
    c1.push_back(2);
    c1.push_back(0);
    Myvector c2;
    c2.push_back(3);
    c2.push_back(0);
    Myvector c3(2, 0);

// display initial contents " 1 0" and " 1 0"
    for each (int elem in c1)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

    for each (int elem in c2)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display
    cliext::transform(c1.begin(), c1.begin() + 2,
        c2.begin(), c3.begin(), cliext::logical_and<int>());
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();
    return (0);
    }

2 0
3 0
1 0

logical_not (STL/CLR)

La classe de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne true uniquement si son argument teste la valeur false. Vous l’utilisez pour spécifier un objet de fonction en termes de son type d’argument.

Syntaxe

template<typename Arg>
    ref class logical_not
    { // wrap operator()
public:
    typedef Arg argument_type;
    typedef bool result_type;
    typedef Microsoft::VisualC::StlClr::UnaryDelegate<
        argument_type, result_type>
        delegate_type;

    logical_not();
    logical_not(logical_not<Arg> %right);

    result_type operator()(argument_type left);
    operator delegate_type^();
    };

Paramètres

Arg
Type des arguments.

Fonctions de membre

Définition de type	Description
argument_type	Type de l’argument fonctor.
delegate_type	Type du délégué générique.
result_type	Type du résultat du fonctor.

Membre	Description
logical_not	Construit le functor.

Opérateur	Description
operator()	Calcule la fonction souhaitée.
operator delegate_type^	Convertit le fonctor en délégué.

Notes

La classe de modèle décrit un fonctor à argument unique. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne true uniquement si son argument teste comme false.

Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.

Exemple

// cliext_logical_not.cpp
// compile with: /clr
#include <cliext/algorithm>
#include <cliext/functional>
#include <cliext/vector>

typedef cliext::vector<int> Myvector;
int main()
    {
    Myvector c1;
    c1.push_back(4);
    c1.push_back(0);
    Myvector c3(2, 0);

// display initial contents " 4 0"
    for each (int elem in c1)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display
    cliext::transform(c1.begin(), c1.begin() + 2,
        c3.begin(), cliext::logical_not<int>());
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();
    return (0);
    }

4 0
0 1

logical_or (STL/CLR)

La classe de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne true uniquement si le premier argument ou le deuxième test est vrai. Vous l’utilisez pour spécifier un objet de fonction en termes de son type d’argument.

Syntaxe

template<typename Arg>
    ref class logical_or
    { // wrap operator()
public:
    typedef Arg first_argument_type;
    typedef Arg second_argument_type;
    typedef bool result_type;
    typedef Microsoft::VisualC::StlClr::BinaryDelegate<
        first_argument_type, second_argument_type, result_type>
        delegate_type;

    logical_or();
    logical_or(logical_or<Arg>% right);

    result_type operator()(first_argument_type left,
        second_argument_type right);
    operator delegate_type^();
    };

Paramètres

Arg
Type des arguments.

Fonctions de membre

Définition de type	Description
delegate_type	Type du délégué générique.
first_argument_type	Type du premier argument du fonctor.
result_type	Type du résultat du fonctor.
second_argument_type	Type du deuxième argument du fonctor.

Membre	Description
logical_or	Construit le functor.

Opérateur	Description
operator()	Calcule la fonction souhaitée.
operator delegate_type^	Convertit le fonctor en délégué.

Notes

La classe de modèle décrit un fonctor à deux arguments. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne true uniquement si le premier argument ou le second teste la valeur true.

Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.

Exemple

// cliext_logical_or.cpp
// compile with: /clr
#include <cliext/algorithm>
#include <cliext/functional>
#include <cliext/vector>

typedef cliext::vector<int> Myvector;
int main()
    {
    Myvector c1;
    c1.push_back(2);
    c1.push_back(0);
    Myvector c2;
    c2.push_back(0);
    c2.push_back(0);
    Myvector c3(2, 0);

// display initial contents " 2 0" and " 0 0"
    for each (int elem in c1)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

    for each (int elem in c2)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display
    cliext::transform(c1.begin(), c1.begin() + 2,
        c2.begin(), c3.begin(), cliext::logical_or<int>());
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();
    return (0);
    }

2 0
0 0
1 0

minus (STL/CLR)

La classe de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne le premier argument moins le deuxième. Vous l’utilisez pour spécifier un objet de fonction en termes de son type d’argument.

Syntaxe

template<typename Arg>
    ref class minus
    { // wrap operator()
public:
    typedef Arg first_argument_type;
    typedef Arg second_argument_type;
    typedef Arg result_type;
    typedef Microsoft::VisualC::StlClr::BinaryDelegate<
        first_argument_type, second_argument_type, result_type>
        delegate_type;

    minus();
    minus(minus<Arg>% right);

    result_type operator()(first_argument_type left,
        second_argument_type right);
    operator delegate_type^();
    };

Paramètres

Arg
Type des arguments et valeur de retour.

Fonctions de membre

Définition de type	Description
delegate_type	Type du délégué générique.
first_argument_type	Type du premier argument du fonctor.
result_type	Type du résultat du fonctor.
second_argument_type	Type du deuxième argument du fonctor.

Membre	Description
minus	Construit le functor.

Opérateur	Description
operator()	Calcule la fonction souhaitée.
operator delegate_type^	Convertit le fonctor en délégué.

Notes

La classe de modèle décrit un fonctor à deux arguments. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne le premier argument moins le deuxième.

Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.

Exemple

// cliext_minus.cpp
// compile with: /clr
#include <cliext/algorithm>
#include <cliext/functional>
#include <cliext/vector>

typedef cliext::vector<int> Myvector;
int main()
    {
    Myvector c1;
    c1.push_back(4);
    c1.push_back(3);
    Myvector c2;
    c2.push_back(2);
    c2.push_back(1);
    Myvector c3(2, 0);

// display initial contents " 4 3" and " 2 1"
    for each (int elem in c1)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

    for each (int elem in c2)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display
    cliext::transform(c1.begin(), c1.begin() + 2,
        c2.begin(), c3.begin(), cliext::minus<int>());
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();
    return (0);
    }

4 3
2 1
2 2

modulus (STL/CLR)

La classe de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne le premier argument modulo le deuxième. Vous l’utilisez pour spécifier un objet de fonction en termes de son type d’argument.

Syntaxe

template<typename Arg>
    ref class modulus
    { // wrap operator()
public:
    typedef Arg first_argument_type;
    typedef Arg second_argument_type;
    typedef Arg result_type;
    typedef Microsoft::VisualC::StlClr::BinaryDelegate<
        first_argument_type, second_argument_type, result_type>
        delegate_type;

    modulus();
    modulus(modulus<Arg>% right);

    result_type operator()(first_argument_type left,
        second_argument_type right);
    operator delegate_type^();
    };

Paramètres

Arg
Type des arguments et valeur de retour.

Fonctions de membre

Définition de type	Description
delegate_type	Type du délégué générique.
first_argument_type	Type du premier argument du fonctor.
result_type	Type du résultat du fonctor.
second_argument_type	Type du deuxième argument du fonctor.

Membre	Description
modulus	Construit le functor.

Opérateur	Description
operator()	Calcule la fonction souhaitée.
operator delegate_type^	Convertit le fonctor en délégué.

Notes

La classe de modèle décrit un fonctor à deux arguments. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne le premier argument modulo le second.

Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.

Exemple

// cliext_modulus.cpp
// compile with: /clr
#include <cliext/algorithm>
#include <cliext/functional>
#include <cliext/vector>

typedef cliext::vector<int> Myvector;
int main()
    {
    Myvector c1;
    c1.push_back(4);
    c1.push_back(2);
    Myvector c2;
    c2.push_back(3);
    c2.push_back(1);
    Myvector c3(2, 0);

// display initial contents " 4 2" and " 3 1"
    for each (int elem in c1)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

    for each (int elem in c2)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display
    cliext::transform(c1.begin(), c1.begin() + 2,
        c2.begin(), c3.begin(), cliext::modulus<int>());
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();
    return (0);
    }

4 2
3 1
1 0

multiplies (STL/CLR)

La classe de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne le premier argument fois la seconde. Vous l’utilisez pour spécifier un objet de fonction en termes de son type d’argument.

Syntaxe

template<typename Arg>
    ref class multiplies
    { // wrap operator()
public:
    typedef Arg first_argument_type;
    typedef Arg second_argument_type;
    typedef Arg result_type;
    typedef Microsoft::VisualC::StlClr::BinaryDelegate<
        first_argument_type, second_argument_type, result_type>
        delegate_type;

    multiplies();
    multiplies(multiplies<Arg>% right);

    result_type operator()(first_argument_type left,
        second_argument_type right);
    operator delegate_type^();
    };

Paramètres

Arg
Type des arguments et valeur de retour.

Fonctions de membre

Définition de type	Description
delegate_type	Type du délégué générique.
first_argument_type	Type du premier argument du fonctor.
result_type	Type du résultat du fonctor.
second_argument_type	Type du deuxième argument du fonctor.

Membre	Description
multiplies	Construit le functor.

Opérateur	Description
operator()	Calcule la fonction souhaitée.
operator delegate_type^	Convertit le fonctor en délégué.

Notes

La classe de modèle décrit un fonctor à deux arguments. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne le premier argument fois la seconde.

Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.

Exemple

// cliext_multiplies.cpp
// compile with: /clr
#include <cliext/algorithm>
#include <cliext/functional>
#include <cliext/vector>

typedef cliext::vector<int> Myvector;
int main()
    {
    Myvector c1;
    c1.push_back(4);
    c1.push_back(3);
    Myvector c2;
    c2.push_back(2);
    c2.push_back(1);
    Myvector c3(2, 0);

// display initial contents " 4 3" and " 2 1"
    for each (int elem in c1)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

    for each (int elem in c2)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display
    cliext::transform(c1.begin(), c1.begin() + 2,
        c2.begin(), c3.begin(), cliext::multiplies<int>());
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();
    return (0);
    }

4 3
2 1
8 3

negate (STL/CLR)

La classe de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne son argument négation. Vous l’utilisez pour spécifier un objet de fonction en termes de son type d’argument.

Syntaxe

template<typename Arg>
    ref class negate
    { // wrap operator()
public:
    typedef Arg argument_type;
    typedef bool result_type;
    typedef Microsoft::VisualC::StlClr::UnaryDelegate<
        argument_type, result_type>
        delegate_type;

    negate();
    negate(negate<Arg>% right);

    result_type operator()(argument_type left);
    operator delegate_type^();
    };

Paramètres

Arg
Type des arguments.

Fonctions de membre

Définition de type	Description
argument_type	Type de l’argument fonctor.
delegate_type	Type du délégué générique.
result_type	Type du résultat du fonctor.

Membre	Description
negate	Construit le functor.

Opérateur	Description
operator()	Calcule la fonction souhaitée.
operator delegate_type^	Convertit le fonctor en délégué.

Notes

La classe de modèle décrit un fonctor à argument unique. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne son argument négation.

Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.

Exemple

// cliext_negate.cpp
// compile with: /clr
#include <cliext/algorithm>
#include <cliext/functional>
#include <cliext/vector>

typedef cliext::vector<int> Myvector;
int main()
    {
    Myvector c1;
    c1.push_back(4);
    c1.push_back(-3);
    Myvector c3(2, 0);

// display initial contents " 4 -3"
    for each (int elem in c1)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display
    cliext::transform(c1.begin(), c1.begin() + 2,
        c3.begin(), cliext::negate<int>());
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();
    return (0);
    }

4 -3
-4 3

not_equal_to (STL/CLR)

La classe de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne true uniquement si le premier argument n’est pas égal à la seconde. Vous l’utilisez pour spécifier un objet de fonction en termes de son type d’argument.

Syntaxe

template<typename Arg>
    ref class not_equal_to
    { // wrap operator()
public:
    typedef Arg first_argument_type;
    typedef Arg second_argument_type;
    typedef bool result_type;
    typedef Microsoft::VisualC::StlClr::BinaryDelegate<
        first_argument_type, second_argument_type, result_type>
        delegate_type;

    not_equal_to();
    not_equal_to(not_equal_to<Arg>% right);

    result_type operator()(first_argument_type left,
        second_argument_type right);
    operator delegate_type^();
    };

Paramètres

Arg
Type des arguments.

Fonctions de membre

Définition de type	Description
delegate_type	Type du délégué générique.
first_argument_type	Type du premier argument du fonctor.
result_type	Type du résultat du fonctor.
second_argument_type	Type du deuxième argument du fonctor.

Membre	Description
not_equal_to	Construit le functor.

Opérateur	Description
operator()	Calcule la fonction souhaitée.
operator delegate_type^	Convertit le fonctor en délégué.

Notes

La classe de modèle décrit un fonctor à deux arguments. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne true uniquement si le premier argument n’est pas égal à la seconde.

Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.

Exemple

// cliext_not_equal_to.cpp
// compile with: /clr
#include <cliext/algorithm>
#include <cliext/functional>
#include <cliext/vector>

typedef cliext::vector<int> Myvector;
int main()
    {
    Myvector c1;
    c1.push_back(4);
    c1.push_back(3);
    Myvector c2;
    c2.push_back(4);
    c2.push_back(4);
    Myvector c3(2, 0);

// display initial contents " 4 3" and " 4 4"
    for each (int elem in c1)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

    for each (int elem in c2)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display
    cliext::transform(c1.begin(), c1.begin() + 2,
        c2.begin(), c3.begin(), cliext::not_equal_to<int>());
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();
    return (0);
    }

4 3
4 4
0 1

not1 (STL/CLR)

Génère un unary_negate fonctor pour un fonctor.

Syntaxe

template<typename Fun>
    unary_negate<Fun> not1(Fun% functor);

Paramètres du modèle

Fun
Type du functor.

Paramètres de fonction

functor
Le functor à envelopper.

Notes

Le modèle de fonction retourne unary_negate<Fun>(functor). Vous l’utilisez comme moyen pratique d’encapsuler un functor à argument unique dans un functor qui fournit son non logique.

Exemple

// cliext_not1.cpp
// compile with: /clr
#include <cliext/algorithm>
#include <cliext/functional>
#include <cliext/vector>

typedef cliext::vector<int> Myvector;
int main()
    {
    Myvector c1;
    c1.push_back(4);
    c1.push_back(0);
    Myvector c3(2, 0);

// display initial contents " 4 0"
    for each (int elem in c1)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display
    cliext::logical_not<int> not_op;

    cliext::transform(c1.begin(), c1.begin() + 2, c3.begin(),
        cliext::unary_negate<cliext::logical_not<int> >(not_op));
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display with function
    cliext::transform(c1.begin(), c1.begin() + 2, c3.begin(),
        cliext::not1(not_op));
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();
    return (0);
    }

4 0
1 0
1 0

not2 (STL/CLR)

Génère un binary_negate fonctor pour un fonctor.

Syntaxe

template<typename Fun>
    binary_negate<Fun> not2(Fun% functor);

Paramètres du modèle

Fun
Type du functor.

Paramètres de fonction

functor
Le functor à envelopper.

Notes

Le modèle de fonction retourne binary_negate<Fun>(functor). Vous l’utilisez comme moyen pratique d’encapsuler un fonctor à deux arguments dans un functor qui fournit son non logique.

Exemple

// cliext_not2.cpp
// compile with: /clr
#include <cliext/algorithm>
#include <cliext/functional>
#include <cliext/vector>

typedef cliext::vector<int> Myvector;
int main()
    {
    Myvector c1;
    c1.push_back(4);
    c1.push_back(3);
    Myvector c2;
    c2.push_back(4);
    c2.push_back(4);
    Myvector c3(2, 0);

// display initial contents " 4 3" and " 4 4"
    for each (int elem in c1)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

    for each (int elem in c2)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display
    cliext::less<int> less_op;

    cliext::transform(c1.begin(), c1.begin() + 2,
        c2.begin(), c3.begin(),
        cliext::binary_negate<cliext::less<int> >(less_op));
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display with function
    cliext::transform(c1.begin(), c1.begin() + 2,
        c2.begin(), c3.begin(), cliext::not2(less_op));
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();
    return (0);
    }

4 3
4 4
1 0
1 0

plus (STL/CLR)

La classe de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne le premier argument plus le deuxième. Vous l’utilisez pour spécifier un objet de fonction en termes de son type d’argument.

Syntaxe

template<typename Arg>
    ref class plus
    { // wrap operator()
public:
    typedef Arg first_argument_type;
    typedef Arg second_argument_type;
    typedef Arg result_type;
    typedef Microsoft::VisualC::StlClr::BinaryDelegate<
        first_argument_type, second_argument_type, result_type>
        delegate_type;

    plus();
    plus(plus<Arg>% right);

    result_type operator()(first_argument_type left,
        second_argument_type right);
    operator delegate_type^();
    };

Paramètres

Arg
Type des arguments et valeur de retour.

Fonctions de membre

Définition de type	Description
delegate_type	Type du délégué générique.
first_argument_type	Type du premier argument du fonctor.
result_type	Type du résultat du fonctor.
second_argument_type	Type du deuxième argument du fonctor.

Membre	Description
plus	Construit le functor.

Opérateur	Description
operator()	Calcule la fonction souhaitée.
operator delegate_type^	Convertit le fonctor en délégué.

Notes

La classe de modèle décrit un fonctor à deux arguments. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne le premier argument plus le deuxième.

Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.

Exemple

// cliext_plus.cpp
// compile with: /clr
#include <cliext/algorithm>
#include <cliext/functional>
#include <cliext/vector>

typedef cliext::vector<int> Myvector;
int main()
    {
    Myvector c1;
    c1.push_back(4);
    c1.push_back(3);
    Myvector c2;
    c2.push_back(2);
    c2.push_back(1);
    Myvector c3(2, 0);

// display initial contents " 4 3" and " 2 1"
    for each (int elem in c1)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

    for each (int elem in c2)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display
    cliext::transform(c1.begin(), c1.begin() + 2,
        c2.begin(), c3.begin(), cliext::plus<int>());
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();
    return (0);
    }

4 3
2 1
6 4

unary_delegate (STL/CLR)

La classe générique décrit un délégué à un argument. Vous l’utilisez pour spécifier un délégué en termes d’argument et de types de retour.

Syntaxe

generic<typename Arg,
    typename Result>
    delegate Result unary_delegate(Arg);

Paramètres

Arg
Type de l’argument.

Result
Type de retour.

Notes

Le délégué générique décrit une fonction à argument unique.

Dans ces modèles de fonction :

unary_delegate<int, int> Fun1;

unary_delegate<int, int> Fun2;

les types Fun1 et Fun2 sont des synonymes, tandis que pour :

delegate int Fun1(int);

delegate int Fun2(int);

ils ne sont pas du même type.

Exemple

// cliext_unary_delegate.cpp
// compile with: /clr
#include <cliext/functional>

int hash_val(wchar_t val)
    {
    return ((val * 17 + 31) % 67);
    }

typedef cliext::unary_delegate<wchar_t, int> Mydelegate;
int main()
    {
    Mydelegate^ myhash = gcnew Mydelegate(&hash_val);

    System::Console::WriteLine("hash(L'a') = {0}", myhash(L'a'));
    System::Console::WriteLine("hash(L'b') = {0}", myhash(L'b'));
    return (0);
    }

hash(L'a') = 5
hash(L'b') = 22

unary_delegate_noreturn (STL/CLR)

La classe générique décrit un délégué à un argument qui retourne void. Vous l’utilisez pour spécifier un délégué en termes de type d’argument.

Syntaxe

generic<typename Arg>
    delegate void unary_delegate_noreturn(Arg);

Paramètres

Arg
Type de l’argument.

Notes

Le délégué générique décrit une fonction à argument unique qui retourne void.

Dans ces modèles de fonction :

unary_delegate_noreturn<int> Fun1;

unary_delegate_noreturn<int> Fun2;

les types Fun1 et Fun2 sont des synonymes, tandis que pour :

delegate void Fun1(int);

delegate void Fun2(int);

ils ne sont pas du même type.

Exemple

// cliext_unary_delegate_noreturn.cpp
// compile with: /clr
#include <cliext/functional>

void hash_val(wchar_t val)
    {
    System::Console::WriteLine("hash({0}) = {1}",
       val, (val * 17 + 31) % 67);
    }

typedef cliext::unary_delegate_noreturn<wchar_t> Mydelegate;
int main()
    {
    Mydelegate^ myhash = gcnew Mydelegate(&hash_val);

    myhash(L'a');
    myhash(L'b');
    return (0);
    }

hash(a) = 5
hash(b) = 22

unary_negate (STL/CLR)

La classe de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne la logique NOT de son fonctor un argument stocké. Vous l’utilisez pour spécifier un objet de fonction en termes de fonctor stocké.

Syntaxe

template<typename Fun>
    ref class unary_negate
    { // wrap operator()
public:
    typedef Fun stored_function_type;
    typedef typename Fun::argument_type argument_type;
    typedef bool result_type;
    typedef Microsoft::VisualC::StlClr::UnaryDelegate<
        argument_type, result_type>
        delegate_type;

    unary_negate(Fun% functor);
    unary_negate(unary_negate<Fun>% right);

    result_type operator()(argument_type left);
    operator delegate_type^();
    };

Paramètres

Fun
Type du fonctor stocké.

Fonctions de membre

Définition de type	Description
argument_type	Type de l’argument fonctor.
delegate_type	Type du délégué générique.
result_type	Type du résultat du fonctor.

Membre	Description
unary_negate	Construit le functor.

Opérateur	Description
operator()	Calcule la fonction souhaitée.
delegate_type^	Convertit le fonctor en délégué.

Notes

La classe de modèle décrit un fonctor à argument unique qui stocke un autre fonctor un argument. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne la logique NOT du fonctor stocké appelé avec l’argument.

Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.

Exemple

// cliext_unary_negate.cpp
// compile with: /clr
#include <cliext/algorithm>
#include <cliext/functional>
#include <cliext/vector>

typedef cliext::vector<int> Myvector;
int main()
    {
    Myvector c1;
    c1.push_back(4);
    c1.push_back(0);
    Myvector c3(2, 0);

// display initial contents " 4 0"
    for each (int elem in c1)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display
    cliext::logical_not<int> not_op;

    cliext::transform(c1.begin(), c1.begin() + 2, c3.begin(),
        cliext::unary_negate<cliext::logical_not<int> >(not_op));
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();

// transform and display with function
    cliext::transform(c1.begin(), c1.begin() + 2, c3.begin(),
        cliext::not1(not_op));
    for each (int elem in c3)
        System::Console::Write(" {0}", elem);
    System::Console::WriteLine();
    return (0);
    }

4 0
1 0
1 0