functional (STL/CLR)

Zahrňte hlavičku <cliext/functional> STL/CLR pro definování šablon funkčních tříd a souvisejících delegátů a funkcí šablon.

Syntaxe

#include <functional>

Požadavky

Header:<cliext/functional>

Obor názvů:cliext

Deklarace

Delegát	Popis
binary_delegate (STL/CLR)	Delegát se dvěma argumenty.
binary_delegate_noreturn (STL/CLR)	Delegát se dvěma argumenty vracející void.
unary_delegate (STL/CLR)	Delegát s jedním argumentem.
unary_delegate_noreturn (STL/CLR)	Delegát s jedním argumentem, který voidvrací .

Třída	Popis
binary_negate (STL/CLR)	Functor negate a two-argument functor.
binder1st (STL/CLR)	Functor vytvořit vazbu prvního argumentu na functor se dvěma argumenty.
binder2nd (STL/CLR)	Functor vytvořit vazbu druhého argumentu na functor se dvěma argumenty.
divides (STL/CLR)	Dělit functor.
equal_to (STL/CLR)	Equal comparison functor.
greater (STL/CLR)	Větší porovnávací functor.
greater_equal (STL/CLR)	Větší nebo rovnou porovnávací trychtor.
less (STL/CLR)	Méně porovnávaný functor.
less_equal (STL/CLR)	Funktor porovnání je menší nebo rovno.
logical_and (STL/CLR)	Logický a functor AND.
logical_not (STL/CLR)	Logický FUNCTOR NOT.
logical_or (STL/CLR)	Logický nebo trychtýr.
minus (STL/CLR)	Odečíst functor.
modulus (STL/CLR)	Moduls functor.
multiplies (STL/CLR)	Násobte funktor.
negate (STL/CLR)	Functor vrátit svůj argument negated.
not_equal_to (STL/CLR)	Nerovná se porovnávací functor.
plus (STL/CLR)	Přidejte functor.
unary_negate (STL/CLR)	Functor negovat jeden-argument functor.

Function	Popis
bind1st (STL/CLR)	Vygeneruje binder1st pro argument a functor.
bind2nd (STL/CLR)	Vygeneruje pořadač2nd pro argument a functor.
not1 (STL/CLR)	Vygeneruje unary_negate pro functor.
not2 (STL/CLR)	Vygeneruje binary_negate pro functor.

Členové

binary_delegate (STL/CLR)

Obecná třída popisuje delegáta se dvěma argumenty. Použijete ho k určení delegáta z hlediska jeho argumentu a návratových typů.

Syntaxe

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

Parametry

Arg1
Typ prvního argumentu.

Arg2
Typ druhého argumentu.

Result
Návratový typ.

Poznámky

Obecný delegát popisuje funkci se dvěma argumenty.

V těchto šablonách funkcí:

binary_delegate<int, int, int> Fun1;

binary_delegate<int, int, int> Fun2;

typy Fun1 a Fun2 jsou synonymy, zatímco pro:

delegate int Fun1(int, int);

delegate int Fun2(int, int);

nejsou stejného typu.

Příklad

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

Obecná třída popisuje delegáta se dvěma argumenty, který vrací void. Použijete ho k určení delegáta z hlediska jeho argumentu.

Syntaxe

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

Parametry

Arg1
Typ prvního argumentu.

Arg2
Typ druhého argumentu.

Poznámky

Obecný delegát popisuje funkci se dvěma argumenty, která vrací void.

V těchto šablonách funkcí:

binary_delegate_noreturn<int, int> Fun1;

binary_delegate_noreturn<int, int> Fun2;

typy Fun1 a Fun2 jsou synonymy, zatímco pro:

delegate void Fun1(int, int);

delegate void Fun2(int, int);

nejsou stejného typu.

Příklad

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

Třída šablony popisuje functor, který při zavolání vrátí logickou HODNOTU svého uloženého dvou argumentu functor. Použijete ho k určení objektu funkce z hlediska uloženého functoru.

Syntaxe

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

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

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

Parametry

Fun
Typ uloženého functoru.

Členské funkce

Definice typu	Popis
delegate_type	Typ obecného delegáta.
first_argument_type	Typ prvního argumentu functoru.
result_type	Typ výsledku functoru.
second_argument_type	Typ druhéhoargumentho
stored_function_type	Typ functoru.

Člen	Popis
binary_negate	Vytvoří functor.

Operátor	Popis
operator()	Vypočítá požadovanou funkci.
operator delegate_type^()	Přetypuje functor delegáta.

Poznámky

Třída šablony popisuje functor se dvěma argumenty, který ukládá další functor se dvěma argumenty. Definuje operátor operator() člena tak, aby při zavolání objektu jako funkce vrátil logickou hodnotu NOT uloženého functoru volaného se dvěma argumenty.

Objekt můžete také předat jako argument funkce, jehož typ je delegate_type^ a bude správně převeden.

Příklad

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

Vygeneruje binder1st argument a functor.

Syntaxe

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

Parametry šablony

Arg
Typ argumentu.

Fun
Typ functoru.

Parametry funkce

functor
Functor, který se má zabalit.

left
První argument, který se má zabalit.

Poznámky

Šablona funkce vrátí binder1st<Fun>(functor, left). Použijete ho jako pohodlný způsob, jak zabalit functor se dvěma argumenty a jeho první argument v functoru s jedním argumentem, který ho volá s druhým argumentem.

Příklad

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

Vygeneruje binder2nd argument a functor.

Syntaxe

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

Parametry šablony

Arg
Typ argumentu.

Fun
Typ functoru.

Parametry funkce

functor
Functor, který se má zabalit.

right
Druhý argument, který se má zabalit.

Poznámky

Šablona funkce vrátí binder2nd<Fun>(functor, right). Použijete ho jako pohodlný způsob zabalení functoru se dvěma argumenty a jeho druhého argumentu v functoru s jedním argumentem, který ho volá s prvním argumentem.

Příklad

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

Třída šablony popisuje functor s jedním argumentem, který při zavolání vrátí svůj uložený dvou argument functor volaný s uloženým prvním argumentem a zadaným druhým argumentem. Použijete ho k určení objektu funkce z hlediska uloženého functoru.

Syntaxe

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

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

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

Parametry

Fun
Typ uloženého functoru.

Členské funkce

Definice typu	Popis
delegate_type	Typ obecného delegáta.
first_argument_type	Typ prvního argumentu functoru.
result_type	Typ výsledku functoru.
second_argument_type	Typ druhéhoargumentho
stored_function_type	Typ functoru.

Člen	Popis
binder1st	Vytvoří functor.

Operátor	Popis
operator()	Vypočítá požadovanou funkci.
operator delegate_type^()	Přetypuje functor delegáta.

Poznámky

Třída šablony popisuje functor s jedním argumentem, který ukládá functor se dvěma argumenty a první argument. Definuje operátor operator() člena, aby při volání objektu jako funkce vrátí výsledek volání uloženého functoru s uloženým prvním argumentem a zadaným druhým argumentem.

Objekt můžete také předat jako argument funkce, jehož typ je delegate_type^ a bude správně převeden.

Příklad

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

Třída šablony popisuje functor s jedním argumentem, který při zavolání vrátí svůj uložený dvou argument functor volaný s zadaným prvním argumentem a jeho uložený druhý argument. Použijete ho k určení objektu funkce z hlediska uloženého functoru.

Syntaxe

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

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

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

Parametry

Fun
Typ uloženého functoru.

Členské funkce

Definice typu	Popis
delegate_type	Typ obecného delegáta.
first_argument_type	Typ prvního argumentu functoru.
result_type	Typ výsledku functoru.
second_argument_type	Typ druhéhoargumentho
stored_function_type	Typ functoru.

Člen	Popis
binder2nd	Vytvoří functor.

Operátor	Popis
operator()	Vypočítá požadovanou funkci.
operator delegate_type^()	Přetypuje functor delegáta.

Poznámky

Třída šablony popisuje functor s jedním argumentem, který ukládá functor se dvěma argumenty a druhý argument. Definuje operátor operator() člena tak, aby při volání objektu jako funkce, vrátí výsledek volání uloženého functoru se zadaným prvním argumentem a uloženým druhým argumentem.

Objekt můžete také předat jako argument funkce, jehož typ je delegate_type^ a bude správně převeden.

Příklad

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

Třída šablony popisuje functor, který při zavolání vrátí první argument dělený druhou. Použijete jej k určení objektu funkce z hlediska jeho typu argumentu.

Syntaxe

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

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

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

Parametry

Arg
Typ argumentů a návratová hodnota.

Členské funkce

Definice typu	Popis
delegate_type	Typ obecného delegáta.
first_argument_type	Typ prvního argumentu functoru.
result_type	Typ výsledku functoru.
second_argument_type	Typ druhéhoargumentho

Člen	Popis
divides	Vytvoří functor.

Operátor	Popis
operator()	Vypočítá požadovanou funkci.
operator delegate_type^()	Přetypuje functor delegáta.

Poznámky

Třída šablony popisuje functor se dvěma argumenty. Definuje operátor operator() člena, aby, když je objekt volán jako funkce, vrátí první argument dělený druhou.

Objekt můžete také předat jako argument funkce, jehož typ je delegate_type^ a bude správně převeden.

Příklad

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

Třída šablony popisuje functor, který při zavolání vrátí hodnotu true pouze v případě, že první argument je roven druhé. Použijete jej k určení objektu funkce z hlediska jeho typu argumentu.

Syntaxe

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

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

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

Parametry

Arg
Typ argumentů.

Členské funkce

Definice typu	Popis
delegate_type	Typ obecného delegáta.
first_argument_type	Typ prvního argumentu functoru.
result_type	Typ výsledku functoru.
second_argument_type	Typ druhéhoargumentho

Člen	Popis
equal_to	Vytvoří functor.

Operátor	Popis
operator()	Vypočítá požadovanou funkci.
operator delegate_type^()	Přetypuje functor delegáta.

Poznámky

Třída šablony popisuje functor se dvěma argumenty. Definuje operátor operator() člena tak, aby, když je objekt volána jako funkce, vrátí hodnotu true pouze v případě, že první argument je roven druhé.

Objekt můžete také předat jako argument funkce, jehož typ je delegate_type^ a bude správně převeden.

Příklad

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

Třída šablony popisuje functor, který při zavolání vrátí hodnotu true pouze v případě, že první argument je větší než druhý. Použijete jej k určení objektu funkce z hlediska jeho typu argumentu.

Syntaxe

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

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

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

Parametry

Arg
Typ argumentů.

Členské funkce

Definice typu	Popis
delegate_type	Typ obecného delegáta.
first_argument_type	Typ prvního argumentu functoru.
result_type	Typ výsledku functoru.
second_argument_type	Typ druhéhoargumentho

Člen	Popis
greater	Vytvoří functor.

Operátor	Popis
operator()	Vypočítá požadovanou funkci.
operator delegate_type^	Přetypuje functor delegáta.

Poznámky

Třída šablony popisuje functor se dvěma argumenty. Definuje operátor operator() člena, aby, když je objekt volána jako funkce, vrátí hodnotu true pouze v případě, že první argument je větší než druhý.

Objekt můžete také předat jako argument funkce, jehož typ je delegate_type^ a bude správně převeden.

Příklad

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

Třída šablony popisuje functor, který při zavolání vrátí hodnotu true pouze v případě, že první argument je větší nebo roven druhé. Použijete jej k určení objektu funkce z hlediska jeho typu argumentu.

Syntaxe

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

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

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

Parametry

Arg
Typ argumentů.

Členské funkce

Definice typu	Popis
delegate_type	Typ obecného delegáta.
first_argument_type	Typ prvního argumentu functoru.
result_type	Typ výsledku functoru.
second_argument_type	Typ druhéhoargumentho

Člen	Popis
greater_equal	Vytvoří functor.

Operátor	Popis
operator()	Vypočítá požadovanou funkci.
operator delegate_type^	Přetypuje functor delegáta.

Poznámky

Třída šablony popisuje functor se dvěma argumenty. Definuje operátor operator() člena tak, aby, když je objekt volána jako funkce, vrátí hodnotu true pouze v případě, že první argument je větší nebo roven druhé.

Objekt můžete také předat jako argument funkce, jehož typ je delegate_type^ a bude správně převeden.

Příklad

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

Třída šablony popisuje functor, který při zavolání vrátí hodnotu true pouze v případě, že první argument je menší než druhý. Použijete jej k určení objektu funkce z hlediska jeho typu argumentu.

Syntaxe

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

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

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

Parametry

Arg
Typ argumentů.

Členské funkce

Definice typu	Popis
delegate_type	Typ obecného delegáta.
first_argument_type	Typ prvního argumentu functoru.
result_type	Typ výsledku functoru.
second_argument_type	Typ druhéhoargumentho

Člen	Popis
less	Vytvoří functor.

Operátor	Popis
operator()	Vypočítá požadovanou funkci.
operator delegate_type^	Přetypuje functor delegáta.

Poznámky

Třída šablony popisuje functor se dvěma argumenty. Definuje operátor operator() člena, aby, když je objekt volána jako funkce, vrátí hodnotu true pouze v případě, že první argument je menší než druhý.

Objekt můžete také předat jako argument funkce, jehož typ je delegate_type^ a bude správně převeden.

Příklad

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

Třída šablony popisuje functor, který při zavolání vrátí hodnotu true pouze v případě, že první argument je menší nebo roven druhé. Použijete jej k určení objektu funkce z hlediska jeho typu argumentu.

Syntaxe

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

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

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

Parametry

Arg
Typ argumentů.

Členské funkce

Definice typu	Popis
delegate_type	Typ obecného delegáta.
first_argument_type	Typ prvního argumentu functoru.
result_type	Typ výsledku functoru.
second_argument_type	Typ druhéhoargumentho

Člen	Popis
less_equal	Vytvoří functor.

Operátor	Popis
operator()	Vypočítá požadovanou funkci.
operator delegate_type^	Přetypuje functor delegáta.

Poznámky

Třída šablony popisuje functor se dvěma argumenty. Definuje operátor operator() člena tak, aby, když je objekt volána jako funkce, vrátí hodnotu true pouze v případě, že první argument je menší nebo roven druhé.

Objekt můžete také předat jako argument funkce, jehož typ je delegate_type^ a bude správně převeden.

Příklad

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

Třída šablony popisuje functor, který při zavolání vrátí hodnotu true pouze v případě, že první i druhý test jako true. Použijete jej k určení objektu funkce z hlediska jeho typu argumentu.

Syntaxe

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

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

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

Parametry

Arg
Typ argumentů.

Členské funkce

Definice typu	Popis
delegate_type	Typ obecného delegáta.
first_argument_type	Typ prvního argumentu functoru.
result_type	Typ výsledku functoru.
second_argument_type	Typ druhéhoargumentho

Člen	Popis
logical_and	Vytvoří functor.

Operátor	Popis
operator()	Vypočítá požadovanou funkci.
operator delegate_type^	Přetypuje functor delegáta.

Poznámky

Třída šablony popisuje functor se dvěma argumenty. Definuje operátor operator() člena tak, aby, když je objekt volána jako funkce, vrátí hodnotu true pouze v případě, že první argument i druhý test jako true.

Objekt můžete také předat jako argument funkce, jehož typ je delegate_type^ a bude správně převeden.

Příklad

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

Třída šablony popisuje functor, který při zavolání vrátí hodnotu true pouze v případě, že některý z jeho argumentů testuje jako false. Použijete jej k určení objektu funkce z hlediska jeho typu argumentu.

Syntaxe

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

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

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

Parametry

Arg
Typ argumentů.

Členské funkce

Definice typu	Popis
argument_type	Typ argumentu functoru.
delegate_type	Typ obecného delegáta.
result_type	Typ výsledku functoru.

Člen	Popis
logical_not	Vytvoří functor.

Operátor	Popis
operator()	Vypočítá požadovanou funkci.
operator delegate_type^	Přetypuje functor delegáta.

Poznámky

Třída šablony popisuje functor s jedním argumentem. Definuje operátor operator() člena, aby při zavolání objektu jako funkce vrátil hodnotu true pouze v případě, že argument testuje hodnotu false.

Objekt můžete také předat jako argument funkce, jehož typ je delegate_type^ a bude správně převeden.

Příklad

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

Třída šablony popisuje functor, který při zavolání vrátí hodnotu true pouze v případě, že první nebo druhý test jako true. Použijete jej k určení objektu funkce z hlediska jeho typu argumentu.

Syntaxe

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

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

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

Parametry

Arg
Typ argumentů.

Členské funkce

Definice typu	Popis
delegate_type	Typ obecného delegáta.
first_argument_type	Typ prvního argumentu functoru.
result_type	Typ výsledku functoru.
second_argument_type	Typ druhéhoargumentho

Člen	Popis
logical_or	Vytvoří functor.

Operátor	Popis
operator()	Vypočítá požadovanou funkci.
operator delegate_type^	Přetypuje functor delegáta.

Poznámky

Třída šablony popisuje functor se dvěma argumenty. Definuje operátor operator() člena, aby, když je objekt volána jako funkce, vrátí hodnotu true pouze v případě, že první nebo druhý test jako true.

Objekt můžete také předat jako argument funkce, jehož typ je delegate_type^ a bude správně převeden.

Příklad

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

Třída šablony popisuje functor, který při zavolání vrátí první argument minus druhý argument. Použijete jej k určení objektu funkce z hlediska jeho typu argumentu.

Syntaxe

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

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

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

Parametry

Arg
Typ argumentů a návratová hodnota.

Členské funkce

Definice typu	Popis
delegate_type	Typ obecného delegáta.
first_argument_type	Typ prvního argumentu functoru.
result_type	Typ výsledku functoru.
second_argument_type	Typ druhéhoargumentho

Člen	Popis
minus	Vytvoří functor.

Operátor	Popis
operator()	Vypočítá požadovanou funkci.
operator delegate_type^	Přetypuje functor delegáta.

Poznámky

Třída šablony popisuje functor se dvěma argumenty. Definuje operátor operator() člena tak, aby při zavolání objektu jako funkce vrátil první argument minus druhý argument.

Objekt můžete také předat jako argument funkce, jehož typ je delegate_type^ a bude správně převeden.

Příklad

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

Třída šablony popisuje functor, který při zavolání vrátí první argument modulo druhé. Použijete jej k určení objektu funkce z hlediska jeho typu argumentu.

Syntaxe

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

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

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

Parametry

Arg
Typ argumentů a návratová hodnota.

Členské funkce

Definice typu	Popis
delegate_type	Typ obecného delegáta.
first_argument_type	Typ prvního argumentu functoru.
result_type	Typ výsledku functoru.
second_argument_type	Typ druhéhoargumentho

Člen	Popis
modulus	Vytvoří functor.

Operátor	Popis
operator()	Vypočítá požadovanou funkci.
operator delegate_type^	Přetypuje functor delegáta.

Poznámky

Třída šablony popisuje functor se dvěma argumenty. Definuje operátor operator() člena tak, aby při zavolání objektu jako funkce vrátil první argument modulo druhé.

Objekt můžete také předat jako argument funkce, jehož typ je delegate_type^ a bude správně převeden.

Příklad

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

Třída šablony popisuje functor, který při zavolání vrátí první argument krát druhý. Použijete jej k určení objektu funkce z hlediska jeho typu argumentu.

Syntaxe

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

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

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

Parametry

Arg
Typ argumentů a návratová hodnota.

Členské funkce

Definice typu	Popis
delegate_type	Typ obecného delegáta.
first_argument_type	Typ prvního argumentu functoru.
result_type	Typ výsledku functoru.
second_argument_type	Typ druhéhoargumentho

Člen	Popis
multiplies	Vytvoří functor.

Operátor	Popis
operator()	Vypočítá požadovanou funkci.
operator delegate_type^	Přetypuje functor delegáta.

Poznámky

Třída šablony popisuje functor se dvěma argumenty. Definuje operátor operator() člena tak, aby při zavolání objektu jako funkce vrátil první argument krát druhý.

Objekt můžete také předat jako argument funkce, jehož typ je delegate_type^ a bude správně převeden.

Příklad

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

Třída šablony popisuje functor, který při zavolání vrátí svůj argument negated. Použijete jej k určení objektu funkce z hlediska jeho typu argumentu.

Syntaxe

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

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

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

Parametry

Arg
Typ argumentů.

Členské funkce

Definice typu	Popis
argument_type	Typ argumentu functoru.
delegate_type	Typ obecného delegáta.
result_type	Typ výsledku functoru.

Člen	Popis
negate	Vytvoří functor.

Operátor	Popis
operator()	Vypočítá požadovanou funkci.
operator delegate_type^	Přetypuje functor delegáta.

Poznámky

Třída šablony popisuje functor s jedním argumentem. Definuje operátor operator() člena, aby, když je objekt volána jako funkce, vrátí svůj argument negated.

Objekt můžete také předat jako argument funkce, jehož typ je delegate_type^ a bude správně převeden.

Příklad

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

Třída šablony popisuje functor, který při zavolání vrátí hodnotu true pouze v případě, že první argument není roven druhé. Použijete jej k určení objektu funkce z hlediska jeho typu argumentu.

Syntaxe

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

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

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

Parametry

Arg
Typ argumentů.

Členské funkce

Definice typu	Popis
delegate_type	Typ obecného delegáta.
first_argument_type	Typ prvního argumentu functoru.
result_type	Typ výsledku functoru.
second_argument_type	Typ druhéhoargumentho

Člen	Popis
not_equal_to	Vytvoří functor.

Operátor	Popis
operator()	Vypočítá požadovanou funkci.
operator delegate_type^	Přetypuje functor delegáta.

Poznámky

Třída šablony popisuje functor se dvěma argumenty. Definuje operátor operator() člena tak, že když je objekt volána jako funkce, vrátí hodnotu true pouze v případě, že první argument není roven druhému.

Objekt můžete také předat jako argument funkce, jehož typ je delegate_type^ a bude správně převeden.

Příklad

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

Vygeneruje unary_negate pro functor.

Syntaxe

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

Parametry šablony

Fun
Typ functoru.

Parametry funkce

functor
Functor, který se má zabalit.

Poznámky

Šablona funkce vrátí unary_negate<Fun>(functor). Použijete ho jako pohodlný způsob, jak zabalit functor s jedním argumentem do functoru, který poskytuje její logickou NE.

Příklad

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

Vygeneruje binary_negate pro functor.

Syntaxe

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

Parametry šablony

Fun
Typ functoru.

Parametry funkce

functor
Functor, který se má zabalit.

Poznámky

Šablona funkce vrátí binary_negate<Fun>(functor). Použijete ho jako pohodlný způsob, jak zabalit functor se dvěma argumenty do functoru, který poskytuje jeho logickou NE.

Příklad

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

Třída šablony popisuje functor, který při zavolání vrátí první argument plus druhý argument. Použijete jej k určení objektu funkce z hlediska jeho typu argumentu.

Syntaxe

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

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

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

Parametry

Arg
Typ argumentů a návratová hodnota.

Členské funkce

Definice typu	Popis
delegate_type	Typ obecného delegáta.
first_argument_type	Typ prvního argumentu functoru.
result_type	Typ výsledku functoru.
second_argument_type	Typ druhéhoargumentho

Člen	Popis
plus	Vytvoří functor.

Operátor	Popis
operator()	Vypočítá požadovanou funkci.
operator delegate_type^	Přetypuje functor delegáta.

Poznámky

Třída šablony popisuje functor se dvěma argumenty. Definuje operátor operator() člena tak, aby při zavolání objektu jako funkce vrátil první argument plus druhý.

Objekt můžete také předat jako argument funkce, jehož typ je delegate_type^ a bude správně převeden.

Příklad

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

Obecná třída popisuje delegáta s jedním argumentem. Použijete ho k určení delegáta z hlediska jeho argumentu a návratových typů.

Syntaxe

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

Parametry

Arg
Typ argumentu.

Result
Návratový typ.

Poznámky

Obecný delegát popisuje funkci s jedním argumentem.

V těchto šablonách funkcí:

unary_delegate<int, int> Fun1;

unary_delegate<int, int> Fun2;

typy Fun1 a Fun2 jsou synonymy, zatímco pro:

delegate int Fun1(int);

delegate int Fun2(int);

nejsou stejného typu.

Příklad

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

Obecná třída popisuje delegát s jedním argumentem, který vrací void. Použijete ho k určení delegáta z hlediska jeho typu argumentu.

Syntaxe

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

Parametry

Arg
Typ argumentu.

Poznámky

Obecný delegát popisuje funkci s jedním argumentem, která vrací void.

V těchto šablonách funkcí:

unary_delegate_noreturn<int> Fun1;

unary_delegate_noreturn<int> Fun2;

typy Fun1 a Fun2 jsou synonymy, zatímco pro:

delegate void Fun1(int);

delegate void Fun2(int);

nejsou stejného typu.

Příklad

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

Třída šablony popisuje functor, který při zavolání vrátí logickou HODNOTU svého uloženého functoru s jedním argumentem. Použijete ho k určení objektu funkce z hlediska uloženého functoru.

Syntaxe

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

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

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

Parametry

Fun
Typ uloženého functoru.

Členské funkce

Definice typu	Popis
argument_type	Typ argumentu functoru.
delegate_type	Typ obecného delegáta.
result_type	Typ výsledku functoru.

Člen	Popis
unary_negate	Vytvoří functor.

Operátor	Popis
operator()	Vypočítá požadovanou funkci.
delegate_type^	Přetypuje functor delegáta.

Poznámky

Třída šablony popisuje functor s jedním argumentem, který ukládá další functor s jedním argumentem. Definuje operátor operator() člena, aby, když je objekt volána jako funkce, vrátí logickou NOT uloženého functoru volaného s argumentem.

Objekt můžete také předat jako argument funkce, jehož typ je delegate_type^ a bude správně převeden.

Příklad

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