`functional` (STL/CLR)

Artikel
10/12/2023

Fügen Sie den STL/CLR-Header <cliext/functional> ein, um funktionale Klassenvorlagen und zugehörige Vorlagendelegatten und -funktionen zu definieren.

Syntax

#include <functional>

Requirements (Anforderungen)

Header:<cliext/functional>

Namespace:cliext

Deklarationen

Delegat	Beschreibung
`binary_delegate` (STL/CLR)	Stellvertretung mit zwei Argumenten.
`binary_delegate_noreturn` (STL/CLR)	Stellvertretung mit zwei Argumenten, die zurückgegeben wird `void`.
`unary_delegate` (STL/CLR)	Stellvertretung mit einem Argument.
`unary_delegate_noreturn` (STL/CLR)	Stellvertretung mit einem Argument, die zurückgegeben wird `void`.

Klasse	Beschreibung
`binary_negate` (STL/CLR)	Functor zum Negieren eines Zwei-Argument-Functors.
`binder1st` (STL/CLR)	Functor zum Binden des ersten Arguments an einen Zwei-Argument-Functor.
`binder2nd` (STL/CLR)	Functor zum Binden des zweiten Arguments an einen Zwei-Argument-Functor.
`divides` (STL/CLR)	Teilen Sie den Functor.
`equal_to` (STL/CLR)	Gleicher Vergleichs-Functor.
`greater` (STL/CLR)	Größerer Vergleichs-Functor.
`greater_equal` (STL/CLR)	Größer oder gleicher Vergleichs-Functor.
`less` (STL/CLR)	Weniger Vergleichs-Functor.
`less_equal` (STL/CLR)	Kleiner oder gleicher Vergleichs-Functor.
`logical_and` (STL/CLR)	Logische UND Functor.
`logical_not` (STL/CLR)	LogischeR NOT-Functor.
`logical_or` (STL/CLR)	LogischeR ODER-Functor.
`minus` (STL/CLR)	Subtrahieren Sie den Functor.
`modulus` (STL/CLR)	Modulus Functor.
`multiplies` (STL/CLR)	Multiplizieren sie.
`negate` (STL/CLR)	Functor, um sein Argument negiert zurückzugeben.
`not_equal_to` (STL/CLR)	Kein gleicher Vergleichs-Functor.
`plus` (STL/CLR)	Fügen Sie einen Functor hinzu.
`unary_negate` (STL/CLR)	Functor zum Negieren eines Ein-Argument-Functors.

Function	Beschreibung
`bind1st` (STL/CLR)	Generiert einen Binder1st für ein Argument und einen Functor.
`bind2nd` (STL/CLR)	Generiert einen Binder2nd für ein Argument und einen Functor.
`not1` (STL/CLR)	Generiert eine unary_negate für einen Functor.
`not2` (STL/CLR)	Generiert eine binary_negate für einen Functor.

Member

`binary_delegate` (STL/CLR)

Die generische Klasse beschreibt einen Zwei-Argument-Delegaten. Sie verwenden ihn, um einen Delegat in Bezug auf das Argument und die Rückgabetypen anzugeben.

Syntax

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

Parameter

Arg1
Der Typ des ersten Arguments.

Arg2
Der Typ des zweiten Arguments.

Result
Der Rückgabetyp.

Hinweise

Der generische Delegat beschreibt eine Zwei-Argument-Funktion.

In diesen Funktionsvorlagen:

binary_delegate<int, int, int> Fun1;

binary_delegate<int, int, int> Fun2;

die Typen Fun1 und Fun2 Synonyme sind, während für:

delegate int Fun1(int, int);

delegate int Fun2(int, int);

sie sind nicht derselbe Typ.

Beispiel

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

Die generische Klasse beschreibt einen Zwei-Argument-Delegaten, der zurückgegeben wird void. Sie verwenden ihn, um einen Delegat in Bezug auf das Argument anzugeben.

Syntax

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

Parameter

Arg1
Der Typ des ersten Arguments.

Arg2
Der Typ des zweiten Arguments.

Hinweise

Der generische Delegat beschreibt eine Zwei-Argument-Funktion, die zurückgegeben wird void.

In diesen Funktionsvorlagen:

binary_delegate_noreturn<int, int> Fun1;

binary_delegate_noreturn<int, int> Fun2;

die Typen Fun1 und Fun2 Synonyme sind, während für:

delegate void Fun1(int, int);

delegate void Fun2(int, int);

sie sind nicht derselbe Typ.

Beispiel

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

Die Vorlagenklasse beschreibt einen Functor, der, wenn sie aufgerufen wird, die logische NOT des gespeicherten Zwei-Argument-Functors zurückgibt. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den gespeicherten Functor anzugeben.

Syntax

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

Parameter

Fun
Der Typ des gespeicherten Functors.

Elementfunktionen

Typendefinition	Beschreibung
`delegate_type`	Der Typ des generischen Delegaten.
`first_argument_type`	Der Typ des ersten Arguments des Functors.
`result_type`	Der Typ des Functorergebnisses.
`second_argument_type`	Der Typ des zweiten Arguments des Functors.
`stored_function_type`	Der Typ des Functors.

Member	Beschreibung
`binary_negate`	Erstellt den Functor.

Operator	Beschreibung
`operator()`	Berechnet die gewünschte Funktion.
`operator delegate_type^()`	Wandelt den Functor in eine Stellvertretung um.

Hinweise

Die Vorlagenklasse beschreibt einen Zwei-Argument-Functor, der einen weiteren Zwei-Argument-Functor speichert. Er definiert den Memberoperator operator() , sodass, wenn das Objekt als Funktion aufgerufen wird, die logische NOT des gespeicherten Functors zurückgibt, der mit den beiden Argumenten aufgerufen wird.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.

Beispiel

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

Generiert ein Argument und einen binder1st Functor.

Syntax

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

Vorlage Parameter

Arg
Der Typ des Arguments.

Fun
Der Typ des Functors.

Funktionsparameter

functor
Der Functor, der umbrochen werden soll.

left
Das erste Argument, das umbrochen werden soll.

Hinweise

Die Funktionsvorlage gibt zurück binder1st<Fun>(functor, left). Sie verwenden es als bequeme Möglichkeit, einen Zwei-Argument-Functor und sein erstes Argument in einem Ein-Argument-Functor umzuschließen, der ihn mit einem zweiten Argument aufruft.

Beispiel

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

Generiert ein Argument und einen binder2nd Functor.

Syntax

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

Vorlage Parameter

Arg
Der Typ des Arguments.

Fun
Der Typ des Functors.

Funktionsparameter

functor
Der Functor, der umbrochen werden soll.

right
Das zweite Argument, das umbrochen werden soll.

Hinweise

Die Funktionsvorlage gibt zurück binder2nd<Fun>(functor, right). Sie verwenden es als bequeme Möglichkeit, einen Zwei-Argument-Functor und das zweite Argument in einem Ein-Argument-Functor umzuschließen, der ihn mit einem ersten Argument aufruft.

Beispiel

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

Die Vorlagenklasse beschreibt einen Ein-Argument-Functor, der, wenn aufgerufen wird, seinen gespeicherten Zwei-Argument-Functor zurückgibt, der mit dem gespeicherten ersten Argument und dem angegebenen zweiten Argument aufgerufen wird. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den gespeicherten Functor anzugeben.

Syntax

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

Parameter

Fun
Der Typ des gespeicherten Functors.

Elementfunktionen

Typendefinition	Beschreibung
`delegate_type`	Der Typ des generischen Delegaten.
`first_argument_type`	Der Typ des ersten Arguments des Functors.
`result_type`	Der Typ des Functorergebnisses.
`second_argument_type`	Der Typ des zweiten Arguments des Functors.
`stored_function_type`	Der Typ des Functors.

Member	Beschreibung
`binder1st`	Erstellt den Functor.

Operator	Beschreibung
`operator()`	Berechnet die gewünschte Funktion.
`operator delegate_type^()`	Wandelt den Functor in eine Stellvertretung um.

Hinweise

Die Vorlagenklasse beschreibt einen Ein-Argument-Functor, der einen Zwei-Argument-Functor und ein erstes Argument speichert. Er definiert den Memberoperator operator() , sodass, wenn das Objekt als Funktion aufgerufen wird, das Ergebnis des Aufrufs des gespeicherten Functors mit dem gespeicherten ersten Argument und dem angegebenen zweiten Argument zurückgibt.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.

Beispiel

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

Die Vorlagenklasse beschreibt einen Ein-Argument-Functor, der, wenn sie aufgerufen wird, den gespeicherten Zwei-Argument-Functor zurückgibt, der mit dem angegebenen ersten Argument und dem gespeicherten zweiten Argument aufgerufen wird. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den gespeicherten Functor anzugeben.

Syntax

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

Parameter

Fun
Der Typ des gespeicherten Functors.

Elementfunktionen

Typendefinition	Beschreibung
`delegate_type`	Der Typ des generischen Delegaten.
`first_argument_type`	Der Typ des ersten Arguments des Functors.
`result_type`	Der Typ des Functorergebnisses.
`second_argument_type`	Der Typ des zweiten Arguments des Functors.
`stored_function_type`	Der Typ des Functors.

Member	Beschreibung
`binder2nd`	Erstellt den Functor.

Operator	Beschreibung
`operator()`	Berechnet die gewünschte Funktion.
`operator delegate_type^()`	Wandelt den Functor in eine Stellvertretung um.

Hinweise

Die Vorlagenklasse beschreibt einen Ein-Argument-Functor, der einen Zwei-Argument-Functor und ein zweites Argument speichert. Er definiert den Memberoperator operator() so, dass beim Aufrufen des Objekts als Funktion das Ergebnis des Aufrufs des gespeicherten Functors mit dem angegebenen ersten Argument und dem gespeicherten zweiten Argument zurückgegeben wird.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.

Beispiel

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

Die Vorlagenklasse beschreibt einen Functor, der, wenn sie aufgerufen wird, das erste Argument dividiert durch die zweite zurückgibt. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den Argumenttyp anzugeben.

Syntax

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

Parameter

Arg
Der Typ der Argumente und des Rückgabewerts.

Elementfunktionen

Typendefinition	Beschreibung
`delegate_type`	Der Typ des generischen Delegaten.
`first_argument_type`	Der Typ des ersten Arguments des Functors.
`result_type`	Der Typ des Functorergebnisses.
`second_argument_type`	Der Typ des zweiten Arguments des Functors.

Member	Beschreibung
`divides`	Erstellt den Functor.

Operator	Beschreibung
`operator()`	Berechnet die gewünschte Funktion.
`operator delegate_type^()`	Wandelt den Functor in eine Stellvertretung um.

Hinweise

Die Vorlagenklasse beschreibt einen Zwei-Argument-Functor. Er definiert den Memberoperator operator() so, dass, wenn das Objekt als Funktion aufgerufen wird, das erste Argument dividiert durch die zweite zurückgibt.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.

Beispiel

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

Die Vorlagenklasse beschreibt einen Functor, der, wenn sie aufgerufen wird, nur true zurückgibt, wenn das erste Argument gleich der zweiten ist. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den Argumenttyp anzugeben.

Syntax

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

Parameter

Arg
Der Typ der Argumente.

Elementfunktionen

Typendefinition	Beschreibung
`delegate_type`	Der Typ des generischen Delegaten.
`first_argument_type`	Der Typ des ersten Arguments des Functors.
`result_type`	Der Typ des Functorergebnisses.
`second_argument_type`	Der Typ des zweiten Arguments des Functors.

Member	Beschreibung
`equal_to`	Erstellt den Functor.

Operator	Beschreibung
`operator()`	Berechnet die gewünschte Funktion.
`operator delegate_type^()`	Wandelt den Functor in eine Stellvertretung um.

Hinweise

Die Vorlagenklasse beschreibt einen Zwei-Argument-Functor. Er definiert den Memberoperator operator() , sodass das erste Argument nur dann wahr ist, wenn das Objekt als Funktion aufgerufen wird.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.

Beispiel

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

Die Vorlagenklasse beschreibt einen Functor, der bei Aufruf nur "true" zurückgibt, wenn das erste Argument größer als die zweite ist. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den Argumenttyp anzugeben.

Syntax

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

Parameter

Arg
Der Typ der Argumente.

Elementfunktionen

Typendefinition	Beschreibung
`delegate_type`	Der Typ des generischen Delegaten.
`first_argument_type`	Der Typ des ersten Arguments des Functors.
`result_type`	Der Typ des Functorergebnisses.
`second_argument_type`	Der Typ des zweiten Arguments des Functors.

Member	Beschreibung
`greater`	Erstellt den Functor.

Operator	Beschreibung
`operator()`	Berechnet die gewünschte Funktion.
`operator delegate_type^`	Wandelt den Functor in eine Stellvertretung um.

Hinweise

Die Vorlagenklasse beschreibt einen Zwei-Argument-Functor. Er definiert den Memberoperator operator() , sodass das erste Argument nur dann true zurückgibt, wenn das erste Argument größer als die zweite ist, wenn das Objekt als Funktion aufgerufen wird.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.

Beispiel

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

Die Vorlagenklasse beschreibt einen Functor, der bei Aufruf nur "true" zurückgibt, wenn das erste Argument größer oder gleich dem zweiten ist. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den Argumenttyp anzugeben.

Syntax

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

Parameter

Arg
Der Typ der Argumente.

Elementfunktionen

Typendefinition	Beschreibung
`delegate_type`	Der Typ des generischen Delegaten.
`first_argument_type`	Der Typ des ersten Arguments des Functors.
`result_type`	Der Typ des Functorergebnisses.
`second_argument_type`	Der Typ des zweiten Arguments des Functors.

Member	Beschreibung
`greater_equal`	Erstellt den Functor.

Operator	Beschreibung
`operator()`	Berechnet die gewünschte Funktion.
`operator delegate_type^`	Wandelt den Functor in eine Stellvertretung um.

Hinweise

Die Vorlagenklasse beschreibt einen Zwei-Argument-Functor. Er definiert den Memberoperator operator() , sodass das Erste Argument größer oder gleich der zweiten ist, wenn das Objekt als Funktion aufgerufen wird, "true" zurück.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.

Beispiel

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

Die Vorlagenklasse beschreibt einen Functor, der bei Aufruf nur "true" zurückgibt, wenn das erste Argument kleiner als der zweite ist. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den Argumenttyp anzugeben.

Syntax

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

Parameter

Arg
Der Typ der Argumente.

Elementfunktionen

Typendefinition	Beschreibung
`delegate_type`	Der Typ des generischen Delegaten.
`first_argument_type`	Der Typ des ersten Arguments des Functors.
`result_type`	Der Typ des Functorergebnisses.
`second_argument_type`	Der Typ des zweiten Arguments des Functors.

Member	Beschreibung
`less`	Erstellt den Functor.

Operator	Beschreibung
`operator()`	Berechnet die gewünschte Funktion.
`operator delegate_type^`	Wandelt den Functor in eine Stellvertretung um.

Hinweise

Die Vorlagenklasse beschreibt einen Zwei-Argument-Functor. Er definiert den Memberoperator operator() , sodass das erste Argument nur dann wahr ist, wenn das Objekt als Funktion aufgerufen wird.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.

Beispiel

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

Die Vorlagenklasse beschreibt einen Functor, der bei Aufruf nur "true" zurückgibt, wenn das erste Argument kleiner oder gleich dem zweiten ist. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den Argumenttyp anzugeben.

Syntax

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

Parameter

Arg
Der Typ der Argumente.

Elementfunktionen

Typendefinition	Beschreibung
`delegate_type`	Der Typ des generischen Delegaten.
`first_argument_type`	Der Typ des ersten Arguments des Functors.
`result_type`	Der Typ des Functorergebnisses.
`second_argument_type`	Der Typ des zweiten Arguments des Functors.

Member	Beschreibung
`less_equal`	Erstellt den Functor.

Operator	Beschreibung
`operator()`	Berechnet die gewünschte Funktion.
`operator delegate_type^`	Wandelt den Functor in eine Stellvertretung um.

Hinweise

Die Vorlagenklasse beschreibt einen Zwei-Argument-Functor. Er definiert den Memberoperator operator() , sodass, wenn das Objekt als Funktion aufgerufen wird, nur true zurückgibt, wenn das erste Argument kleiner oder gleich dem zweiten ist.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.

Beispiel

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

Die Vorlagenklasse beschreibt einen Functor, der bei Aufruf nur "true" zurückgibt, wenn sowohl das erste Argument als auch der zweite Test als "true" verwendet werden. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den Argumenttyp anzugeben.

Syntax

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

Parameter

Arg
Der Typ der Argumente.

Elementfunktionen

Typendefinition	Beschreibung
`delegate_type`	Der Typ des generischen Delegaten.
`first_argument_type`	Der Typ des ersten Arguments des Functors.
`result_type`	Der Typ des Functorergebnisses.
`second_argument_type`	Der Typ des zweiten Arguments des Functors.

Member	Beschreibung
`logical_and`	Erstellt den Functor.

Operator	Beschreibung
`operator()`	Berechnet die gewünschte Funktion.
`operator delegate_type^`	Wandelt den Functor in eine Stellvertretung um.

Hinweise

Die Vorlagenklasse beschreibt einen Zwei-Argument-Functor. Er definiert den Memberoperator operator() so, dass das Objekt, wenn das Objekt als Funktion aufgerufen wird, nur true zurückgibt, wenn sowohl das erste Argument als auch der zweite Test als "true" angegeben werden.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.

Beispiel

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

Die Vorlagenklasse beschreibt einen Functor, der bei Aufruf nur "true" zurückgibt, wenn beide Argumente als "false" getestet werden. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den Argumenttyp anzugeben.

Syntax

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

Parameter

Arg
Der Typ der Argumente.

Elementfunktionen

Typendefinition	Beschreibung
`argument_type`	Der Typ des Functor-Arguments.
`delegate_type`	Der Typ des generischen Delegaten.
`result_type`	Der Typ des Functorergebnisses.

Member	Beschreibung
`logical_not`	Erstellt den Functor.

Operator	Beschreibung
`operator()`	Berechnet die gewünschte Funktion.
`operator delegate_type^`	Wandelt den Functor in eine Stellvertretung um.

Hinweise

Die Vorlagenklasse beschreibt einen Ein-Argument-Functor. Er definiert den Memberoperator operator() , sodass das Objekt, wenn das Objekt als Funktion aufgerufen wird, nur true zurückgibt, wenn das Argument als falsch getestet wird.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.

Beispiel

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

Die Vorlagenklasse beschreibt einen Functor, der, wenn sie aufgerufen wird, nur true zurückgibt, wenn entweder das erste Argument oder die zweite Prüfung als wahr ausgeführt wird. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den Argumenttyp anzugeben.

Syntax

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

Parameter

Arg
Der Typ der Argumente.

Elementfunktionen

Typendefinition	Beschreibung
`delegate_type`	Der Typ des generischen Delegaten.
`first_argument_type`	Der Typ des ersten Arguments des Functors.
`result_type`	Der Typ des Functorergebnisses.
`second_argument_type`	Der Typ des zweiten Arguments des Functors.

Member	Beschreibung
`logical_or`	Erstellt den Functor.

Operator	Beschreibung
`operator()`	Berechnet die gewünschte Funktion.
`operator delegate_type^`	Wandelt den Functor in eine Stellvertretung um.

Hinweise

Die Vorlagenklasse beschreibt einen Zwei-Argument-Functor. Er definiert den Memberoperator operator() , sodass das Objekt, wenn das Objekt als Funktion aufgerufen wird, nur true zurückgibt, wenn entweder das erste Argument oder die zweite Als wahr getestet wird.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.

Beispiel

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

Die Vorlagenklasse beschreibt einen Functor, der bei Aufruf das erste Argument minus der zweiten zurückgibt. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den Argumenttyp anzugeben.

Syntax

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

Parameter

Arg
Der Typ der Argumente und des Rückgabewerts.

Elementfunktionen

Typendefinition	Beschreibung
`delegate_type`	Der Typ des generischen Delegaten.
`first_argument_type`	Der Typ des ersten Arguments des Functors.
`result_type`	Der Typ des Functorergebnisses.
`second_argument_type`	Der Typ des zweiten Arguments des Functors.

Member	Beschreibung
`minus`	Erstellt den Functor.

Operator	Beschreibung
`operator()`	Berechnet die gewünschte Funktion.
`operator delegate_type^`	Wandelt den Functor in eine Stellvertretung um.

Hinweise

Die Vorlagenklasse beschreibt einen Zwei-Argument-Functor. Er definiert den Memberoperator operator() , sodass, wenn das Objekt als Funktion aufgerufen wird, das erste Argument minus der zweiten zurückgibt.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.

Beispiel

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

Die Vorlagenklasse beschreibt einen Functor, der, wenn sie aufgerufen wird, das erste Argumentmodul für die zweite zurückgibt. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den Argumenttyp anzugeben.

Syntax

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

Parameter

Arg
Der Typ der Argumente und des Rückgabewerts.

Elementfunktionen

Typendefinition	Beschreibung
`delegate_type`	Der Typ des generischen Delegaten.
`first_argument_type`	Der Typ des ersten Arguments des Functors.
`result_type`	Der Typ des Functorergebnisses.
`second_argument_type`	Der Typ des zweiten Arguments des Functors.

Member	Beschreibung
`modulus`	Erstellt den Functor.

Operator	Beschreibung
`operator()`	Berechnet die gewünschte Funktion.
`operator delegate_type^`	Wandelt den Functor in eine Stellvertretung um.

Hinweise

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.

Beispiel

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

Die Vorlagenklasse beschreibt einen Functor, der beim Aufrufen das erste Argument mal die zweite zurückgibt. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den Argumenttyp anzugeben.

Syntax

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

Parameter

Arg
Der Typ der Argumente und des Rückgabewerts.

Elementfunktionen

Typendefinition	Beschreibung
`delegate_type`	Der Typ des generischen Delegaten.
`first_argument_type`	Der Typ des ersten Arguments des Functors.
`result_type`	Der Typ des Functorergebnisses.
`second_argument_type`	Der Typ des zweiten Arguments des Functors.

Member	Beschreibung
`multiplies`	Erstellt den Functor.

Operator	Beschreibung
`operator()`	Berechnet die gewünschte Funktion.
`operator delegate_type^`	Wandelt den Functor in eine Stellvertretung um.

Hinweise

Die Vorlagenklasse beschreibt einen Zwei-Argument-Functor. Er definiert den Memberoperator operator() , sodass beim Aufrufen des Objekts als Funktion das erste Argument beim zweiten Argument zurückgegeben wird.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.

Beispiel

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

Die Vorlagenklasse beschreibt einen Functor, der, wenn sie aufgerufen wird, das Argument negiert zurückgibt. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den Argumenttyp anzugeben.

Syntax

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

Parameter

Arg
Der Typ der Argumente.

Elementfunktionen

Typendefinition	Beschreibung
`argument_type`	Der Typ des Functor-Arguments.
`delegate_type`	Der Typ des generischen Delegaten.
`result_type`	Der Typ des Functorergebnisses.

Member	Beschreibung
`negate`	Erstellt den Functor.

Operator	Beschreibung
`operator()`	Berechnet die gewünschte Funktion.
`operator delegate_type^`	Wandelt den Functor in eine Stellvertretung um.

Hinweise

Die Vorlagenklasse beschreibt einen Ein-Argument-Functor. Er definiert den Memberoperator operator() , sodass, wenn das Objekt als Funktion aufgerufen wird, sein Argument negiert zurückgibt.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.

Beispiel

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

Die Vorlagenklasse beschreibt einen Functor, der, wenn sie aufgerufen wird, nur true zurückgibt, wenn das erste Argument nicht gleich dem zweiten ist. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den Argumenttyp anzugeben.

Syntax

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

Parameter

Arg
Der Typ der Argumente.

Elementfunktionen

Typendefinition	Beschreibung
`delegate_type`	Der Typ des generischen Delegaten.
`first_argument_type`	Der Typ des ersten Arguments des Functors.
`result_type`	Der Typ des Functorergebnisses.
`second_argument_type`	Der Typ des zweiten Arguments des Functors.

Member	Beschreibung
`not_equal_to`	Erstellt den Functor.

Operator	Beschreibung
`operator()`	Berechnet die gewünschte Funktion.
`operator delegate_type^`	Wandelt den Functor in eine Stellvertretung um.

Hinweise

Die Vorlagenklasse beschreibt einen Zwei-Argument-Functor. Er definiert den Memberoperator operator() , sodass das erste Argument, wenn das Objekt als Funktion aufgerufen wird, nur true zurückgibt, wenn das erste Argument nicht dem zweiten entspricht.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.

Beispiel

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

Generiert einen unary_negate für einen Functor.

Syntax

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

Vorlage Parameter

Fun
Der Typ des Functors.

Funktionsparameter

functor
Der Functor, der umbrochen werden soll.

Hinweise

Die Funktionsvorlage gibt zurück unary_negate<Fun>(functor). Sie verwenden es als bequeme Möglichkeit, einen Ein-Argument-Functor in einen Functor zu umschließen, der seine logische NOT liefert.

Beispiel

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

Generiert einen binary_negate für einen Functor.

Syntax

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

Vorlage Parameter

Fun
Der Typ des Functors.

Funktionsparameter

functor
Der Functor, der umbrochen werden soll.

Hinweise

Die Funktionsvorlage gibt zurück binary_negate<Fun>(functor). Sie verwenden es als bequeme Möglichkeit, einen Zwei-Argument-Functor in einen Functor zu umschließen, der seine logische NOT liefert.

Beispiel

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

Die Vorlagenklasse beschreibt einen Functor, der bei Aufruf das erste Argument plus die zweite zurückgibt. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den Argumenttyp anzugeben.

Syntax

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

Parameter

Arg
Der Typ der Argumente und des Rückgabewerts.

Elementfunktionen

Typendefinition	Beschreibung
`delegate_type`	Der Typ des generischen Delegaten.
`first_argument_type`	Der Typ des ersten Arguments des Functors.
`result_type`	Der Typ des Functorergebnisses.
`second_argument_type`	Der Typ des zweiten Arguments des Functors.

Member	Beschreibung
`plus`	Erstellt den Functor.

Operator	Beschreibung
`operator()`	Berechnet die gewünschte Funktion.
`operator delegate_type^`	Wandelt den Functor in eine Stellvertretung um.

Hinweise

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.

Beispiel

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

Die generische Klasse beschreibt einen 1-Argument-Delegaten. Sie verwenden ihn, um einen Delegat in Bezug auf das Argument und die Rückgabetypen anzugeben.

Syntax

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

Parameter

Arg
Der Typ des Arguments.

Result
Der Rückgabetyp.

Hinweise

Der generische Delegat beschreibt eine Ein-Argument-Funktion.

In diesen Funktionsvorlagen:

unary_delegate<int, int> Fun1;

unary_delegate<int, int> Fun2;

die Typen Fun1 und Fun2 Synonyme sind, während für:

delegate int Fun1(int);

delegate int Fun2(int);

sie sind nicht derselbe Typ.

Beispiel

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

Die generische Klasse beschreibt einen Ein-Argument-Delegaten, der zurückgegeben wird void. Sie verwenden ihn, um einen Delegat in Bezug auf den Argumenttyp anzugeben.

Syntax

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

Parameter

Arg
Der Typ des Arguments.

Hinweise

Der generische Delegat beschreibt eine Ein-Argument-Funktion, die zurückgegeben wird void.

In diesen Funktionsvorlagen:

unary_delegate_noreturn<int> Fun1;

unary_delegate_noreturn<int> Fun2;

die Typen Fun1 und Fun2 Synonyme sind, während für:

delegate void Fun1(int);

delegate void Fun2(int);

sie sind nicht derselbe Typ.

Beispiel

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

Die Vorlagenklasse beschreibt einen Functor, der, wenn sie aufgerufen wird, die logische NOT des gespeicherten Ein-Argument-Functors zurückgibt. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den gespeicherten Functor anzugeben.

Syntax

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

Parameter

Fun
Der Typ des gespeicherten Functors.

Elementfunktionen

Typendefinition	Beschreibung
`argument_type`	Der Typ des Functor-Arguments.
`delegate_type`	Der Typ des generischen Delegaten.
`result_type`	Der Typ des Functorergebnisses.

Member	Beschreibung
`unary_negate`	Erstellt den Functor.

Operator	Beschreibung
`operator()`	Berechnet die gewünschte Funktion.
`delegate_type^`	Wandelt den Functor in eine Stellvertretung um.

Hinweise

Die Vorlagenklasse beschreibt einen Ein-Argument-Functor, der einen anderen Ein-Argument-Functor speichert. Er definiert den Memberoperator operator() so, dass, wenn das Objekt als Funktion aufgerufen wird, die logische NOT des gespeicherten Functors zurückgibt, der mit dem Argument aufgerufen wird.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.

Beispiel

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

functional (STL/CLR)

Syntax

Requirements (Anforderungen)

Deklarationen

Member

binary_delegate (STL/CLR)

Syntax

Parameter

Hinweise

Beispiel

binary_delegate_noreturn (STL/CLR)

Syntax

Parameter

Hinweise

Beispiel

binary_negate (STL/CLR)

Syntax

Parameter

Elementfunktionen

Hinweise

Beispiel

bind1st (STL/CLR)

Syntax

Vorlage Parameter

Funktionsparameter

Hinweise

Beispiel

bind2nd (STL/CLR)

Syntax

Vorlage Parameter

Funktionsparameter

Hinweise

Beispiel

binder1st (STL/CLR)

Syntax

Parameter

Elementfunktionen

Hinweise

Beispiel

binder2nd (STL/CLR)

Syntax

Parameter

Elementfunktionen

Hinweise

Beispiel

divides (STL/CLR)

Syntax

Parameter

Elementfunktionen

Hinweise

Beispiel

equal_to (STL/CLR)

Syntax

Parameter

Elementfunktionen

Hinweise

Beispiel

greater (STL/CLR)

Syntax

Parameter

Elementfunktionen

Hinweise

Beispiel

greater_equal (STL/CLR)

Syntax

Parameter

Elementfunktionen

Hinweise

Beispiel

less (STL/CLR)

Syntax

Parameter

Elementfunktionen

Hinweise

Beispiel

less_equal (STL/CLR)

Syntax

Parameter

Elementfunktionen

Hinweise

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