functional (STL/CLR)

Neem de STL/CLR-header <cliext/functional> op om functionele klassesjablonen en gerelateerde sjabloondelegeringen en functies te definiëren.

Syntaxis

#include <functional>

Behoeften

Rubriek:<cliext/functioneel>

naamruimte:cliext

Verklaringen

Leden

binary_delegate (STL/CLR)

In de algemene klasse wordt een gemachtigde met twee argumenten beschreven. U gebruikt deze functie om een gemachtigde op te geven in termen van het argument en retourtypen.

Syntaxis

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

Parameterwaarden

Arg1
Het type van het eerste argument.

Arg2
Het type van het tweede argument.

Result
Het retourtype.

Opmerkingen

De algemene gemachtigde beschrijft een functie met twee argumenten.

In deze functiesjablonen:

binary_delegate<int, int, int> Fun1;

binary_delegate<int, int, int> Fun2;

de typen Fun1 en Fun2 synoniemen zijn, terwijl voor:

delegate int Fun1(int, int);

delegate int Fun2(int, int);

ze zijn niet hetzelfde type.

Voorbeeld

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

De algemene klasse beschrijft een gemachtigde met twee argumenten die wordt geretourneerd void. U gebruikt deze functie om een gemachtigde op te geven in termen van het argument.

Syntaxis

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

Parameterwaarden

Arg1
Het type van het eerste argument.

Arg2
Het type van het tweede argument.

Opmerkingen

De algemene gemachtigde beschrijft een functie met twee argumenten die wordt geretourneerd void.

In deze functiesjablonen:

binary_delegate_noreturn<int, int> Fun1;

binary_delegate_noreturn<int, int> Fun2;

de typen Fun1 en Fun2 synoniemen zijn, terwijl voor:

delegate void Fun1(int, int);

delegate void Fun2(int, int);

ze zijn niet hetzelfde type.

Voorbeeld

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

De sjabloonklasse beschrijft een functor die, wanneer aangeroepen, de logische NOT van de opgeslagen functor met twee argumenten retourneert. U gebruikt het om een functieobject op te geven in termen van de opgeslagen functor.

Syntaxis

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

Parameterwaarden

Fun
Het type van de opgeslagen functor.

Lidfuncties

Opmerkingen

In de sjabloonklasse wordt een functor met twee argumenten beschreven waarin nog een functor met twee argumenten wordt opgeslagen. Hiermee wordt de lidoperator operator() gedefinieerd, zodat, wanneer het object wordt aangeroepen als een functie, de logische NOT van de opgeslagen functor met de twee argumenten retourneert.

U kunt het object ook doorgeven als een functieargument waarvan het type is delegate_type^ en dat het op de juiste manier wordt geconverteerd.

Voorbeeld

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

Genereert een binder1st voor een argument en functor.

Syntaxis

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

Sjabloonparameters

Arg
Het type van het argument.

Fun
Het type functor.

Functieparameters

functor
De functor om te verpakken.

left
Het eerste argument om te verpakken.

Opmerkingen

De functiesjabloon retourneert binder1st<Fun>(functor, left). U kunt het gebruiken als een handige manier om een functor met twee argumenten en het eerste argument in een functor met één argument te verpakken die het aanroept met een tweede argument.

Voorbeeld

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

Genereert een binder2nd voor een argument en functor.

Syntaxis

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

Sjabloonparameters

Arg
Het type van het argument.

Fun
Het type functor.

Functieparameters

functor
De functor om te verpakken.

right
Het tweede argument om te verpakken.

Opmerkingen

De functiesjabloon retourneert binder2nd<Fun>(functor, right). U kunt het gebruiken als een handige manier om een functor met twee argumenten en het tweede argument in een functor met één argument te verpakken die het aanroept met een eerste argument.

Voorbeeld

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

De sjabloonklasse beschrijft een functor met één argument die, wanneer aangeroepen, de opgeslagen functor met twee argumenten retourneert die wordt aangeroepen met het opgeslagen eerste argument en het opgegeven tweede argument. U gebruikt het om een functieobject op te geven in termen van de opgeslagen functor.

Syntaxis

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

Parameterwaarden

Fun
Het type van de opgeslagen functor.

Lidfuncties

Opmerkingen

In de sjabloonklasse wordt een functor met één argument beschreven waarin een functor met twee argumenten en een eerste argument wordt opgeslagen. Hiermee definieert u de lidoperator operator() zodat, wanneer het object wordt aangeroepen als een functie, het resultaat wordt geretourneerd van het aanroepen van de opgeslagen functor met het opgeslagen eerste argument en het opgegeven tweede argument.

U kunt het object ook doorgeven als een functieargument waarvan het type is delegate_type^ en dat het op de juiste manier wordt geconverteerd.

Voorbeeld

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

De sjabloonklasse beschrijft een functor met één argument die, wanneer aangeroepen, de opgeslagen functor met twee argumenten retourneert die wordt aangeroepen met het opgegeven eerste argument en het opgeslagen tweede argument. U gebruikt het om een functieobject op te geven in termen van de opgeslagen functor.

Syntaxis

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

Parameterwaarden

Fun
Het type van de opgeslagen functor.

Lidfuncties

Opmerkingen

In de sjabloonklasse wordt een functor met één argument beschreven waarin een functor met twee argumenten en een tweede argument wordt opgeslagen. Hiermee definieert u de lidoperator operator() zodat, wanneer het object wordt aangeroepen als een functie, het resultaat wordt geretourneerd van het aanroepen van de opgeslagen functor met het opgegeven eerste argument en het opgeslagen tweede argument.

U kunt het object ook doorgeven als een functieargument waarvan het type is delegate_type^ en dat het op de juiste manier wordt geconverteerd.

Voorbeeld

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

De sjabloonklasse beschrijft een functor die, wanneer aangeroepen, het eerste argument retourneert dat door de tweede is gedeeld. U gebruikt het om een functieobject op te geven in termen van het argumenttype.

Syntaxis

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

Parameterwaarden

Arg
Het type argumenten en de retourwaarde.

Lidfuncties

Opmerkingen

In de sjabloonklasse wordt een functor met twee argumenten beschreven. Hiermee definieert u de lidoperator operator() , zodat wanneer het object wordt aangeroepen als een functie, het eerste argument retourneert dat door de tweede is gedeeld.

U kunt het object ook doorgeven als een functieargument waarvan het type is delegate_type^ en dat het op de juiste manier wordt geconverteerd.

Voorbeeld

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

De sjabloonklasse beschrijft een functor die, wanneer aangeroepen, alleen waar retourneert als het eerste argument gelijk is aan de tweede. U gebruikt het om een functieobject op te geven in termen van het argumenttype.

Syntaxis

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

Parameterwaarden

Arg
Het type argumenten.

Lidfuncties

Opmerkingen

In de sjabloonklasse wordt een functor met twee argumenten beschreven. Hiermee definieert u de lidoperator operator() , zodat wanneer het object wordt aangeroepen als een functie, het alleen waar retourneert als het eerste argument gelijk is aan de tweede.

U kunt het object ook doorgeven als een functieargument waarvan het type is delegate_type^ en dat het op de juiste manier wordt geconverteerd.

Voorbeeld

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

De sjabloonklasse beschrijft een functor die, wanneer aangeroepen, alleen waar retourneert als het eerste argument groter is dan de tweede. U gebruikt het om een functieobject op te geven in termen van het argumenttype.

Syntaxis

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

Parameterwaarden

Arg
Het type argumenten.

Lidfuncties

Opmerkingen

In de sjabloonklasse wordt een functor met twee argumenten beschreven. Hiermee wordt de lidoperator operator() gedefinieerd, zodat wanneer het object wordt aangeroepen als een functie, het alleen waar retourneert als het eerste argument groter is dan de tweede.

U kunt het object ook doorgeven als een functieargument waarvan het type is delegate_type^ en dat het op de juiste manier wordt geconverteerd.

Voorbeeld

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

De sjabloonklasse beschrijft een functor die, wanneer aangeroepen, alleen waar retourneert als het eerste argument groter is dan of gelijk is aan de tweede. U gebruikt het om een functieobject op te geven in termen van het argumenttype.

Syntaxis

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

Parameterwaarden

Arg
Het type argumenten.

Lidfuncties

Opmerkingen

In de sjabloonklasse wordt een functor met twee argumenten beschreven. Hiermee wordt de lidoperator operator() gedefinieerd, zodat wanneer het object wordt aangeroepen als een functie, het alleen waar retourneert als het eerste argument groter is dan of gelijk is aan de tweede.

U kunt het object ook doorgeven als een functieargument waarvan het type is delegate_type^ en dat het op de juiste manier wordt geconverteerd.

Voorbeeld

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

De sjabloonklasse beschrijft een functor die, wanneer aangeroepen, alleen waar retourneert als het eerste argument kleiner is dan de tweede. U gebruikt het om een functieobject op te geven in termen van het argumenttype.

Syntaxis

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

Parameterwaarden

Arg
Het type argumenten.

Lidfuncties

Opmerkingen

In de sjabloonklasse wordt een functor met twee argumenten beschreven. Hiermee wordt de lidoperator operator() gedefinieerd, zodat wanneer het object wordt aangeroepen als een functie, het alleen waar retourneert als het eerste argument kleiner is dan de tweede.

U kunt het object ook doorgeven als een functieargument waarvan het type is delegate_type^ en dat het op de juiste manier wordt geconverteerd.

Voorbeeld

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

De sjabloonklasse beschrijft een functor die, wanneer aangeroepen, alleen waar retourneert als het eerste argument kleiner is dan of gelijk is aan de tweede. U gebruikt het om een functieobject op te geven in termen van het argumenttype.

Syntaxis

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

Parameterwaarden

Arg
Het type argumenten.

Lidfuncties

Opmerkingen

In de sjabloonklasse wordt een functor met twee argumenten beschreven. Hiermee definieert u de lidoperator operator() , zodat wanneer het object wordt aangeroepen als een functie, het alleen waar retourneert als het eerste argument kleiner is dan of gelijk is aan de tweede.

U kunt het object ook doorgeven als een functieargument waarvan het type is delegate_type^ en dat het op de juiste manier wordt geconverteerd.

Voorbeeld

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

De sjabloonklasse beschrijft een functor die, wanneer aangeroepen, alleen waar retourneert als zowel het eerste argument als de tweede test waar is. U gebruikt het om een functieobject op te geven in termen van het argumenttype.

Syntaxis

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

Parameterwaarden

Arg
Het type argumenten.

Lidfuncties

Opmerkingen

In de sjabloonklasse wordt een functor met twee argumenten beschreven. Hiermee definieert u de lidoperator operator() , zodat wanneer het object wordt aangeroepen als een functie, het alleen waar retourneert als zowel het eerste argument als de tweede test waar is.

U kunt het object ook doorgeven als een functieargument waarvan het type is delegate_type^ en dat het op de juiste manier wordt geconverteerd.

Voorbeeld

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

In de sjabloonklasse wordt een functor beschreven die, wanneer deze wordt aangeroepen, alleen waar retourneert als het argument onwaar wordt getest. U gebruikt het om een functieobject op te geven in termen van het argumenttype.

Syntaxis

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

Parameterwaarden

Arg
Het type argumenten.

Lidfuncties

Opmerkingen

In de sjabloonklasse wordt een functor met één argument beschreven. Hiermee definieert u de lidoperator operator() , zodat wanneer het object wordt aangeroepen als een functie, het alleen waar retourneert als het argument onwaar test.

U kunt het object ook doorgeven als een functieargument waarvan het type is delegate_type^ en dat het op de juiste manier wordt geconverteerd.

Voorbeeld

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

De sjabloonklasse beschrijft een functor die, wanneer aangeroepen, alleen waar retourneert als het eerste argument of de tweede test waar is. U gebruikt het om een functieobject op te geven in termen van het argumenttype.

Syntaxis

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

Parameterwaarden

Arg
Het type argumenten.

Lidfuncties

Opmerkingen

In de sjabloonklasse wordt een functor met twee argumenten beschreven. Hiermee wordt de lidoperator operator() gedefinieerd, zodat wanneer het object wordt aangeroepen als een functie, het alleen waar retourneert als het eerste argument of de tweede test als waar.

U kunt het object ook doorgeven als een functieargument waarvan het type is delegate_type^ en dat het op de juiste manier wordt geconverteerd.

Voorbeeld

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

In de sjabloonklasse wordt een functor beschreven die, wanneer aangeroepen, het eerste argument min de tweede retourneert. U gebruikt het om een functieobject op te geven in termen van het argumenttype.

Syntaxis

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

Parameterwaarden

Arg
Het type argumenten en de retourwaarde.

Lidfuncties

Opmerkingen

In de sjabloonklasse wordt een functor met twee argumenten beschreven. Hiermee definieert u de lidoperator operator() , zodat, wanneer het object wordt aangeroepen als een functie, het eerste argument min de tweede retourneert.

U kunt het object ook doorgeven als een functieargument waarvan het type is delegate_type^ en dat het op de juiste manier wordt geconverteerd.

Voorbeeld

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

De sjabloonklasse beschrijft een functor die, wanneer aangeroepen, de eerste argumentmodulatie de tweede retourneert. U gebruikt het om een functieobject op te geven in termen van het argumenttype.

Syntaxis

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

Parameterwaarden

Arg
Het type argumenten en de retourwaarde.

Lidfuncties

Opmerkingen

In de sjabloonklasse wordt een functor met twee argumenten beschreven. Hiermee definieert u de lidoperator operator() , zodat wanneer het object wordt aangeroepen als een functie, de eerste argumentmodulatie de tweede retourneert.

U kunt het object ook doorgeven als een functieargument waarvan het type is delegate_type^ en dat het op de juiste manier wordt geconverteerd.

Voorbeeld

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

In de sjabloonklasse wordt een functor beschreven die, wanneer deze wordt aangeroepen, het eerste argument keert als de tweede retourneert. U gebruikt het om een functieobject op te geven in termen van het argumenttype.

Syntaxis

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

Parameterwaarden

Arg
Het type argumenten en de retourwaarde.

Lidfuncties

Opmerkingen

In de sjabloonklasse wordt een functor met twee argumenten beschreven. Hiermee definieert u de lidoperator operator() , zodat wanneer het object wordt aangeroepen als een functie, het eerste argument keert dat het tweede argument wordt geretourneerd.

U kunt het object ook doorgeven als een functieargument waarvan het type is delegate_type^ en dat het op de juiste manier wordt geconverteerd.

Voorbeeld

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

In de sjabloonklasse wordt een functor beschreven die, wanneer aangeroepen, het argument wordt genegeerd. U gebruikt het om een functieobject op te geven in termen van het argumenttype.

Syntaxis

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

Parameterwaarden

Arg
Het type argumenten.

Lidfuncties

Opmerkingen

In de sjabloonklasse wordt een functor met één argument beschreven. Hiermee wordt de lidoperator operator() gedefinieerd, zodat, wanneer het object wordt aangeroepen als een functie, het argument wordt genegeerd.

U kunt het object ook doorgeven als een functieargument waarvan het type is delegate_type^ en dat het op de juiste manier wordt geconverteerd.

Voorbeeld

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

De sjabloonklasse beschrijft een functor die, wanneer aangeroepen, alleen waar retourneert als het eerste argument niet gelijk is aan de tweede. U gebruikt het om een functieobject op te geven in termen van het argumenttype.

Syntaxis

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

Parameterwaarden

Arg
Het type argumenten.

Lidfuncties

Opmerkingen

In de sjabloonklasse wordt een functor met twee argumenten beschreven. Hiermee definieert u de lidoperator operator() , zodat wanneer het object wordt aangeroepen als een functie, het alleen waar retourneert als het eerste argument niet gelijk is aan de tweede.

U kunt het object ook doorgeven als een functieargument waarvan het type is delegate_type^ en dat het op de juiste manier wordt geconverteerd.

Voorbeeld

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

Genereert een unary_negate voor een functor.

Syntaxis

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

Sjabloonparameters

Fun
Het type functor.

Functieparameters

functor
De functor om te verpakken.

Opmerkingen

De functiesjabloon retourneert unary_negate<Fun>(functor). U gebruikt het als een handige manier om een functor met één argument in te pakken in een functor die de logische NOT levert.

Voorbeeld

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

Genereert een binary_negate voor een functor.

Syntaxis

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

Sjabloonparameters

Fun
Het type functor.

Functieparameters

functor
De functor om te verpakken.

Opmerkingen

De functiesjabloon retourneert binary_negate<Fun>(functor). U gebruikt het als een handige manier om een functor met twee argumenten te verpakken in een functor die de logische NOT levert.

Voorbeeld

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

In de sjabloonklasse wordt een functor beschreven die, wanneer deze wordt aangeroepen, het eerste argument plus de tweede retourneert. U gebruikt het om een functieobject op te geven in termen van het argumenttype.

Syntaxis

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

Parameterwaarden

Arg
Het type argumenten en de retourwaarde.

Lidfuncties

Opmerkingen

In de sjabloonklasse wordt een functor met twee argumenten beschreven. Hiermee definieert u de lidoperator operator() , zodat, wanneer het object wordt aangeroepen als een functie, het eerste argument plus de tweede retourneert.

U kunt het object ook doorgeven als een functieargument waarvan het type is delegate_type^ en dat het op de juiste manier wordt geconverteerd.

Voorbeeld

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

In de algemene klasse wordt een gemachtigde met één argument beschreven. U gebruikt deze functie om een gemachtigde op te geven in termen van het argument en retourtypen.

Syntaxis

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

Parameterwaarden

Arg
Het type van het argument.

Result
Het retourtype.

Opmerkingen

De algemene gemachtigde beschrijft een functie met één argument.

In deze functiesjablonen:

unary_delegate<int, int> Fun1;

unary_delegate<int, int> Fun2;

de typen Fun1 en Fun2 synoniemen zijn, terwijl voor:

delegate int Fun1(int);

delegate int Fun2(int);

ze zijn niet hetzelfde type.

Voorbeeld

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

In de algemene klasse wordt een gemachtigde met één argument beschreven die wordt geretourneerd void. U gebruikt deze functie om een gemachtigde op te geven in termen van het argumenttype.

Syntaxis

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

Parameterwaarden

Arg
Het type van het argument.

Opmerkingen

De algemene gemachtigde beschrijft een functie met één argument die retourneert void.

In deze functiesjablonen:

unary_delegate_noreturn<int> Fun1;

unary_delegate_noreturn<int> Fun2;

de typen Fun1 en Fun2 synoniemen zijn, terwijl voor:

delegate void Fun1(int);

delegate void Fun2(int);

ze zijn niet hetzelfde type.

Voorbeeld

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

De sjabloonklasse beschrijft een functor die, wanneer aangeroepen, de logische NOT van de opgeslagen functor met één argument retourneert. U gebruikt het om een functieobject op te geven in termen van de opgeslagen functor.

Syntaxis

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

Parameterwaarden

Fun
Het type van de opgeslagen functor.

Lidfuncties

Opmerkingen

In de sjabloonklasse wordt een functor met één argument beschreven waarin een andere functor met één argument wordt opgeslagen. Hiermee definieert u de lidoperator operator() , zodat wanneer het object wordt aangeroepen als een functie, de logische NOT van de opgeslagen functor die met het argument wordt aangeroepen, wordt geretourneerd.

U kunt het object ook doorgeven als een functieargument waarvan het type is delegate_type^ en dat het op de juiste manier wordt geconverteerd.

Voorbeeld

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