`functional` (STL/CLR)

Articolo
10/12/2023

Includere l'intestazione <cliext/functional> STL/CLR per definire modelli di classe funzionale e delegati e funzioni del modello correlati.

Sintassi

#include <functional>

Requisiti

Intestazione:<cliext/functional>

Spazio dei nomi: cliext

Dichiarazioni

Delega	Descrizione
`binary_delegate` (STL/CLR)	Delegato a due argomenti.
`binary_delegate_noreturn` (STL/CLR)	Delegato a due argomenti che restituisce `void`.
`unary_delegate` (STL/CLR)	Delegato a un solo argomento.
`unary_delegate_noreturn` (STL/CLR)	Delegato a un argomento che restituisce `void`.

Classe	Descrizione
`binary_negate` (STL/CLR)	Functor per negare un funtore a due argomenti.
`binder1st` (STL/CLR)	Functor per associare il primo argomento a un funtore a due argomenti.
`binder2nd` (STL/CLR)	Functor per associare il secondo argomento a un funtore a due argomenti.
`divides` (STL/CLR)	Divide functor.
`equal_to` (STL/CLR)	Funtore di confronto uguale.
`greater` (STL/CLR)	Funtore di confronto maggiore.
`greater_equal` (STL/CLR)	Funtore di confronto maggiore o uguale.
`less` (STL/CLR)	Funtore di confronto minore.
`less_equal` (STL/CLR)	Funtore di confronto minore o uguale.
`logical_and` (STL/CLR)	Funtore AND logico.
`logical_not` (STL/CLR)	Funtore NOT logico.
`logical_or` (STL/CLR)	Funtore OR logico.
`minus` (STL/CLR)	Sottrae funtore.
`modulus` (STL/CLR)	Functor modulo.
`multiplies` (STL/CLR)	Moltiplicare il funtore.
`negate` (STL/CLR)	Functor per restituire l'argomento negato.
`not_equal_to` (STL/CLR)	Funtore di confronto diverso.
`plus` (STL/CLR)	Aggiungere functor.
`unary_negate` (STL/CLR)	Functor per negare un funtore a un argomento.

Funzione	Descrizione
`bind1st` (STL/CLR)	Genera un binder1st per un argomento e un funtore.
`bind2nd` (STL/CLR)	Genera un binder2nd per un argomento e un funtore.
`not1` (STL/CLR)	Genera un unary_negate per un functor.
`not2` (STL/CLR)	Genera un binary_negate per un functor.

Membri

`binary_delegate` (STL/CLR)

La classe generica descrive un delegato a due argomenti. Viene usato per specificare un delegato in termini di argomento e tipi restituiti.

Sintassi

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

Parametri

Arg1
Tipo del primo argomento.

Arg2
Tipo del secondo argomento.

Result
Tipo restituito.

Osservazioni:

Il delegato generico descrive una funzione a due argomenti.

Nei modelli di funzione seguenti:

binary_delegate<int, int, int> Fun1;

binary_delegate<int, int, int> Fun2;

i tipi Fun1 e Fun2 sono sinonimi, mentre per:

delegate int Fun1(int, int);

delegate int Fun2(int, int);

non sono dello stesso tipo.

Esempio

// 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 generica descrive un delegato a due argomenti che restituisce void. Viene usato per specificare un delegato in termini di argomento.

Sintassi

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

Parametri

Arg1
Tipo del primo argomento.

Arg2
Tipo del secondo argomento.

Osservazioni:

Il delegato generico descrive una funzione a due argomenti che restituisce void.

Nei modelli di funzione seguenti:

binary_delegate_noreturn<int, int> Fun1;

binary_delegate_noreturn<int, int> Fun2;

i tipi Fun1 e Fun2 sono sinonimi, mentre per:

delegate void Fun1(int, int);

delegate void Fun2(int, int);

non sono dello stesso tipo.

Esempio

// 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 modello descrive un funtore che, quando viene chiamato, restituisce il NOT logico del funtore a due argomenti archiviato. Viene usato per specificare un oggetto funzione in termini di funtore archiviato.

Sintassi

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^();
    };

Parametri

Fun
Tipo del funtore archiviato.

Funzioni di membro

Definizione del tipo	Descrizione
`delegate_type`	Tipo del delegato generico.
`first_argument_type`	Tipo del functor primo argomento.
`result_type`	Tipo del risultato del funtore.
`second_argument_type`	Tipo del secondo argomento functor.
`stored_function_type`	Tipo del funtore.

Membro	Descrizione
`binary_negate`	Costruisce il funtore.

Operatore	Descrizione
`operator()`	Calcola la funzione desiderata.
`operator delegate_type^()`	Esegue il cast del funtore a un delegato.

Osservazioni:

La classe modello descrive un funtore a due argomenti che archivia un altro funtore a due argomenti. Definisce l'operatore operator() membro in modo che, quando l'oggetto viene chiamato come funzione, restituisce il NOT logico del funtore archiviato chiamato con i due argomenti.

È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.

Esempio

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

`bind1st` (STL/CLR)

Genera un oggetto per un binder1st argomento e un funtore.

Sintassi

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

Parametri modello

Arg
Il tipo di argomento.

Fun
Tipo del funtore.

Parametri della funzione

functor
Funtore da avvolgere.

left
Primo argomento a capo.

Osservazioni:

Il modello di funzione restituisce binder1st<Fun>(functor, left). Lo si usa come modo pratico per eseguire il wrapping di un funtore a due argomenti e il primo argomento in un funtore a un argomento che lo chiama con un secondo argomento.

Esempio

// 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)

Genera un oggetto per un binder2nd argomento e un funtore.

Sintassi

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

Parametri modello

Arg
Il tipo di argomento.

Fun
Tipo del funtore.

Parametri della funzione

functor
Funtore da avvolgere.

right
Secondo argomento di cui eseguire il wrapping.

Osservazioni:

Il modello di funzione restituisce binder2nd<Fun>(functor, right). Lo si usa come modo pratico per eseguire il wrapping di un funtore a due argomenti e il secondo argomento in un funtore a un argomento che lo chiama con un primo argomento.

Esempio

// 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 modello descrive un funtore a un argomento che, quando viene chiamato, restituisce il funtore a due argomenti archiviato chiamato con il primo argomento archiviato e il secondo argomento fornito. Viene usato per specificare un oggetto funzione in termini di funtore archiviato.

Sintassi

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^();
    };

Parametri

Fun
Tipo del funtore archiviato.

Funzioni di membro

Definizione del tipo	Descrizione
`delegate_type`	Tipo del delegato generico.
`first_argument_type`	Tipo del functor primo argomento.
`result_type`	Tipo del risultato del funtore.
`second_argument_type`	Tipo del secondo argomento functor.
`stored_function_type`	Tipo del funtore.

Membro	Descrizione
`binder1st`	Costruisce il funtore.

Operatore	Descrizione
`operator()`	Calcola la funzione desiderata.
`operator delegate_type^()`	Esegue il cast del funtore a un delegato.

Osservazioni:

La classe modello descrive un funtore a un argomento che archivia un funtore a due argomenti e un primo argomento. Definisce l'operatore operator() membro in modo che, quando l'oggetto viene chiamato come funzione, restituisce il risultato della chiamata del funtore archiviato con il primo argomento archiviato e il secondo argomento fornito.

È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.

Esempio

// 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 modello descrive un funtore a un argomento che, quando viene chiamato, restituisce il funtore a due argomenti archiviato chiamato con il primo argomento fornito e il secondo argomento archiviato. Viene usato per specificare un oggetto funzione in termini di funtore archiviato.

Sintassi

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^();
    };

Parametri

Fun
Tipo del funtore archiviato.

Funzioni di membro

Definizione del tipo	Descrizione
`delegate_type`	Tipo del delegato generico.
`first_argument_type`	Tipo del functor primo argomento.
`result_type`	Tipo del risultato del funtore.
`second_argument_type`	Tipo del secondo argomento functor.
`stored_function_type`	Tipo del funtore.

Membro	Descrizione
`binder2nd`	Costruisce il funtore.

Operatore	Descrizione
`operator()`	Calcola la funzione desiderata.
`operator delegate_type^()`	Esegue il cast del funtore a un delegato.

Osservazioni:

La classe modello descrive un funtore a un argomento che archivia un funtore a due argomenti e un secondo argomento. Definisce l'operatore operator() membro in modo che, quando l'oggetto viene chiamato come funzione, restituisce il risultato della chiamata del funtore archiviato con il primo argomento fornito e il secondo argomento archiviato.

È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.

Esempio

// 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 modello descrive un funtore che, quando viene chiamato, restituisce il primo argomento diviso per il secondo. Viene usato per specificare un oggetto funzione in termini di tipo argomento.

Sintassi

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^();
    };

Parametri

Arg
Tipo di argomenti e valore restituito.

Funzioni di membro

Definizione del tipo	Descrizione
`delegate_type`	Tipo del delegato generico.
`first_argument_type`	Tipo del functor primo argomento.
`result_type`	Tipo del risultato del funtore.
`second_argument_type`	Tipo del secondo argomento functor.

Membro	Descrizione
`divides`	Costruisce il funtore.

Operatore	Descrizione
`operator()`	Calcola la funzione desiderata.
`operator delegate_type^()`	Esegue il cast del funtore a un delegato.

Osservazioni:

La classe modello descrive un funtore a due argomenti. Definisce l'operatore operator() membro in modo che, quando l'oggetto viene chiamato come funzione, restituisce il primo argomento diviso per il secondo.

È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.

Esempio

// 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 modello descrive un funtore che, quando viene chiamato, restituisce true solo se il primo argomento è uguale al secondo. Viene usato per specificare un oggetto funzione in termini di tipo argomento.

Sintassi

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^();
    };

Parametri

Arg
Tipo degli argomenti.

Funzioni di membro

Definizione del tipo	Descrizione
`delegate_type`	Tipo del delegato generico.
`first_argument_type`	Tipo del functor primo argomento.
`result_type`	Tipo del risultato del funtore.
`second_argument_type`	Tipo del secondo argomento functor.

Membro	Descrizione
`equal_to`	Costruisce il funtore.

Operatore	Descrizione
`operator()`	Calcola la funzione desiderata.
`operator delegate_type^()`	Esegue il cast del funtore a un delegato.

Osservazioni:

La classe modello descrive un funtore a due argomenti. Definisce l'operatore operator() membro in modo che, quando l'oggetto viene chiamato come funzione, restituisce true solo se il primo argomento è uguale al secondo.

È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.

Esempio

// 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 modello descrive un funtore che, quando viene chiamato, restituisce true solo se il primo argomento è maggiore del secondo. Viene usato per specificare un oggetto funzione in termini di tipo argomento.

Sintassi

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^();
    };

Parametri

Arg
Tipo degli argomenti.

Funzioni di membro

Definizione del tipo	Descrizione
`delegate_type`	Tipo del delegato generico.
`first_argument_type`	Tipo del functor primo argomento.
`result_type`	Tipo del risultato del funtore.
`second_argument_type`	Tipo del secondo argomento functor.

Membro	Descrizione
`greater`	Costruisce il funtore.

Operatore	Descrizione
`operator()`	Calcola la funzione desiderata.
`operator delegate_type^`	Esegue il cast del funtore a un delegato.

Osservazioni:

È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.

Esempio

// 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 modello descrive un funtore che, quando viene chiamato, restituisce true solo se il primo argomento è maggiore o uguale al secondo. Viene usato per specificare un oggetto funzione in termini di tipo argomento.

Sintassi

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^();
    };

Parametri

Arg
Tipo degli argomenti.

Funzioni di membro

Definizione del tipo	Descrizione
`delegate_type`	Tipo del delegato generico.
`first_argument_type`	Tipo del functor primo argomento.
`result_type`	Tipo del risultato del funtore.
`second_argument_type`	Tipo del secondo argomento functor.

Membro	Descrizione
`greater_equal`	Costruisce il funtore.

Operatore	Descrizione
`operator()`	Calcola la funzione desiderata.
`operator delegate_type^`	Esegue il cast del funtore a un delegato.

Osservazioni:

È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.

Esempio

// 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 modello descrive un funtore che, quando viene chiamato, restituisce true solo se il primo argomento è minore del secondo. Viene usato per specificare un oggetto funzione in termini di tipo argomento.

Sintassi

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^();
    };

Parametri

Arg
Tipo degli argomenti.

Funzioni di membro

Definizione del tipo	Descrizione
`delegate_type`	Tipo del delegato generico.
`first_argument_type`	Tipo del functor primo argomento.
`result_type`	Tipo del risultato del funtore.
`second_argument_type`	Tipo del secondo argomento functor.

Membro	Descrizione
`less`	Costruisce il funtore.

Operatore	Descrizione
`operator()`	Calcola la funzione desiderata.
`operator delegate_type^`	Esegue il cast del funtore a un delegato.

Osservazioni:

È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.

Esempio

// 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 modello descrive un funtore che, quando viene chiamato, restituisce true solo se il primo argomento è minore o uguale al secondo. Viene usato per specificare un oggetto funzione in termini di tipo argomento.

Sintassi

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^();
    };

Parametri

Arg
Tipo degli argomenti.

Funzioni di membro

Definizione del tipo	Descrizione
`delegate_type`	Tipo del delegato generico.
`first_argument_type`	Tipo del functor primo argomento.
`result_type`	Tipo del risultato del funtore.
`second_argument_type`	Tipo del secondo argomento functor.

Membro	Descrizione
`less_equal`	Costruisce il funtore.

Operatore	Descrizione
`operator()`	Calcola la funzione desiderata.
`operator delegate_type^`	Esegue il cast del funtore a un delegato.

Osservazioni:

È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.

Esempio

// 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 modello descrive un funtore che, quando viene chiamato, restituisce true solo se sia il primo argomento che il secondo test come true. Viene usato per specificare un oggetto funzione in termini di tipo argomento.

Sintassi

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^();
    };

Parametri

Arg
Tipo degli argomenti.

Funzioni di membro

Definizione del tipo	Descrizione
`delegate_type`	Tipo del delegato generico.
`first_argument_type`	Tipo del functor primo argomento.
`result_type`	Tipo del risultato del funtore.
`second_argument_type`	Tipo del secondo argomento functor.

Membro	Descrizione
`logical_and`	Costruisce il funtore.

Operatore	Descrizione
`operator()`	Calcola la funzione desiderata.
`operator delegate_type^`	Esegue il cast del funtore a un delegato.

Osservazioni:

È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.

Esempio

// 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 modello descrive un funtore che, quando viene chiamato, restituisce true solo se uno dei relativi argomenti viene verificato come false. Viene usato per specificare un oggetto funzione in termini di tipo argomento.

Sintassi

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^();
    };

Parametri

Arg
Tipo degli argomenti.

Funzioni di membro

Definizione del tipo	Descrizione
`argument_type`	Tipo dell'argomento functor.
`delegate_type`	Tipo del delegato generico.
`result_type`	Tipo del risultato del funtore.

Membro	Descrizione
`logical_not`	Costruisce il funtore.

Operatore	Descrizione
`operator()`	Calcola la funzione desiderata.
`operator delegate_type^`	Esegue il cast del funtore a un delegato.

Osservazioni:

La classe modello descrive un funtore a un argomento. Definisce l'operatore operator() membro in modo che, quando l'oggetto viene chiamato come funzione, restituisce true solo se il relativo argomento viene verificato come false.

È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.

Esempio

// 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 modello descrive un funtore che, quando viene chiamato, restituisce true solo se il primo argomento o il secondo test è true. Viene usato per specificare un oggetto funzione in termini di tipo argomento.

Sintassi

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^();
    };

Parametri

Arg
Tipo degli argomenti.

Funzioni di membro

Definizione del tipo	Descrizione
`delegate_type`	Tipo del delegato generico.
`first_argument_type`	Tipo del functor primo argomento.
`result_type`	Tipo del risultato del funtore.
`second_argument_type`	Tipo del secondo argomento functor.

Membro	Descrizione
`logical_or`	Costruisce il funtore.

Operatore	Descrizione
`operator()`	Calcola la funzione desiderata.
`operator delegate_type^`	Esegue il cast del funtore a un delegato.

Osservazioni:

È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.

Esempio

// 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 modello descrive un funtore che, quando viene chiamato, restituisce il primo argomento meno il secondo. Viene usato per specificare un oggetto funzione in termini di tipo argomento.

Sintassi

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^();
    };

Parametri

Arg
Tipo di argomenti e valore restituito.

Funzioni di membro

Definizione del tipo	Descrizione
`delegate_type`	Tipo del delegato generico.
`first_argument_type`	Tipo del functor primo argomento.
`result_type`	Tipo del risultato del funtore.
`second_argument_type`	Tipo del secondo argomento functor.

Membro	Descrizione
`minus`	Costruisce il funtore.

Operatore	Descrizione
`operator()`	Calcola la funzione desiderata.
`operator delegate_type^`	Esegue il cast del funtore a un delegato.

Osservazioni:

È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.

Esempio

// 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 modello descrive un funtore che, quando viene chiamato, restituisce il primo argomento modulo il secondo. Viene usato per specificare un oggetto funzione in termini di tipo argomento.

Sintassi

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^();
    };

Parametri

Arg
Tipo di argomenti e valore restituito.

Funzioni di membro

Definizione del tipo	Descrizione
`delegate_type`	Tipo del delegato generico.
`first_argument_type`	Tipo del functor primo argomento.
`result_type`	Tipo del risultato del funtore.
`second_argument_type`	Tipo del secondo argomento functor.

Membro	Descrizione
`modulus`	Costruisce il funtore.

Operatore	Descrizione
`operator()`	Calcola la funzione desiderata.
`operator delegate_type^`	Esegue il cast del funtore a un delegato.

Osservazioni:

È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.

Esempio

// 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 modello descrive un funtore che, quando viene chiamato, restituisce il primo argomento volte al secondo. Viene usato per specificare un oggetto funzione in termini di tipo argomento.

Sintassi

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^();
    };

Parametri

Arg
Tipo di argomenti e valore restituito.

Funzioni di membro

Definizione del tipo	Descrizione
`delegate_type`	Tipo del delegato generico.
`first_argument_type`	Tipo del functor primo argomento.
`result_type`	Tipo del risultato del funtore.
`second_argument_type`	Tipo del secondo argomento functor.

Membro	Descrizione
`multiplies`	Costruisce il funtore.

Operatore	Descrizione
`operator()`	Calcola la funzione desiderata.
`operator delegate_type^`	Esegue il cast del funtore a un delegato.

Osservazioni:

È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.

Esempio

// 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 modello descrive un funtore che, quando viene chiamato, restituisce il relativo argomento negato. Viene usato per specificare un oggetto funzione in termini di tipo argomento.

Sintassi

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^();
    };

Parametri

Arg
Tipo degli argomenti.

Funzioni di membro

Definizione del tipo	Descrizione
`argument_type`	Tipo dell'argomento functor.
`delegate_type`	Tipo del delegato generico.
`result_type`	Tipo del risultato del funtore.

Membro	Descrizione
`negate`	Costruisce il funtore.

Operatore	Descrizione
`operator()`	Calcola la funzione desiderata.
`operator delegate_type^`	Esegue il cast del funtore a un delegato.

Osservazioni:

La classe modello descrive un funtore a un argomento. Definisce l'operatore operator() membro in modo che, quando l'oggetto viene chiamato come funzione, restituisce il relativo argomento negato.

È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.

Esempio

// 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 modello descrive un funtore che, quando viene chiamato, restituisce true solo se il primo argomento non è uguale al secondo. Viene usato per specificare un oggetto funzione in termini di tipo argomento.

Sintassi

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^();
    };

Parametri

Arg
Tipo degli argomenti.

Funzioni di membro

Definizione del tipo	Descrizione
`delegate_type`	Tipo del delegato generico.
`first_argument_type`	Tipo del functor primo argomento.
`result_type`	Tipo del risultato del funtore.
`second_argument_type`	Tipo del secondo argomento functor.

Membro	Descrizione
`not_equal_to`	Costruisce il funtore.

Operatore	Descrizione
`operator()`	Calcola la funzione desiderata.
`operator delegate_type^`	Esegue il cast del funtore a un delegato.

Osservazioni:

È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.

Esempio

// 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)

Genera un oggetto unary_negate per un funtore.

Sintassi

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

Parametri modello

Fun
Tipo del funtore.

Parametri della funzione

functor
Funtore da avvolgere.

Osservazioni:

Il modello di funzione restituisce unary_negate<Fun>(functor). Lo si usa come modo pratico per eseguire il wrapping di un funtore a un argomento in un funtore che fornisce il relativo NOT logico.

Esempio

// 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)

Genera un oggetto binary_negate per un funtore.

Sintassi

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

Parametri modello

Fun
Tipo del funtore.

Parametri della funzione

functor
Funtore da avvolgere.

Osservazioni:

Il modello di funzione restituisce binary_negate<Fun>(functor). Lo si usa come modo pratico per eseguire il wrapping di un funtore a due argomenti in un funtore che fornisce il relativo NOT logico.

Esempio

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

`plus` (STL/CLR)

La classe modello descrive un funtore che, quando viene chiamato, restituisce il primo argomento più il secondo. Viene usato per specificare un oggetto funzione in termini di tipo argomento.

Sintassi

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^();
    };

Parametri

Arg
Tipo di argomenti e valore restituito.

Funzioni di membro

Definizione del tipo	Descrizione
`delegate_type`	Tipo del delegato generico.
`first_argument_type`	Tipo del functor primo argomento.
`result_type`	Tipo del risultato del funtore.
`second_argument_type`	Tipo del secondo argomento functor.

Membro	Descrizione
`plus`	Costruisce il funtore.

Operatore	Descrizione
`operator()`	Calcola la funzione desiderata.
`operator delegate_type^`	Esegue il cast del funtore a un delegato.

Osservazioni:

È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.

Esempio

// 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 generica descrive un delegato di un argomento. Viene usato per specificare un delegato in termini di argomento e tipi restituiti.

Sintassi

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

Parametri

Arg
Il tipo di argomento.

Result
Tipo restituito.

Osservazioni:

Il delegato generico descrive una funzione con un solo argomento.

Nei modelli di funzione seguenti:

unary_delegate<int, int> Fun1;

unary_delegate<int, int> Fun2;

i tipi Fun1 e Fun2 sono sinonimi, mentre per:

delegate int Fun1(int);

delegate int Fun2(int);

non sono dello stesso tipo.

Esempio

// 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 generica descrive un delegato di un argomento che restituisce void. Viene usato per specificare un delegato in termini di tipo argomento.

Sintassi

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

Parametri

Arg
Il tipo di argomento.

Osservazioni:

Il delegato generico descrive una funzione a un argomento che restituisce void.

Nei modelli di funzione seguenti:

unary_delegate_noreturn<int> Fun1;

unary_delegate_noreturn<int> Fun2;

i tipi Fun1 e Fun2 sono sinonimi, mentre per:

delegate void Fun1(int);

delegate void Fun2(int);

non sono dello stesso tipo.

Esempio

// 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 modello descrive un funtore che, quando viene chiamato, restituisce il not logico del funtore a un argomento archiviato. Viene usato per specificare un oggetto funzione in termini di funtore archiviato.

Sintassi

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^();
    };

Parametri

Fun
Tipo del funtore archiviato.

Funzioni di membro

Definizione del tipo	Descrizione
`argument_type`	Tipo dell'argomento functor.
`delegate_type`	Tipo del delegato generico.
`result_type`	Tipo del risultato del funtore.

Membro	Descrizione
`unary_negate`	Costruisce il funtore.

Operatore	Descrizione
`operator()`	Calcola la funzione desiderata.
`delegate_type^`	Esegue il cast del funtore a un delegato.

Osservazioni:

La classe modello descrive un funtore a un argomento che archivia un altro funtore a argomento. Definisce l'operatore operator() membro in modo che, quando l'oggetto viene chiamato come funzione, restituisce il NOT logico del funtore archiviato chiamato con l'argomento .

È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.

Esempio

// 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

Condividi tramite

functional (STL/CLR)

Sintassi

Requisiti

Dichiarazioni

Membri

binary_delegate (STL/CLR)

Sintassi

Parametri

Osservazioni:

Esempio

binary_delegate_noreturn (STL/CLR)

Sintassi

Parametri

Osservazioni:

Esempio

binary_negate (STL/CLR)

Sintassi

Parametri

Funzioni di membro

Osservazioni:

Esempio

bind1st (STL/CLR)

Sintassi

Parametri modello

Parametri della funzione

Osservazioni:

Esempio

bind2nd (STL/CLR)

Sintassi

Parametri modello

Parametri della funzione

Osservazioni:

Esempio

binder1st (STL/CLR)

Sintassi

Parametri

Funzioni di membro

Osservazioni:

Esempio

binder2nd (STL/CLR)

Sintassi

Parametri

Funzioni di membro

Osservazioni:

Esempio

divides (STL/CLR)

Sintassi

Parametri

Funzioni di membro

Osservazioni:

Esempio

equal_to (STL/CLR)

Sintassi

Parametri

Funzioni di membro

Osservazioni:

Esempio

greater (STL/CLR)

Sintassi

Parametri

Funzioni di membro

Osservazioni:

Esempio

greater_equal (STL/CLR)

Sintassi

Parametri

Funzioni di membro

Osservazioni:

Esempio

less (STL/CLR)

Sintassi

Parametri

Funzioni di membro

Osservazioni:

Esempio

less_equal (STL/CLR)

Sintassi

Parametri

Funzioni di membro

`functional` (STL/CLR)

`binary_delegate` (STL/CLR)

`binary_delegate_noreturn` (STL/CLR)

`binary_negate` (STL/CLR)

`bind1st` (STL/CLR)

`bind2nd` (STL/CLR)

`binder1st` (STL/CLR)

`binder2nd` (STL/CLR)

`divides` (STL/CLR)

`equal_to` (STL/CLR)

`greater` (STL/CLR)

`greater_equal` (STL/CLR)

`less` (STL/CLR)

`less_equal` (STL/CLR)

`logical_and` (STL/CLR)

`logical_not` (STL/CLR)

`logical_or` (STL/CLR)

`minus` (STL/CLR)

`modulus` (STL/CLR)

`multiplies` (STL/CLR)

`negate` (STL/CLR)

`not_equal_to` (STL/CLR)

`not1` (STL/CLR)

`not2` (STL/CLR)

`plus` (STL/CLR)

`unary_delegate` (STL/CLR)