functional (STL/CLR)

Schließen Sie den STL/CLR-Header ein <cliext/functional> , um eine Reihe von Vorlagenklassen und zugehörigen Vorlagen delegaten und Funktionen zu definieren.

Syntax

#include <functional>

Requirements (Anforderungen)

Header:< cliext/functional>

Namespace: cliext

Deklarationen

Delegat	BESCHREIBUNG
binary_delegate (STL/CLR)	Delegat mit zwei Argumenten.
binary_delegate_noreturn (STL/CLR)	Ein Delegat mit zwei Argumenten, der zurücksendet void.
unary_delegate (STL/CLR)	Ein-Argument-Delegat.
unary_delegate_noreturn (STL/CLR)	Ein-Argument-Delegat, der zurücksendet void.

Klasse	BESCHREIBUNG
binary_negate (STL/CLR)	Funktor zum Negieren eines Funktors mit zwei Argumenten.
binder1st (STL/CLR)	Funktor zum Binden des ersten Arguments an einen Funktor mit zwei Argumenten.
binder2nd (STL/CLR)	Funktor zum Binden des zweiten Arguments an einen Zwei-Argument-Funktor.
divides (STL/CLR)	Dividieren des Funktors.
equal_to (STL/CLR)	Gleichheitsvergleichs-Funktor.
greater (STL/CLR)	Größerer Vergleichstrichter.
greater_equal (STL/CLR)	Vergleichstrichter größer oder gleich.
less (STL/CLR)	Weniger Vergleichstrichter.
less_equal (STL/CLR)	Kleiner oder gleicher Vergleichstrichter.
logical_and (STL/CLR)	Logischer AND-Funktor.
logical_not (STL/CLR)	Logischer NOT-Funktor.
logical_or (STL/CLR)	Logischer OR-Funktor.
minus (STL/CLR)	Subtrahieren Sie den Funktor.
modulus (STL/CLR)	Modulus-Funktor.
multiplies (STL/CLR)	Multiplizieren des Funktors.
negate (STL/CLR)	Functor zum Zurückgeben des Arguments negiert.
not_equal_to (STL/CLR)	Vergleichstrichter nicht gleich.
plus (STL/CLR)	Fügen Sie functor hinzu.
unary_negate (STL/CLR)	Funktor zum Negieren eines Funktors mit einem Argument.

Funktion	BESCHREIBUNG
bind1st (STL/CLR)	Generiert einen binder1st für ein Argument und einen Funktor.
bind2nd (STL/CLR)	Generiert einen binder2nd für ein Argument und einen Funktor.
not1 (STL/CLR)	Generiert eine unary_negate für einen Funktor.
not2 (STL/CLR)	Generiert eine binary_negate für einen Funktor.

Member

binary_delegate (STL/CLR)

Die generetische Klasse beschreibt einen Delegaten mit zwei Argumenten. Sie verwenden sie, um einen Delegaten 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.

Ergebnis
Der Rückgabetyp.

Hinweise

Der generetische Delegat beschreibt eine Funktion mit zwei Argumenten.

Beachten Sie, dass für:

binary_delegate<int, int, int> Fun1;

binary_delegate<int, int, int> Fun2;

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

delegate int Fun1(int, int);

delegate int Fun2(int, int);

sie sind nicht vom gleichen 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 generetische Klasse beschreibt einen Delegaten mit zwei Argumenten, der zurückgibt void. Sie verwenden sie, um einen Delegaten 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 generetische Delegat beschreibt eine Funktion mit zwei Argumenten, die zurückgibt void.

Beachten Sie, dass für:

binary_delegate_noreturn<int, int> Fun1;

binary_delegate_noreturn<int, int> Fun2;

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

delegate void Fun1(int, int);

delegate void Fun2(int, int);

sie sind nicht der gleiche 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 Funktor, der beim Aufruf den logischen NOT-Wert des gespeicherten Funktors mit zwei Argumenten zurückgibt. Sie verwenden es, um ein Funktionsobjekt in Bezug auf seinen gespeicherten Funktor 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 Funktors.

Elementfunktionen

Typendefinition	Beschreibung
delegate_type	Der Typ des generischen Delegaten.
first_argument_type	Der Typ des ersten Funktorarguments.
Result_type	Der Typ des Funktorergebnisses.
second_argument_type	Der Typ des zweiten Funktorarguments.
stored_function_type	Der Typ des Funktors.

Member	BESCHREIBUNG
binary_negate	Erstellt den Funktor.

Operator	BESCHREIBUNG
Operator()	Berechnet die gewünschte Funktion.
operator delegate_type^()	Gibt den Funktor in einen Delegaten um.

Hinweise

Die Vorlagenklasse beschreibt einen Funktor mit zwei Argumenten, der einen weiteren Zweiargument-Funktor speichert. Er definiert den Memberoperator operator() , sodass beim Aufruf des Objekts als Funktion das logische NOT des gespeicherten Funktors zurückgegeben wird, der mit den beiden Argumenten aufgerufen wird.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ ist delegate_type^ und 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);
    }

4 3
4 4
1 0
1 0

bind1st (STL/CLR)

Generiert einen binder1st für ein Argument und einen Funktor.

Syntax

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

Vorlagenparameter

Arg
Der Typ des Arguments.

Fun
Der Typ des Funktors.

Funktionsparameter

Functor
Der zu umschließende Funktor.

left
Das erste zu umschließende Argument.

Hinweise

Die Vorlagenfunktion gibt binder1st (STL/CLR)<Fun>(functor, left) zurück. Sie verwenden ihn als praktische Möglichkeit, einen Funktor mit zwei Argumenten und sein erstes Argument in einen 1-Argument-Funktor zu umschließ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 einen binder2nd für ein Argument und einen Funktor.

Syntax

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

Vorlagenparameter

Arg
Der Typ des Arguments.

Fun
Der Typ des Funktors.

Funktionsparameter

Functor
Der zu umschließende Funktor.

right
Das zweite zu umschließende Argument.

Hinweise

Die Vorlagenfunktion gibt binder2nd (STL/CLR)<Fun>(functor, right) zurück. Sie verwenden ihn als praktische Möglichkeit, einen Funktor mit zwei Argumenten und sein zweites Argument in einem 1-Argument-Funktor zu umschließ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 1-Argument-Funktor, der beim Aufruf seinen gespeicherten Funktor mit zwei Argumenten zurückgibt, der mit dem gespeicherten ersten Argument und dem angegebenen zweiten Argument aufgerufen wird. Sie verwenden es, um ein Funktionsobjekt in Bezug auf seinen gespeicherten Funktor 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 Funktors.

Elementfunktionen

Typendefinition	Beschreibung
delegate_type	Der Typ des generischen Delegaten.
first_argument_type	Der Typ des ersten Funktorarguments.
Result_type	Der Typ des Funktorergebnisses.
second_argument_type	Der Typ des zweiten Funktorarguments.
stored_function_type	Der Typ des Funktors.

Member	BESCHREIBUNG
binder1st	Erstellt den Funktor.

Operator	BESCHREIBUNG
Operator()	Berechnet die gewünschte Funktion.
operator delegate_type^()	Casts the functor to a delegate.

Hinweise

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

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ ist delegate_type^ und 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 1-Argument-Funktor, der beim Aufgerufenen seinen gespeicherten Zwei-Argument-Funktor mit dem angegebenen ersten Argument und dem gespeicherten zweiten Argument zurückgibt. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den gespeicherten Funktor 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 Funktors.

Elementfunktionen

Typendefinition	Beschreibung
delegate_type	Der Typ des generischen Delegaten.
first_argument_type	Der Typ des ersten Funktorarguments.
Result_type	Der Typ des Funktorergebnis.
second_argument_type	Der Typ des zweiten Funktorarguments.
stored_function_type	Der Typ des Funktors.

Member	BESCHREIBUNG
binder2nd	Erstellt den Funktor.

Operator	BESCHREIBUNG
Operator()	Berechnet die gewünschte Funktion.
operator delegate_type^()	Casts the functor to a delegate.

Hinweise

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

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ ist delegate_type^ und 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 Funktor, der beim Aufgerufenen das erste Argument dividiert durch das zweite argument zurückgibt. Sie verwenden es, um ein Funktionsobjekt in Bezug auf seinen 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 Funktorarguments.
Result_type	Der Typ des Funktorergebnis.
second_argument_type	Der Typ des zweiten Funktorarguments.

Member	BESCHREIBUNG
divides	Erstellt den Funktor.

Operator	BESCHREIBUNG
Operator()	Berechnet die gewünschte Funktion.
operator delegate_type^()	Casts the functor to a delegate.

Hinweise

Die Vorlagenklasse beschreibt einen Funktor mit zwei Argumenten. Er definiert den Memberoperator operator() so, dass beim Aufgerufen des Objekts als Funktion das erste Argument dividiert durch das zweite argument zurückgegeben wird.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ ist delegate_type^ und 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 Funktor, der beim Aufgerufenen nur TRUE zurückgibt, wenn das erste Argument gleich dem zweiten ist. Sie verwenden es, um ein Funktionsobjekt in Bezug auf seinen 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 Funktorarguments.
Result_type	Der Typ des Funktorergebnis.
second_argument_type	Der Typ des zweiten Funktorarguments.

Member	BESCHREIBUNG
equal_to	Erstellt den Funktor.

Operator	BESCHREIBUNG
Operator()	Berechnet die gewünschte Funktion.
operator delegate_type^()	Casts the functor to a delegate.

Hinweise

Die Vorlagenklasse beschreibt einen Funktor mit zwei Argumenten. Er definiert den Memberoperator operator() so, dass das Objekt beim Aufgerufen als Funktion nur dann TRUE zurückgibt, wenn das erste Argument gleich dem zweiten ist.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ ist delegate_type^ und 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 Funktor, der beim Aufgerufenen nur TRUE zurückgibt, wenn das erste Argument größer als das zweite ist. Sie verwenden es, um ein Funktionsobjekt in Bezug auf seinen 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 Funktorarguments.
Result_type	Der Typ des Funktorergebnis.
second_argument_type	Der Typ des zweiten Funktorarguments.

Member	BESCHREIBUNG
greater	Erstellt den Funktor.

Operator	BESCHREIBUNG
Operator()	Berechnet die gewünschte Funktion.
operator delegate_type^	Casts the functor to a delegate.

Hinweise

Die Vorlagenklasse beschreibt einen Funktor mit zwei Argumenten. Sie definiert den Memberoperator operator() so, dass das Objekt beim Aufgerufen als Funktion nur dann TRUE zurückgibt, wenn das erste Argument größer als das zweite ist.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ ist delegate_type^ und 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 Funktor, der beim Aufgerufenen nur TRUE zurückgibt, wenn das erste Argument größer oder gleich dem zweiten argument ist. Sie verwenden es, um ein Funktionsobjekt in Bezug auf seinen 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 Funktorarguments.
Result_type	Der Typ des Funktorergebnis.
second_argument_type	Der Typ des zweiten Funktorarguments.

Member	BESCHREIBUNG
greater_equal	Erstellt den Funktor.

Operator	BESCHREIBUNG
Operator()	Berechnet die gewünschte Funktion.
operator delegate_type^	Casts the functor to a delegate.

Hinweise

Die Vorlagenklasse beschreibt einen Funktor mit zwei Argumenten. Sie definiert den Memberoperator operator() so, dass das Objekt beim Aufgerufen als Funktion nur dann TRUE zurückgibt, wenn das erste Argument größer oder gleich dem zweiten argument ist.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ ist delegate_type^ und 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 Funktor, der beim Aufgerufenen nur TRUE zurückgibt, wenn das erste Argument kleiner als das zweite argument ist. Sie verwenden es, um ein Funktionsobjekt in Bezug auf seinen 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 Funktorarguments.
Result_type	Der Typ des Funktorergebnis.
second_argument_type	Der Typ des zweiten Funktorarguments.

Member	BESCHREIBUNG
less	Erstellt den Funktor.

Operator	BESCHREIBUNG
Operator()	Berechnet die gewünschte Funktion.
operator delegate_type^	Casts the functor to a delegate.

Hinweise

Die Vorlagenklasse beschreibt einen Funktor mit zwei Argumenten. Sie definiert den Memberoperator operator() so, dass das Objekt beim Aufgerufen als Funktion nur dann TRUE zurückgibt, wenn das erste Argument kleiner als das zweite argument ist.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ ist delegate_type^ und 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 Funktor, der beim Aufgerufenen nur TRUE zurückgibt, wenn das erste Argument kleiner oder gleich dem zweiten argument ist. Sie verwenden es, um ein Funktionsobjekt in Bezug auf seinen 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 Funktorarguments.
Result_type	Der Typ des Funktorergebnis.
second_argument_type	Der Typ des zweiten Funktorarguments.

Member	BESCHREIBUNG
less_equal	Erstellt den Funktor.

Operator	BESCHREIBUNG
Operator()	Berechnet die gewünschte Funktion.
operator delegate_type^	Casts the functor to a delegate.

Hinweise

Die Vorlagenklasse beschreibt einen Funktor mit zwei Argumenten. Sie definiert den Memberoperator operator() so, dass das Objekt beim Aufgerufen als Funktion nur dann TRUE zurückgibt, wenn das erste Argument kleiner oder gleich dem zweiten argument ist.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ ist delegate_type^ und 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 Funktor, der beim Aufgerufenen nur dann TRUE zurückgibt, wenn sowohl das erste Argument als auch der zweite Test als true gilt. Sie verwenden es, um ein Funktionsobjekt in Bezug auf seinen 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 Funktorarguments.
Result_type	Der Typ des Funktorergebnis.
second_argument_type	Der Typ des zweiten Funktorarguments.

Member	BESCHREIBUNG
logical_and	Erstellt den Funktor.

Operator	BESCHREIBUNG
Operator()	Berechnet die gewünschte Funktion.
operator delegate_type^	Casts the functor to a delegate.

Hinweise

Die Vorlagenklasse beschreibt einen Funktor mit zwei Argumenten. Sie definiert den Memberoperator operator() so, dass das -Objekt beim Aufgerufen als Funktion nur dann TRUE zurückgibt, wenn sowohl das erste Argument als auch der zweite Test als true festgelegt sind.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ ist delegate_type^ und 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 Funktor, der beim Aufgerufenen nur TRUE zurückgibt, wenn eines der Argumente als false testet. Sie verwenden es, um ein Funktionsobjekt in Bezug auf seinen 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 Funktorarguments.
delegate_type	Der Typ des generischen Delegaten.
Result_type	Der Typ des Funktorergebnis.

Member	BESCHREIBUNG
logical_not	Erstellt den Funktor.

Operator	BESCHREIBUNG
Operator()	Berechnet die gewünschte Funktion.
operator delegate_type^	Casts the functor to a delegate.

Hinweise

Die Vorlagenklasse beschreibt einen Funktor mit einem Argument. Sie definiert den Memberoperator operator() so, dass das Objekt beim Aufgerufen als Funktion nur dann TRUE zurückgibt, wenn das Argument als FALSE testet.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ ist delegate_type^ und 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 Funktor, der beim Aufgerufenen nur dann TRUE zurückgibt, wenn entweder das erste Argument oder das zweite als true testet. Sie verwenden es, um ein Funktionsobjekt in Bezug auf seinen 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 Funktorarguments.
Result_type	Der Typ des Funktorergebnis.
second_argument_type	Der Typ des zweiten Funktorarguments.

Member	BESCHREIBUNG
logical_or	Erstellt den Funktor.

Operator	BESCHREIBUNG
Operator()	Berechnet die gewünschte Funktion.
operator delegate_type^	Casts the functor to a delegate.

Hinweise

Die Vorlagenklasse beschreibt einen Funktor mit zwei Argumenten. Er definiert den Memberoperator operator() so, dass das Objekt beim Aufgerufen als Funktion nur dann TRUE zurückgibt, wenn entweder das erste Argument oder das zweite als TRUE testet.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ ist delegate_type^ und 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 Funktor, der beim Aufgerufenen das erste Argument abzüglich des zweiten zurückgibt. Sie verwenden es, um ein Funktionsobjekt in Bezug auf seinen 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 Funktorarguments.
Result_type	Der Typ des Funktorergebnis.
second_argument_type	Der Typ des zweiten Funktorarguments.

Member	BESCHREIBUNG
minus	Erstellt den Funktor.

Operator	BESCHREIBUNG
Operator()	Berechnet die gewünschte Funktion.
operator delegate_type^	Casts the functor to a delegate.

Hinweise

Die Vorlagenklasse beschreibt einen Funktor mit zwei Argumenten. Er definiert den Memberoperator operator() so, dass das erste Argument abzüglich des zweiten zurückgegeben wird, wenn das Objekt als Funktion aufgerufen wird.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ ist delegate_type^ und 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 Funktor, der beim Aufgerufenen das erste Argumentmodulo des zweiten zurückgibt. Sie verwenden es, um ein Funktionsobjekt in Bezug auf seinen 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 Funktorarguments.
Result_type	Der Typ des Funktorergebnis.
second_argument_type	Der Typ des zweiten Funktorarguments.

Member	BESCHREIBUNG
modulus	Erstellt den Funktor.

Operator	BESCHREIBUNG
Operator()	Berechnet die gewünschte Funktion.
operator delegate_type^	Casts the functor to a delegate.

Hinweise

Die Vorlagenklasse beschreibt einen Funktor mit zwei Argumenten. Sie definiert den Memberoperator operator() so, dass das erste Argumentmodulo zurückgegeben wird, wenn das Objekt als Funktion aufgerufen wird.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ ist delegate_type^ und 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 Funktor, der beim Aufruf das erste Argument mal das zweite Argument zurückgibt. Sie verwenden es, um ein Funktionsobjekt in Bezug auf seinen 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 Funktorarguments.
Result_type	Der Typ des Funktorergebnisses.
second_argument_type	Der Typ des zweiten Funktorarguments.

Member	BESCHREIBUNG
multiplies	Erstellt den Funktor.

Operator	BESCHREIBUNG
Operator()	Berechnet die gewünschte Funktion.
operator delegate_type^	Gibt den Funktor in einen Delegaten um.

Hinweise

Die Vorlagenklasse beschreibt einen Funktor mit zwei Argumenten. Er definiert den Memberoperator operator() , sodass beim Aufruf des Objekts als Funktion das erste Argument mal das zweite Argument zurückgegeben wird.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ ist delegate_type^ und 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 Funktor, der beim Aufruf das argument negiert zurückgibt. Sie verwenden es, um ein Funktionsobjekt in Bezug auf seinen 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 Funktorarguments.
delegate_type	Der Typ des generischen Delegaten.
Result_type	Der Typ des Funktorergebnisses.

Member	BESCHREIBUNG
negate	Erstellt den Funktor.

Operator	BESCHREIBUNG
Operator()	Berechnet die gewünschte Funktion.
operator delegate_type^	Gibt den Funktor in einen Delegaten um.

Hinweise

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

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ ist delegate_type^ und 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 Funktor, der beim Aufruf nur dann TRUE zurückgibt, wenn das erste Argument ungleich dem zweiten argument ist. Sie verwenden es, um ein Funktionsobjekt in Bezug auf seinen 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 Funktorarguments.
Result_type	Der Typ des Funktorergebnisses.
second_argument_type	Der Typ des zweiten Funktorarguments.

Member	BESCHREIBUNG
not_equal_to	Erstellt den Funktor.

Operator	BESCHREIBUNG
Operator()	Berechnet die gewünschte Funktion.
operator delegate_type^	Gibt den Funktor in einen Delegaten um.

Hinweise

Die Vorlagenklasse beschreibt einen Funktor mit zwei Argumenten. Er definiert den Memberoperator operator() , sodass beim Aufruf des Objekts als Funktion nur true zurückgegeben wird, wenn das erste Argument ungleich dem zweiten argument ist.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ ist delegate_type^ und 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 Funktor.

Syntax

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

Vorlagenparameter

Fun
Der Typ des Funktors.

Funktionsparameter

Functor
Der zu umschließende Funktor.

Hinweise

Die Vorlagenfunktion gibt unary_negate (STL/CLR) zurück<Fun>(functor). Sie verwenden es als praktische Möglichkeit, einen Funktor mit einem Argument in einen Funktor zu umschließen, der sein logisches 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 Funktor.

Syntax

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

Vorlagenparameter

Fun
Der Typ des Funktors.

Funktionsparameter

Functor
Der zu umschließende Funktor.

Hinweise

Die Vorlagenfunktion gibt binary_negate (STL/CLR) zurück<Fun>(functor). Sie verwenden es als praktische Möglichkeit, einen Zwei-Argument-Funktor in einen Funktor zu umschließen, der sein logisches 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);
    }

4 3
4 4
1 0
1 0

plus (STL/CLR)

Die Vorlagenklasse beschreibt einen Funktor, der beim Aufgerufenen das erste Argument plus das zweite zurückgibt. Sie verwenden es, um ein Funktionsobjekt in Bezug auf seinen 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 Funktorarguments.
Result_type	Der Typ des Funktorergebnis.
second_argument_type	Der Typ des zweiten Funktorarguments.

Member	BESCHREIBUNG
plus	Erstellt den Funktor.

Operator	BESCHREIBUNG
Operator()	Berechnet die gewünschte Funktion.
operator delegate_type^	Casts the functor to a delegate.

Hinweise

Die Vorlagenklasse beschreibt einen Funktor mit zwei Argumenten. Sie definiert den Memberoperator operator() , sodass das erste Argument plus das zweite argument zurückgegeben wird, wenn das Objekt als Funktion aufgerufen wird.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ ist delegate_type^ und 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 generetische Klasse beschreibt einen Delegaten mit einem Argument. Sie verwenden sie, um einen Delegaten 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.

Ergebnis
Der Rückgabetyp.

Hinweise

Der generetische Delegat beschreibt eine Funktion mit einem Argument.

Beachten Sie, dass für:

unary_delegare<int, int> Fun1;

unary_delegare<int, int> Fun2;

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

delegate int Fun1(int);

delegate int Fun2(int);

sie sind nicht vom gleichen 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 generetische Klasse beschreibt einen Delegaten mit einem Argument, der zurückgibt void. Sie verwenden sie, um einen Delegaten in Bezug auf den Argumenttyp anzugeben.

Syntax

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

Parameter

Arg
Der Typ des Arguments.

Hinweise

Der generetische Delegat beschreibt eine Funktion mit einem Argument, die zurückgibt void.

Beachten Sie, dass für:

unary_delegare_noreturn<int> Fun1;

unary_delegare_noreturn<int> Fun2;

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

delegate void Fun1(int);

delegate void Fun2(int);

sie sind nicht vom gleichen 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 Funktor, der beim Aufgerufenen die logische NOT des gespeicherten 1-Argument-Funktors zurückgibt. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den gespeicherten Funktor 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 Funktors.

Elementfunktionen

Typendefinition	Beschreibung
argument_type	Der Typ des Funktorarguments.
delegate_type	Der Typ des generischen Delegaten.
Result_type	Der Typ des Funktorergebnisses.

Member	BESCHREIBUNG
unary_negate	Erstellt den Funktor.

Operator	BESCHREIBUNG
Operator()	Berechnet die gewünschte Funktion.
delegate_type^	Gibt den Funktor in einen Delegaten um.

Hinweise

Die Vorlagenklasse beschreibt einen 1-Argument-Funktor, der einen anderen Einargument-Funktor speichert. Er definiert den Memberoperator operator() , sodass beim Aufruf des Objekts als Funktion das logische NOT des gespeicherten Funktors zurückgegeben wird, der mit dem Argument aufgerufen wird.

Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ ist delegate_type^ und 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