functional (STL/CLR)

Adja meg az STL/CLR fejlécet <cliext/functional> a funkcionális osztálysablonok, valamint a kapcsolódó sablondelegáltak és függvények definiálásához.

Szemantika

#include <functional>

Követelmények

Fejléc:<cliext/functional>

Névtér:cliext

Nyilatkozatok

Képviselő	Leírás
binary_delegate (STL/CLR)	Kétargumentumos delegált.
binary_delegate_noreturn (STL/CLR)	Kétargumentumos delegált visszatérése void.
unary_delegate (STL/CLR)	Egyargumentumos delegált.
unary_delegate_noreturn (STL/CLR)	Egyargumentumos delegált visszatérése void.

Osztály	Leírás
binary_negate (STL/CLR)	Functor, hogy negate a két argumentum funktor.
binder1st (STL/CLR)	A Functor az első argumentumot egy kétargumentumos funktorhoz köti.
binder2nd (STL/CLR)	A Functor a második argumentumot egy kétargumentumos funktorhoz köti.
divides (STL/CLR)	Oszd el a funktort.
equal_to (STL/CLR)	Egyenlő összehasonlító funktor.
greater (STL/CLR)	Nagyobb összehasonlító funktor.
greater_equal (STL/CLR)	Nagyobb vagy egyenlő összehasonlítási funktor.
less (STL/CLR)	Kevésbé összehasonlító funktor.
less_equal (STL/CLR)	Kisebb vagy egyenlő összehasonlítási funktor.
logical_and (STL/CLR)	Logikai ÉS funktor.
logical_not (STL/CLR)	Logikai NOT funktor.
logical_or (STL/CLR)	Logikai vagy funktor.
minus (STL/CLR)	Kivonási funktor.
modulus (STL/CLR)	Modulus funktor.
multiplies (STL/CLR)	Szorozza meg a funktort.
negate (STL/CLR)	Functor, hogy visszaadja az argumentumát negated.
not_equal_to (STL/CLR)	Nem egyenlő összehasonlító funktor.
plus (STL/CLR)	Adja hozzá a funktort.
unary_negate (STL/CLR)	Functor egy egyargumentumos funktor tagadásához.

Funkció	Leírás
bind1st (STL/CLR)	Létrehoz egy kötést1st argumentumhoz és funktorhoz.
bind2nd (STL/CLR)	Létrehoz egy kötést2nd egy argumentumhoz és egy funktorhoz.
not1 (STL/CLR)	Létrehoz egy unary_negate egy funktorhoz.
not2 (STL/CLR)	Létrehoz egy binary_negate egy funktorhoz.

Tagok

binary_delegate (STL/CLR)

Az általános osztály egy kétargumentumos delegáltat ír le. A használatával meg kell adnia egy meghatalmazottat az argumentum és a visszatérési típusok szempontjából.

Szemantika

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

Paraméterek

Arg1
Az első argumentum típusa.

Arg2
A második argumentum típusa.

Result
A visszatérési típus.

Megjegyzések

Az általános delegált egy kétargumentumos függvényt ír le.

Ezekben a függvénysablonokban:

binary_delegate<int, int, int> Fun1;

binary_delegate<int, int, int> Fun2;

típusok Fun1 és Fun2 szinonimák, míg a következőhöz:

delegate int Fun1(int, int);

delegate int Fun2(int, int);

nem azonos típusúak.

példa

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

Az általános osztály a visszaadott kétargumentumos delegáltat voidírja le. A használatával meg kell adnia egy meghatalmazottat az argumentuma szempontjából.

Szemantika

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

Paraméterek

Arg1
Az első argumentum típusa.

Arg2
A második argumentum típusa.

Megjegyzések

Az általános delegált egy kétargumentumos függvényt ír le, amely visszaadja a függvényt void.

Ezekben a függvénysablonokban:

binary_delegate_noreturn<int, int> Fun1;

binary_delegate_noreturn<int, int> Fun2;

típusok Fun1 és Fun2 szinonimák, míg a következőhöz:

delegate void Fun1(int, int);

delegate void Fun2(int, int);

nem azonos típusúak.

példa

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

A sablonosztály egy funktort ír le, amely meghívásakor a tárolt kétargumentumos funktor logikai NOT értékét adja vissza. A használatával függvényobjektumot adhat meg a tárolt funktor szempontjából.

Szemantika

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

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

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

Paraméterek

Fun
A tárolt funktor típusa.

Tagfüggvények

Típusdefiníció	Leírás
delegate_type	Az általános meghatalmazott típusa.
first_argument_type	A funktor első argumentumának típusa.
result_type	A funktor eredményének típusa.
second_argument_type	A funktor második argumentumának típusa.
stored_function_type	A funktor típusa.

Tag	Leírás
binary_negate	Felépíti a funktort.

Operátor	Leírás
operator()	Kiszámítja a kívánt függvényt.
operator delegate_type^()	A funktort egy meghatalmazottra veti.

Megjegyzések

A sablonosztály egy két argumentumból álló funktort ír le, amely egy másik kétargumentumos funktort tárol. A tag operátort operator() úgy határozza meg, hogy amikor az objektumot függvényként hívják, a két argumentummal meghívott tárolt funktor logikai NOT értékét adja vissza.

Az objektumot olyan függvényargumentumként is átadhatja, amelynek típusa és delegate_type^ megfelelő konvertálása megtörténik.

példa

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

Argumentumot binder1st és funktort hoz létre.

Szemantika

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

Sablonparaméterek

Arg
Az argumentum típusa.

Fun
A funktor típusa.

Függvényparaméterek

functor
A funktor, amit be kell törni.

left
A sortörés első argumentuma.

Megjegyzések

A függvénysablon visszaadja a következőt binder1st<Fun>(functor, left): . Ezzel kényelmesen körbefuttathat egy kétargumentumos funktort és annak első argumentumát egy olyan egyargumentumos funktorban, amely második argumentummal hívja meg.

példa

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

Argumentumot binder2nd és funktort hoz létre.

Szemantika

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

Sablonparaméterek

Arg
Az argumentum típusa.

Fun
A funktor típusa.

Függvényparaméterek

functor
A funktor, amit be kell törni.

right
A második sortöréshez használt argumentum.

Megjegyzések

A függvénysablon visszaadja a következőt binder2nd<Fun>(functor, right): . Ezzel kényelmesen körbefuttathat egy kétargumentumos funktort és annak második argumentumát egy olyan egyargumentumos funktorban, amely első argumentummal hívja meg.

példa

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

A sablonosztály egy egyargumentumos funktort ír le, amely meghívásakor a tárolt kétargumentumos funktort a tárolt első argumentummal és a megadott második argumentummal adja vissza. A használatával függvényobjektumot adhat meg a tárolt funktor szempontjából.

Szemantika

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

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

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

Paraméterek

Fun
A tárolt funktor típusa.

Tagfüggvények

Típusdefiníció	Leírás
delegate_type	Az általános meghatalmazott típusa.
first_argument_type	A funktor első argumentumának típusa.
result_type	A funktor eredményének típusa.
second_argument_type	A funktor második argumentumának típusa.
stored_function_type	A funktor típusa.

Tag	Leírás
binder1st	Felépíti a funktort.

Operátor	Leírás
operator()	Kiszámítja a kívánt függvényt.
operator delegate_type^()	A funktort egy meghatalmazottra veti.

Megjegyzések

A sablonosztály egy egyargumentumos funktort ír le, amely egy kétargumentumos funktort és egy első argumentumot tárol. A tagoperátort operator() úgy határozza meg, hogy amikor az objektumot függvényként hívja meg, a tárolt funktor meghívásának eredményét adja vissza a tárolt első argumentummal és a megadott második argumentummal.

Az objektumot olyan függvényargumentumként is átadhatja, amelynek típusa és delegate_type^ megfelelő konvertálása megtörténik.

példa

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

A sablonosztály egy egyargumentumos funktort ír le, amely meghíváskor a megadott első argumentummal és a tárolt második argumentummal visszaadja a tárolt kétargumentumos funktort. A használatával függvényobjektumot adhat meg a tárolt funktor szempontjából.

Szemantika

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

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

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

Paraméterek

Fun
A tárolt funktor típusa.

Tagfüggvények

Típusdefiníció	Leírás
delegate_type	Az általános meghatalmazott típusa.
first_argument_type	A funktor első argumentumának típusa.
result_type	A funktor eredményének típusa.
second_argument_type	A funktor második argumentumának típusa.
stored_function_type	A funktor típusa.

Tag	Leírás
binder2nd	Felépíti a funktort.

Operátor	Leírás
operator()	Kiszámítja a kívánt függvényt.
operator delegate_type^()	A funktort egy meghatalmazottra veti.

Megjegyzések

A sablonosztály egy egyargumentumos funktort ír le, amely egy kétargumentumos funktort és egy második argumentumot tárol. A tag operátort operator() úgy határozza meg, hogy amikor az objektumot függvényként hívja meg, a tárolt funktor meghívásának eredményét adja vissza a megadott első argumentummal és a tárolt második argumentummal.

Az objektumot olyan függvényargumentumként is átadhatja, amelynek típusa és delegate_type^ megfelelő konvertálása megtörténik.

példa

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

A sablonosztály egy funktort ír le, amely meghívásakor az első argumentumot a másodikkal osztva adja vissza. Az argumentumtípus szempontjából függvényobjektumot ad meg.

Szemantika

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

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

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

Paraméterek

Arg
Az argumentumok típusa és a visszatérési érték.

Tagfüggvények

Típusdefiníció	Leírás
delegate_type	Az általános meghatalmazott típusa.
first_argument_type	A funktor első argumentumának típusa.
result_type	A funktor eredményének típusa.
second_argument_type	A funktor második argumentumának típusa.

Tag	Leírás
divides	Felépíti a funktort.

Operátor	Leírás
operator()	Kiszámítja a kívánt függvényt.
operator delegate_type^()	A funktort egy meghatalmazottra veti.

Megjegyzések

A sablonosztály egy kétargumentumos funktort ír le. A tag operátort operator() úgy határozza meg, hogy amikor az objektumot függvényként hívják, az első argumentumot a másodikkal osztva adja vissza.

Az objektumot olyan függvényargumentumként is átadhatja, amelynek típusa és delegate_type^ megfelelő konvertálása megtörténik.

példa

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

A sablonosztály egy funktort ír le, amely meghíváskor csak akkor ad vissza igaz értéket, ha az első argumentum egyenlő a második argumentumával. Az argumentumtípus szempontjából függvényobjektumot ad meg.

Szemantika

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

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

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

Paraméterek

Arg
Az argumentumok típusa.

Tagfüggvények

Típusdefiníció	Leírás
delegate_type	Az általános meghatalmazott típusa.
first_argument_type	A funktor első argumentumának típusa.
result_type	A funktor eredményének típusa.
second_argument_type	A funktor második argumentumának típusa.

Tag	Leírás
equal_to	Felépíti a funktort.

Operátor	Leírás
operator()	Kiszámítja a kívánt függvényt.
operator delegate_type^()	A funktort egy meghatalmazottra veti.

Megjegyzések

A sablonosztály egy kétargumentumos funktort ír le. A tag operátort operator() úgy határozza meg, hogy amikor az objektumot függvényként hívják, akkor csak akkor ad vissza igaz értéket, ha az első argumentum egyenlő a második argumentummal.

Az objektumot olyan függvényargumentumként is átadhatja, amelynek típusa és delegate_type^ megfelelő konvertálása megtörténik.

példa

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

A sablonosztály egy funktort ír le, amely meghíváskor csak akkor ad vissza igaz értéket, ha az első argumentum nagyobb, mint a második. Az argumentumtípus szempontjából függvényobjektumot ad meg.

Szemantika

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

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

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

Paraméterek

Arg
Az argumentumok típusa.

Tagfüggvények

Típusdefiníció	Leírás
delegate_type	Az általános meghatalmazott típusa.
first_argument_type	A funktor első argumentumának típusa.
result_type	A funktor eredményének típusa.
second_argument_type	A funktor második argumentumának típusa.

Tag	Leírás
greater	Felépíti a funktort.

Operátor	Leírás
operator()	Kiszámítja a kívánt függvényt.
operator delegate_type^	A funktort egy meghatalmazottra veti.

Megjegyzések

A sablonosztály egy kétargumentumos funktort ír le. A tag operátort operator() úgy határozza meg, hogy amikor az objektumot függvényként hívják, akkor csak akkor ad vissza igaz értéket, ha az első argumentum nagyobb, mint a második.

Az objektumot olyan függvényargumentumként is átadhatja, amelynek típusa és delegate_type^ megfelelő konvertálása megtörténik.

példa

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

A sablonosztály egy funktort ír le, amely meghíváskor csak akkor ad vissza igaz értéket, ha az első argumentum nagyobb vagy egyenlő a másodiknál. Az argumentumtípus szempontjából függvényobjektumot ad meg.

Szemantika

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

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

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

Paraméterek

Arg
Az argumentumok típusa.

Tagfüggvények

Típusdefiníció	Leírás
delegate_type	Az általános meghatalmazott típusa.
first_argument_type	A funktor első argumentumának típusa.
result_type	A funktor eredményének típusa.
second_argument_type	A funktor második argumentumának típusa.

Tag	Leírás
greater_equal	Felépíti a funktort.

Operátor	Leírás
operator()	Kiszámítja a kívánt függvényt.
operator delegate_type^	A funktort egy meghatalmazottra veti.

Megjegyzések

A sablonosztály egy kétargumentumos funktort ír le. A tag operátort operator() úgy határozza meg, hogy amikor az objektumot függvényként hívják, akkor csak akkor ad vissza igaz értéket, ha az első argumentum nagyobb vagy egyenlő a másodiknál.

Az objektumot olyan függvényargumentumként is átadhatja, amelynek típusa és delegate_type^ megfelelő konvertálása megtörténik.

példa

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

A sablonosztály egy funktort ír le, amely meghíváskor csak akkor ad vissza igaz értéket, ha az első argumentum kisebb, mint a második. Az argumentumtípus szempontjából függvényobjektumot ad meg.

Szemantika

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

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

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

Paraméterek

Arg
Az argumentumok típusa.

Tagfüggvények

Típusdefiníció	Leírás
delegate_type	Az általános meghatalmazott típusa.
first_argument_type	A funktor első argumentumának típusa.
result_type	A funktor eredményének típusa.
second_argument_type	A funktor második argumentumának típusa.

Tag	Leírás
less	Felépíti a funktort.

Operátor	Leírás
operator()	Kiszámítja a kívánt függvényt.
operator delegate_type^	A funktort egy meghatalmazottra veti.

Megjegyzések

A sablonosztály egy kétargumentumos funktort ír le. A tagoperátort operator() úgy határozza meg, hogy amikor az objektumot függvényként hívják, akkor csak akkor ad vissza igaz értéket, ha az első argumentum kisebb, mint a második.

Az objektumot olyan függvényargumentumként is átadhatja, amelynek típusa és delegate_type^ megfelelő konvertálása megtörténik.

példa

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

A sablonosztály egy funktort ír le, amely meghíváskor csak akkor ad vissza igaz értéket, ha az első argumentum kisebb vagy egyenlő a második argumentuméval. Az argumentumtípus szempontjából függvényobjektumot ad meg.

Szemantika

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

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

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

Paraméterek

Arg
Az argumentumok típusa.

Tagfüggvények

Típusdefiníció	Leírás
delegate_type	Az általános meghatalmazott típusa.
first_argument_type	A funktor első argumentumának típusa.
result_type	A funktor eredményének típusa.
second_argument_type	A funktor második argumentumának típusa.

Tag	Leírás
less_equal	Felépíti a funktort.

Operátor	Leírás
operator()	Kiszámítja a kívánt függvényt.
operator delegate_type^	A funktort egy meghatalmazottra veti.

Megjegyzések

A sablonosztály egy kétargumentumos funktort ír le. A tag operátort operator() úgy határozza meg, hogy amikor az objektumot függvényként hívják, akkor csak akkor ad vissza igaz értéket, ha az első argumentum kisebb vagy egyenlő a második argumentummal.

Az objektumot olyan függvényargumentumként is átadhatja, amelynek típusa és delegate_type^ megfelelő konvertálása megtörténik.

példa

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

A sablonosztály egy funktort ír le, amely meghíváskor csak akkor ad vissza igaz értéket, ha az első argumentum és a második teszt is igaz. Az argumentumtípus szempontjából függvényobjektumot ad meg.

Szemantika

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

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

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

Paraméterek

Arg
Az argumentumok típusa.

Tagfüggvények

Típusdefiníció	Leírás
delegate_type	Az általános meghatalmazott típusa.
first_argument_type	A funktor első argumentumának típusa.
result_type	A funktor eredményének típusa.
second_argument_type	A funktor második argumentumának típusa.

Tag	Leírás
logical_and	Felépíti a funktort.

Operátor	Leírás
operator()	Kiszámítja a kívánt függvényt.
operator delegate_type^	A funktort egy meghatalmazottra veti.

Megjegyzések

A sablonosztály egy kétargumentumos funktort ír le. A tagoperátort operator() úgy határozza meg, hogy amikor az objektumot függvényként hívják, akkor csak akkor ad vissza igaz értéket, ha az első argumentum és a második teszt is igaz.

Az objektumot olyan függvényargumentumként is átadhatja, amelynek típusa és delegate_type^ megfelelő konvertálása megtörténik.

példa

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

A sablonosztály egy funktort ír le, amely meghíváskor csak akkor ad vissza igaz értéket, ha bármelyik argumentuma hamisnak bizonyul. Az argumentumtípus szempontjából függvényobjektumot ad meg.

Szemantika

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

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

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

Paraméterek

Arg
Az argumentumok típusa.

Tagfüggvények

Típusdefiníció	Leírás
argument_type	A funktor argumentum típusa.
delegate_type	Az általános meghatalmazott típusa.
result_type	A funktor eredményének típusa.

Tag	Leírás
logical_not	Felépíti a funktort.

Operátor	Leírás
operator()	Kiszámítja a kívánt függvényt.
operator delegate_type^	A funktort egy meghatalmazottra veti.

Megjegyzések

A sablonosztály egy egyargumentumos funktort ír le. A tag operátort operator() úgy határozza meg, hogy amikor az objektumot függvényként hívják, akkor csak akkor ad vissza igaz értéket, ha az argumentuma hamisnak bizonyul.

Az objektumot olyan függvényargumentumként is átadhatja, amelynek típusa és delegate_type^ megfelelő konvertálása megtörténik.

példa

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

A sablonosztály egy funktort ír le, amely meghíváskor csak akkor ad vissza igaz értéket, ha az első argumentum vagy a második teszt igaz. Az argumentumtípus szempontjából függvényobjektumot ad meg.

Szemantika

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

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

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

Paraméterek

Arg
Az argumentumok típusa.

Tagfüggvények

Típusdefiníció	Leírás
delegate_type	Az általános meghatalmazott típusa.
first_argument_type	A funktor első argumentumának típusa.
result_type	A funktor eredményének típusa.
second_argument_type	A funktor második argumentumának típusa.

Tag	Leírás
logical_or	Felépíti a funktort.

Operátor	Leírás
operator()	Kiszámítja a kívánt függvényt.
operator delegate_type^	A funktort egy meghatalmazottra veti.

Megjegyzések

A sablonosztály egy kétargumentumos funktort ír le. A tag operátort operator() úgy határozza meg, hogy az objektum függvényként való meghívásakor csak akkor adja vissza az igaz értéket, ha az első argumentum vagy a második teszt igaz.

Az objektumot olyan függvényargumentumként is átadhatja, amelynek típusa és delegate_type^ megfelelő konvertálása megtörténik.

példa

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

A sablonosztály egy funktort ír le, amely meghíváskor az első argumentumot adja vissza a másodiktól mínusz. Az argumentumtípus szempontjából függvényobjektumot ad meg.

Szemantika

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

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

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

Paraméterek

Arg
Az argumentumok típusa és a visszatérési érték.

Tagfüggvények

Típusdefiníció	Leírás
delegate_type	Az általános meghatalmazott típusa.
first_argument_type	A funktor első argumentumának típusa.
result_type	A funktor eredményének típusa.
second_argument_type	A funktor második argumentumának típusa.

Tag	Leírás
minus	Felépíti a funktort.

Operátor	Leírás
operator()	Kiszámítja a kívánt függvényt.
operator delegate_type^	A funktort egy meghatalmazottra veti.

Megjegyzések

A sablonosztály egy kétargumentumos funktort ír le. A tag operátort operator() úgy határozza meg, hogy amikor az objektumot függvényként hívják, az első argumentumot adja vissza a másodiktól mínusz.

Az objektumot olyan függvényargumentumként is átadhatja, amelynek típusa és delegate_type^ megfelelő konvertálása megtörténik.

példa

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

A sablonosztály egy funktort ír le, amely meghívásakor az első argumentum modulo a másodikat adja vissza. Az argumentumtípus szempontjából függvényobjektumot ad meg.

Szemantika

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

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

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

Paraméterek

Arg
Az argumentumok típusa és a visszatérési érték.

Tagfüggvények

Típusdefiníció	Leírás
delegate_type	Az általános meghatalmazott típusa.
first_argument_type	A funktor első argumentumának típusa.
result_type	A funktor eredményének típusa.
second_argument_type	A funktor második argumentumának típusa.

Tag	Leírás
modulus	Felépíti a funktort.

Operátor	Leírás
operator()	Kiszámítja a kívánt függvényt.
operator delegate_type^	A funktort egy meghatalmazottra veti.

Megjegyzések

A sablonosztály egy kétargumentumos funktort ír le. A tag operátort operator() úgy határozza meg, hogy amikor az objektumot függvényként hívják, az első argumentum moduloját adja vissza a másodikhoz.

Az objektumot olyan függvényargumentumként is átadhatja, amelynek típusa és delegate_type^ megfelelő konvertálása megtörténik.

példa

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

A sablonosztály egy funktort ír le, amely meghívásakor az első argumentum a másodiknál többször jelenik meg. Az argumentumtípus szempontjából függvényobjektumot ad meg.

Szemantika

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

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

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

Paraméterek

Arg
Az argumentumok típusa és a visszatérési érték.

Tagfüggvények

Típusdefiníció	Leírás
delegate_type	Az általános meghatalmazott típusa.
first_argument_type	A funktor első argumentumának típusa.
result_type	A funktor eredményének típusa.
second_argument_type	A funktor második argumentumának típusa.

Tag	Leírás
multiplies	Felépíti a funktort.

Operátor	Leírás
operator()	Kiszámítja a kívánt függvényt.
operator delegate_type^	A funktort egy meghatalmazottra veti.

Megjegyzések

A sablonosztály egy kétargumentumos funktort ír le. A tagoperátort operator() úgy határozza meg, hogy amikor az objektumot függvényként hívja meg, az első argumentumot a másodiknál többször adja vissza.

Az objektumot olyan függvényargumentumként is átadhatja, amelynek típusa és delegate_type^ megfelelő konvertálása megtörténik.

példa

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

A sablonosztály egy olyan funktort ír le, amely meghíváskor az argumentumát érvénytelenítve adja vissza. Az argumentumtípus szempontjából függvényobjektumot ad meg.

Szemantika

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

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

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

Paraméterek

Arg
Az argumentumok típusa.

Tagfüggvények

Típusdefiníció	Leírás
argument_type	A funktor argumentum típusa.
delegate_type	Az általános meghatalmazott típusa.
result_type	A funktor eredményének típusa.

Tag	Leírás
negate	Felépíti a funktort.

Operátor	Leírás
operator()	Kiszámítja a kívánt függvényt.
operator delegate_type^	A funktort egy meghatalmazottra veti.

Megjegyzések

A sablonosztály egy egyargumentumos funktort ír le. A tag operátort operator() úgy határozza meg, hogy az objektum függvényként való meghívásakor negatott argumentumot adjon vissza.

Az objektumot olyan függvényargumentumként is átadhatja, amelynek típusa és delegate_type^ megfelelő konvertálása megtörténik.

példa

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

A sablonosztály egy funktort ír le, amely meghíváskor csak akkor ad vissza igaz értéket, ha az első argumentum nem egyenlő a második argumentumával. Az argumentumtípus szempontjából függvényobjektumot ad meg.

Szemantika

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

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

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

Paraméterek

Arg
Az argumentumok típusa.

Tagfüggvények

Típusdefiníció	Leírás
delegate_type	Az általános meghatalmazott típusa.
first_argument_type	A funktor első argumentumának típusa.
result_type	A funktor eredményének típusa.
second_argument_type	A funktor második argumentumának típusa.

Tag	Leírás
not_equal_to	Felépíti a funktort.

Operátor	Leírás
operator()	Kiszámítja a kívánt függvényt.
operator delegate_type^	A funktort egy meghatalmazottra veti.

Megjegyzések

A sablonosztály egy kétargumentumos funktort ír le. A tag operátort operator() úgy határozza meg, hogy amikor az objektumot függvényként hívják, akkor csak akkor ad vissza igaz értéket, ha az első argumentum nem egyenlő a második argumentummal.

Az objektumot olyan függvényargumentumként is átadhatja, amelynek típusa és delegate_type^ megfelelő konvertálása megtörténik.

példa

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

Létrehoz egy unary_negate funktort.

Szemantika

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

Sablonparaméterek

Fun
A funktor típusa.

Függvényparaméterek

functor
A funktor, amit be kell törni.

Megjegyzések

A függvénysablon visszaadja a következőt unary_negate<Fun>(functor): . Ezzel kényelmesen körbefuttathat egy egyargumentumos funktort egy olyan funktorban, amely a logikai NOT-t adja meg.

példa

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

Létrehoz egy binary_negate funktort.

Szemantika

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

Sablonparaméterek

Fun
A funktor típusa.

Függvényparaméterek

functor
A funktor, amit be kell törni.

Megjegyzések

A függvénysablon visszaadja a következőt binary_negate<Fun>(functor): . Ezzel kényelmesen körbefuttathat egy kétargumentumos funktort egy olyan funktorban, amely a logikai NOT-t adja meg.

példa

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

A sablonosztály egy funktort ír le, amely meghívásakor az első argumentumot és a másodikat adja vissza. Az argumentumtípus szempontjából függvényobjektumot ad meg.

Szemantika

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

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

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

Paraméterek

Arg
Az argumentumok típusa és a visszatérési érték.

Tagfüggvények

Típusdefiníció	Leírás
delegate_type	Az általános meghatalmazott típusa.
first_argument_type	A funktor első argumentumának típusa.
result_type	A funktor eredményének típusa.
second_argument_type	A funktor második argumentumának típusa.

Tag	Leírás
plus	Felépíti a funktort.

Operátor	Leírás
operator()	Kiszámítja a kívánt függvényt.
operator delegate_type^	A funktort egy meghatalmazottra veti.

Megjegyzések

A sablonosztály egy kétargumentumos funktort ír le. A tag operátort operator() úgy határozza meg, hogy amikor az objektumot függvényként hívják, az első argumentumot és a másodikat adja vissza.

Az objektumot olyan függvényargumentumként is átadhatja, amelynek típusa és delegate_type^ megfelelő konvertálása megtörténik.

példa

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

Az általános osztály egy egyargumentumos delegáltat ír le. A használatával meg kell adnia egy meghatalmazottat az argumentum és a visszatérési típusok szempontjából.

Szemantika

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

Paraméterek

Arg
Az argumentum típusa.

Result
A visszatérési típus.

Megjegyzések

Az általános meghatalmazott egy argumentumfüggvényt ír le.

Ezekben a függvénysablonokban:

unary_delegate<int, int> Fun1;

unary_delegate<int, int> Fun2;

típusok Fun1 és Fun2 szinonimák, míg a következőhöz:

delegate int Fun1(int);

delegate int Fun2(int);

nem azonos típusúak.

példa

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

Az általános osztály egy egyargumentumos delegáltat ír le, amely visszaadja a függvényt void. A használatával megadhatja a meghatalmazottat az argumentumtípus szempontjából.

Szemantika

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

Paraméterek

Arg
Az argumentum típusa.

Megjegyzések

Az általános meghatalmazott egy argumentumfüggvényt ír le, amely visszaadja a függvényt void.

Ezekben a függvénysablonokban:

unary_delegate_noreturn<int> Fun1;

unary_delegate_noreturn<int> Fun2;

típusok Fun1 és Fun2 szinonimák, míg a következőhöz:

delegate void Fun1(int);

delegate void Fun2(int);

nem azonos típusúak.

példa

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

A sablonosztály egy funktort ír le, amely meghívásakor a tárolt egyargumentumos funktor logikai NOT értékét adja vissza. A használatával függvényobjektumot adhat meg a tárolt funktor szempontjából.

Szemantika

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

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

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

Paraméterek

Fun
A tárolt funktor típusa.

Tagfüggvények

Típusdefiníció	Leírás
argument_type	A funktor argumentum típusa.
delegate_type	Az általános meghatalmazott típusa.
result_type	A funktor eredményének típusa.

Tag	Leírás
unary_negate	Felépíti a funktort.

Operátor	Leírás
operator()	Kiszámítja a kívánt függvényt.
delegate_type^	A funktort egy meghatalmazottra veti.

Megjegyzések

A sablonosztály egy egyargumentumos funktort ír le, amely egy másik egyargumentumos funktort tárol. A tag operátort operator() úgy határozza meg, hogy amikor az objektumot függvényként hívják, az argumentummal meghívott tárolt funktor logikai NOT értékét adja vissza.

Az objektumot olyan függvényargumentumként is átadhatja, amelynek típusa és delegate_type^ megfelelő konvertálása megtörténik.

példa

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