functional (STL/CLR)

İşlevsel sınıf şablonlarını ve ilgili şablon temsilcilerini ve işlevlerini tanımlamak için STL/CLR üst bilgisini <cliext/functional> ekleyin.

Sözdizimi

#include <functional>

Gereksinimler

Üst bilgi:<cliext/functional>

Ad alanı: cliext

Bildirimler

Temsilci	Açıklama
binary_delegate (STL/CLR)	İki bağımsız değişkenli temsilci.
binary_delegate_noreturn (STL/CLR)	döndüren voidiki bağımsız değişkenli temsilci.
unary_delegate (STL/CLR)	Tek bağımsız değişkenli temsilci.
unary_delegate_noreturn (STL/CLR)	Döndüren voidtek bağımsız değişkenli temsilci.

Sınıf	Açıklama
binary_negate (STL/CLR)	İki bağımsız değişkenli bir functor'ı yok etmek için functor.
binder1st (STL/CLR)	İlk bağımsız değişkeni iki bağımsız değişkenli bir functor'a bağlamak için functor.
binder2nd (STL/CLR)	İkinci bağımsız değişkeni iki bağımsız değişkenli bir functor'a bağlamak için functor.
divides (STL/CLR)	Eğlenceyi böl.
equal_to (STL/CLR)	Eşit karşılaştırmalı funktör.
greater (STL/CLR)	Daha iyi karşılaştırma funktör.
greater_equal (STL/CLR)	Büyük veya eşit karşılaştırma funktör.
less (STL/CLR)	Daha az karşılaştırmalı funktör.
less_equal (STL/CLR)	Daha az veya eşit karşılaştırma funktör.
logical_and (STL/CLR)	Mantıksal AND functor.
logical_not (STL/CLR)	Mantıksal NOT functor.
logical_or (STL/CLR)	Mantıksal VEYA functor.
minus (STL/CLR)	Functor'i çıkarın.
modulus (STL/CLR)	Modulus functor.
multiplies (STL/CLR)	Functor'ın çarpın.
negate (STL/CLR)	Functor bağımsız değişkenini olumsuz döndürecek.
not_equal_to (STL/CLR)	Eşit karşılaştırma funktör değil.
plus (STL/CLR)	Functor ekleyin.
unary_negate (STL/CLR)	Tek bağımsız değişkenli bir functor'ı yok etmek için functor.

İşlev	Açıklama
bind1st (STL/CLR)	Bağımsız değişken ve funktör için bağlayıcı1st oluşturur.
bind2nd (STL/CLR)	Bağımsız değişken ve funktör için binder2nd oluşturur.
not1 (STL/CLR)	Bir functor için bir unary_negate oluşturur.
not2 (STL/CLR)	Bir functor için bir binary_negate oluşturur.

Üyeler

binary_delegate (STL/CLR)

Genel sınıf, iki bağımsız değişkenli bir temsilciyi açıklar. Bağımsız değişkeni ve dönüş türleri açısından bir temsilci belirtirsiniz.

Sözdizimi

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

Parametreler

Arg1
İlk bağımsız değişkenin türü.

Arg2
İkinci bağımsız değişkenin türü.

Result
Dönüş türü.

Açıklamalar

Genel temsilci iki bağımsız değişkenli bir işlevi açıklar.

Bu işlev şablonlarında:

binary_delegate<int, int, int> Fun1;

binary_delegate<int, int, int> Fun2;

türleri Fun1 ve Fun2 eş anlamlıdır; bunun için:

delegate int Fun1(int, int);

delegate int Fun2(int, int);

aynı türde değil.

Örnek

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

Genel sınıf, döndüren voidiki bağımsız değişkenli bir temsilciyi açıklar. Bağımsız değişkeni açısından bir temsilci belirtmek için bunu kullanırsınız.

Sözdizimi

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

Parametreler

Arg1
İlk bağımsız değişkenin türü.

Arg2
İkinci bağımsız değişkenin türü.

Açıklamalar

Genel temsilci, döndüren voidiki bağımsız değişkenli bir işlevi açıklar.

Bu işlev şablonlarında:

binary_delegate_noreturn<int, int> Fun1;

binary_delegate_noreturn<int, int> Fun2;

türleri Fun1 ve Fun2 eş anlamlıdır; bunun için:

delegate void Fun1(int, int);

delegate void Fun2(int, int);

aynı türde değil.

Örnek

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

Şablon sınıfı çağrıldığında depolanan iki bağımsız değişkenli functor'ının mantıksal DEĞİl değerini döndüren bir functor tanımlar. Saklı funktör açısından bir işlev nesnesi belirtmek için kullanırsınız.

Sözdizimi

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

Parametreler

Fun
Depolanan functor türü.

Üye İşlevleri

Tür Tanımı	Açıklama
delegate_type	Genel temsilcinin türü.
first_argument_type	Functor ilk bağımsız değişkeninin türü.
result_type	Functor sonucunun türü.
second_argument_type	Functor ikinci bağımsız değişkeninin türü.
stored_function_type	Functor türü.

Üye	Açıklama
binary_negate	Functor'ın yapısını oluşturur.

Operator	Açıklama
operator()	İstenen işlevi hesaplar.
operator delegate_type^()	Functor'ı bir temsilciye yayınlar.

Açıklamalar

Şablon sınıfı, başka bir iki bağımsız değişkenli functor depolayan iki bağımsız değişkenli bir functor açıklar. Üye işlecini operator() tanımlar, böylece nesne işlev olarak çağrıldığında, iki bağımsız değişkenle çağrılan depolanan functor'ın mantıksal NOT değerini döndürür.

Ayrıca, nesnesini türü delegate_type^ olan ve uygun şekilde dönüştürülecek bir işlev bağımsız değişkeni olarak geçirebilirsiniz.

Örnek

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

binder1st Bağımsız değişken ve functor için bir oluşturur.

Sözdizimi

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

Şablon Parametreleri

Arg
Bağımsız değişkenin türü.

Fun
Functor türü.

İşlev Parametreleri

functor
Sarma için functor.

left
Kaydıracak ilk bağımsız değişken.

Açıklamalar

İşlev şablonu döndürür binder1st<Fun>(functor, left). İki bağımsız değişkenli bir functor ve ilk bağımsız değişkenini ikinci bağımsız değişkenle çağıran tek bağımsız değişkenli bir functor içinde sarmalamanın kullanışlı bir yolu olarak kullanırsınız.

Örnek

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

binder2nd Bağımsız değişken ve functor için bir oluşturur.

Sözdizimi

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

Şablon Parametreleri

Arg
Bağımsız değişkenin türü.

Fun
Functor türü.

İşlev Parametreleri

functor
Sarma için functor.

right
Kaydıracak ikinci bağımsız değişken.

Açıklamalar

İşlev şablonu döndürür binder2nd<Fun>(functor, right). İki bağımsız değişkenli bir functor ve ikinci bağımsız değişkenini ilk bağımsız değişkenle çağıran tek bağımsız değişkenli bir functor içinde sarmalamanın kullanışlı bir yolu olarak kullanırsınız.

Örnek

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

Şablon sınıfı, çağrıldığında depolanan iki bağımsız değişkenli functor'ını depolanan ilk bağımsız değişkeni ve sağlanan ikinci bağımsız değişkeniyle birlikte döndüren tek bağımsız değişkenli bir functor tanımlar. Saklı funktör açısından bir işlev nesnesi belirtmek için kullanırsınız.

Sözdizimi

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

Parametreler

Fun
Depolanan functor türü.

Üye İşlevleri

Tür Tanımı	Açıklama
delegate_type	Genel temsilcinin türü.
first_argument_type	Functor ilk bağımsız değişkeninin türü.
result_type	Functor sonucunun türü.
second_argument_type	Functor ikinci bağımsız değişkeninin türü.
stored_function_type	Functor türü.

Üye	Açıklama
binder1st	Functor'ın yapısını oluşturur.

Operator	Açıklama
operator()	İstenen işlevi hesaplar.
operator delegate_type^()	Functor'ı bir temsilciye yayınlar.

Açıklamalar

Şablon sınıfı, iki bağımsız değişkenli bir functor ve ilk bağımsız değişkeni depolayan tek bağımsız değişkenli bir functor'ı açıklar. Üye işlecini operator() tanımlar, böylece nesne işlev olarak çağrıldığında depolanan ilk bağımsız değişken ve sağlanan ikinci bağımsız değişken ile depolanan functor'ı çağırmanın sonucunu döndürür.

Ayrıca, nesnesini türü delegate_type^ olan ve uygun şekilde dönüştürülecek bir işlev bağımsız değişkeni olarak geçirebilirsiniz.

Örnek

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

Şablon sınıfı, çağrıldığında, sağlanan ilk bağımsız değişken ve depolanan ikinci bağımsız değişkeniyle çağrılan saklı iki bağımsız değişkenli functor'ını döndüren tek bağımsız değişkenli bir functor açıklar. Saklı funktör açısından bir işlev nesnesi belirtmek için kullanırsınız.

Sözdizimi

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

Parametreler

Fun
Depolanan functor türü.

Üye İşlevleri

Tür Tanımı	Açıklama
delegate_type	Genel temsilcinin türü.
first_argument_type	Functor ilk bağımsız değişkeninin türü.
result_type	Functor sonucunun türü.
second_argument_type	Functor ikinci bağımsız değişkeninin türü.
stored_function_type	Functor türü.

Üye	Açıklama
binder2nd	Functor'ın yapısını oluşturur.

Operator	Açıklama
operator()	İstenen işlevi hesaplar.
operator delegate_type^()	Functor'ı bir temsilciye yayınlar.

Açıklamalar

Şablon sınıfı, iki bağımsız değişkenli bir functor ve ikinci bir bağımsız değişken depolayan tek bağımsız değişkenli bir functor'ı açıklar. Üye işlecini operator() tanımlar, böylece nesne işlev olarak çağrıldığında, sağlanan ilk bağımsız değişken ve depolanan ikinci bağımsız değişkenle depolanan functor'ı çağırmanın sonucunu döndürür.

Ayrıca, nesnesini türü delegate_type^ olan ve uygun şekilde dönüştürülecek bir işlev bağımsız değişkeni olarak geçirebilirsiniz.

Örnek

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

Şablon sınıfı, çağrıldığında ikinciye bölünen ilk bağımsız değişkeni döndüren bir functor açıklar. Bağımsız değişken türü açısından bir işlev nesnesi belirtirken bunu kullanırsınız.

Sözdizimi

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

Parametreler

Arg
Bağımsız değişkenlerin ve dönüş değerinin türü.

Üye İşlevleri

Tür Tanımı	Açıklama
delegate_type	Genel temsilcinin türü.
first_argument_type	Functor ilk bağımsız değişkeninin türü.
result_type	Functor sonucunun türü.
second_argument_type	Functor ikinci bağımsız değişkeninin türü.

Üye	Açıklama
divides	Functor'ın yapısını oluşturur.

Operator	Açıklama
operator()	İstenen işlevi hesaplar.
operator delegate_type^()	Functor'ı bir temsilciye yayınlar.

Açıklamalar

Şablon sınıfı iki bağımsız değişkenli bir functor açıklar. Üye işlecini operator() tanımlar, böylece nesne işlev olarak çağrıldığında ilk bağımsız değişkeni saniyeye bölünerek döndürür.

Ayrıca, nesnesini türü delegate_type^ olan ve uygun şekilde dönüştürülecek bir işlev bağımsız değişkeni olarak geçirebilirsiniz.

Örnek

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

Şablon sınıfı, çağrıldığında yalnızca ilk bağımsız değişken ikinciye eşitse true döndüren bir functor tanımlar. Bağımsız değişken türü açısından bir işlev nesnesi belirtirken bunu kullanırsınız.

Sözdizimi

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

Parametreler

Arg
Bağımsız değişkenlerin türü.

Üye İşlevleri

Tür Tanımı	Açıklama
delegate_type	Genel temsilcinin türü.
first_argument_type	Functor ilk bağımsız değişkeninin türü.
result_type	Functor sonucunun türü.
second_argument_type	Functor ikinci bağımsız değişkeninin türü.

Üye	Açıklama
equal_to	Functor'ın yapısını oluşturur.

Operator	Açıklama
operator()	İstenen işlevi hesaplar.
operator delegate_type^()	Functor'ı bir temsilciye yayınlar.

Açıklamalar

Şablon sınıfı iki bağımsız değişkenli bir functor açıklar. Üye işlecini operator() tanımlar, böylece nesne işlev olarak çağrıldığında yalnızca ilk bağımsız değişken ikinciye eşitse true döndürür.

Ayrıca, nesnesini türü delegate_type^ olan ve uygun şekilde dönüştürülecek bir işlev bağımsız değişkeni olarak geçirebilirsiniz.

Örnek

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

Şablon sınıfı, çağrıldığında yalnızca ilk bağımsız değişken ikinciden büyükse true döndüren bir functor tanımlar. Bağımsız değişken türü açısından bir işlev nesnesi belirtirken bunu kullanırsınız.

Sözdizimi

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

Parametreler

Arg
Bağımsız değişkenlerin türü.

Üye İşlevleri

Tür Tanımı	Açıklama
delegate_type	Genel temsilcinin türü.
first_argument_type	Functor ilk bağımsız değişkeninin türü.
result_type	Functor sonucunun türü.
second_argument_type	Functor ikinci bağımsız değişkeninin türü.

Üye	Açıklama
greater	Functor'ın yapısını oluşturur.

Operator	Açıklama
operator()	İstenen işlevi hesaplar.
operator delegate_type^	Functor'ı bir temsilciye yayınlar.

Açıklamalar

Şablon sınıfı iki bağımsız değişkenli bir functor açıklar. Üye işlecini operator() tanımlar, böylece nesne işlev olarak çağrıldığında yalnızca ilk bağımsız değişken ikinciden büyükse true değerini döndürür.

Ayrıca, nesnesini türü delegate_type^ olan ve uygun şekilde dönüştürülecek bir işlev bağımsız değişkeni olarak geçirebilirsiniz.

Örnek

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

Şablon sınıfı, çağrıldığında yalnızca ilk bağımsız değişken ikinciden büyük veya ona eşitse true döndüren bir functor tanımlar. Bağımsız değişken türü açısından bir işlev nesnesi belirtirken bunu kullanırsınız.

Sözdizimi

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

Parametreler

Arg
Bağımsız değişkenlerin türü.

Üye İşlevleri

Tür Tanımı	Açıklama
delegate_type	Genel temsilcinin türü.
first_argument_type	Functor ilk bağımsız değişkeninin türü.
result_type	Functor sonucunun türü.
second_argument_type	Functor ikinci bağımsız değişkeninin türü.

Üye	Açıklama
greater_equal	Functor'ın yapısını oluşturur.

Operator	Açıklama
operator()	İstenen işlevi hesaplar.
operator delegate_type^	Functor'ı bir temsilciye yayınlar.

Açıklamalar

Şablon sınıfı iki bağımsız değişkenli bir functor açıklar. Üye işlecini operator() tanımlar, böylece nesne işlev olarak çağrıldığında yalnızca ilk bağımsız değişken ikinciden büyük veya ona eşitse true döndürür.

Ayrıca, nesnesini türü delegate_type^ olan ve uygun şekilde dönüştürülecek bir işlev bağımsız değişkeni olarak geçirebilirsiniz.

Örnek

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

Şablon sınıfı, çağrıldığında yalnızca ilk bağımsız değişken ikinciden küçükse true döndüren bir functor tanımlar. Bağımsız değişken türü açısından bir işlev nesnesi belirtirken bunu kullanırsınız.

Sözdizimi

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

Parametreler

Arg
Bağımsız değişkenlerin türü.

Üye İşlevleri

Tür Tanımı	Açıklama
delegate_type	Genel temsilcinin türü.
first_argument_type	Functor ilk bağımsız değişkeninin türü.
result_type	Functor sonucunun türü.
second_argument_type	Functor ikinci bağımsız değişkeninin türü.

Üye	Açıklama
less	Functor'ın yapısını oluşturur.

Operator	Açıklama
operator()	İstenen işlevi hesaplar.
operator delegate_type^	Functor'ı bir temsilciye yayınlar.

Açıklamalar

Şablon sınıfı iki bağımsız değişkenli bir functor açıklar. Üye işlecini operator() tanımlar, böylece nesne işlev olarak çağrıldığında yalnızca ilk bağımsız değişken ikinciden küçükse true değerini döndürür.

Ayrıca, nesnesini türü delegate_type^ olan ve uygun şekilde dönüştürülecek bir işlev bağımsız değişkeni olarak geçirebilirsiniz.

Örnek

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

Şablon sınıfı, çağrıldığında yalnızca ilk bağımsız değişken ikinciye eşit veya ondan küçükse true döndüren bir functor tanımlar. Bağımsız değişken türü açısından bir işlev nesnesi belirtirken bunu kullanırsınız.

Sözdizimi

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

Parametreler

Arg
Bağımsız değişkenlerin türü.

Üye İşlevleri

Tür Tanımı	Açıklama
delegate_type	Genel temsilcinin türü.
first_argument_type	Functor ilk bağımsız değişkeninin türü.
result_type	Functor sonucunun türü.
second_argument_type	Functor ikinci bağımsız değişkeninin türü.

Üye	Açıklama
less_equal	Functor'ın yapısını oluşturur.

Operator	Açıklama
operator()	İstenen işlevi hesaplar.
operator delegate_type^	Functor'ı bir temsilciye yayınlar.

Açıklamalar

Şablon sınıfı iki bağımsız değişkenli bir functor açıklar. Üye işlecini operator() tanımlar, böylece nesne işlev olarak çağrıldığında yalnızca ilk bağımsız değişken ikinciye eşit veya daha küçükse true döndürür.

Ayrıca, nesnesini türü delegate_type^ olan ve uygun şekilde dönüştürülecek bir işlev bağımsız değişkeni olarak geçirebilirsiniz.

Örnek

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

Şablon sınıfı, çağrıldığında yalnızca hem ilk bağımsız değişken hem de ikinci test true olduğunda true döndüren bir functor tanımlar. Bağımsız değişken türü açısından bir işlev nesnesi belirtirken bunu kullanırsınız.

Sözdizimi

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

Parametreler

Arg
Bağımsız değişkenlerin türü.

Üye İşlevleri

Tür Tanımı	Açıklama
delegate_type	Genel temsilcinin türü.
first_argument_type	Functor ilk bağımsız değişkeninin türü.
result_type	Functor sonucunun türü.
second_argument_type	Functor ikinci bağımsız değişkeninin türü.

Üye	Açıklama
logical_and	Functor'ın yapısını oluşturur.

Operator	Açıklama
operator()	İstenen işlevi hesaplar.
operator delegate_type^	Functor'ı bir temsilciye yayınlar.

Açıklamalar

Şablon sınıfı iki bağımsız değişkenli bir functor açıklar. Üye işlecini operator() tanımlar, böylece nesne işlev olarak çağrıldığında yalnızca hem ilk bağımsız değişken hem de ikinci test true olduğunda true değerini döndürür.

Ayrıca, nesnesini türü delegate_type^ olan ve uygun şekilde dönüştürülecek bir işlev bağımsız değişkeni olarak geçirebilirsiniz.

Örnek

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

Şablon sınıfı, çağrıldığında yalnızca bağımsız değişkeni false olarak test edildiğinde true döndüren bir functor tanımlar. Bağımsız değişken türü açısından bir işlev nesnesi belirtirken bunu kullanırsınız.

Sözdizimi

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

Parametreler

Arg
Bağımsız değişkenlerin türü.

Üye İşlevleri

Tür Tanımı	Açıklama
argument_type	Functor bağımsız değişkeninin türü.
delegate_type	Genel temsilcinin türü.
result_type	Functor sonucunun türü.

Üye	Açıklama
logical_not	Functor'ın yapısını oluşturur.

Operator	Açıklama
operator()	İstenen işlevi hesaplar.
operator delegate_type^	Functor'ı bir temsilciye yayınlar.

Açıklamalar

Şablon sınıfı tek bağımsız değişkenli bir functor açıklar. Üye işlecini operator() tanımlar, böylece nesne işlev olarak çağrıldığında yalnızca bağımsız değişkeni false olarak test ederse true değerini döndürür.

Ayrıca, nesnesini türü delegate_type^ olan ve uygun şekilde dönüştürülecek bir işlev bağımsız değişkeni olarak geçirebilirsiniz.

Örnek

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

Şablon sınıfı, çağrıldığında yalnızca ilk bağımsız değişken veya ikinci test doğru olduğunda true döndüren bir functor tanımlar. Bağımsız değişken türü açısından bir işlev nesnesi belirtirken bunu kullanırsınız.

Sözdizimi

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

Parametreler

Arg
Bağımsız değişkenlerin türü.

Üye İşlevleri

Tür Tanımı	Açıklama
delegate_type	Genel temsilcinin türü.
first_argument_type	Functor ilk bağımsız değişkeninin türü.
result_type	Functor sonucunun türü.
second_argument_type	Functor ikinci bağımsız değişkeninin türü.

Üye	Açıklama
logical_or	Functor'ın yapısını oluşturur.

Operator	Açıklama
operator()	İstenen işlevi hesaplar.
operator delegate_type^	Functor'ı bir temsilciye yayınlar.

Açıklamalar

Şablon sınıfı iki bağımsız değişkenli bir functor açıklar. Üye işlecini operator() tanımlar, böylece nesne işlev olarak çağrıldığında yalnızca ilk bağımsız değişken veya ikinci test doğru olduğunda true döndürür.

Ayrıca, nesnesini türü delegate_type^ olan ve uygun şekilde dönüştürülecek bir işlev bağımsız değişkeni olarak geçirebilirsiniz.

Örnek

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

Şablon sınıfı, çağrıldığında ilk bağımsız değişkeni eksi ikinciyi döndüren bir functor açıklar. Bağımsız değişken türü açısından bir işlev nesnesi belirtirken bunu kullanırsınız.

Sözdizimi

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

Parametreler

Arg
Bağımsız değişkenlerin ve dönüş değerinin türü.

Üye İşlevleri

Tür Tanımı	Açıklama
delegate_type	Genel temsilcinin türü.
first_argument_type	Functor ilk bağımsız değişkeninin türü.
result_type	Functor sonucunun türü.
second_argument_type	Functor ikinci bağımsız değişkeninin türü.

Üye	Açıklama
minus	Functor'ın yapısını oluşturur.

Operator	Açıklama
operator()	İstenen işlevi hesaplar.
operator delegate_type^	Functor'ı bir temsilciye yayınlar.

Açıklamalar

Şablon sınıfı iki bağımsız değişkenli bir functor açıklar. Üye işlecini operator() tanımlar, böylece nesne işlev olarak çağrıldığında ilk bağımsız değişken eksi ikinciyi döndürür.

Ayrıca, nesnesini türü delegate_type^ olan ve uygun şekilde dönüştürülecek bir işlev bağımsız değişkeni olarak geçirebilirsiniz.

Örnek

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

Şablon sınıfı, çağrıldığında ikincinin ilk bağımsız değişken modülunu döndüren bir functor açıklar. Bağımsız değişken türü açısından bir işlev nesnesi belirtirken bunu kullanırsınız.

Sözdizimi

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

Parametreler

Arg
Bağımsız değişkenlerin ve dönüş değerinin türü.

Üye İşlevleri

Tür Tanımı	Açıklama
delegate_type	Genel temsilcinin türü.
first_argument_type	Functor ilk bağımsız değişkeninin türü.
result_type	Functor sonucunun türü.
second_argument_type	Functor ikinci bağımsız değişkeninin türü.

Üye	Açıklama
modulus	Functor'ın yapısını oluşturur.

Operator	Açıklama
operator()	İstenen işlevi hesaplar.
operator delegate_type^	Functor'ı bir temsilciye yayınlar.

Açıklamalar

Şablon sınıfı iki bağımsız değişkenli bir functor açıklar. Üye işlecini operator() tanımlar, böylece nesne işlev olarak çağrıldığında ikinci bağımsız değişken modülünü döndürür.

Ayrıca, nesnesini türü delegate_type^ olan ve uygun şekilde dönüştürülecek bir işlev bağımsız değişkeni olarak geçirebilirsiniz.

Örnek

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

Şablon sınıfı, çağrıldığında ikincinin ilk bağımsız değişkenini döndüren bir functor tanımlar. Bağımsız değişken türü açısından bir işlev nesnesi belirtirken bunu kullanırsınız.

Sözdizimi

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

Parametreler

Arg
Bağımsız değişkenlerin ve dönüş değerinin türü.

Üye İşlevleri

Tür Tanımı	Açıklama
delegate_type	Genel temsilcinin türü.
first_argument_type	Functor ilk bağımsız değişkeninin türü.
result_type	Functor sonucunun türü.
second_argument_type	Functor ikinci bağımsız değişkeninin türü.

Üye	Açıklama
multiplies	Functor'ın yapısını oluşturur.

Operator	Açıklama
operator()	İstenen işlevi hesaplar.
operator delegate_type^	Functor'ı bir temsilciye yayınlar.

Açıklamalar

Şablon sınıfı iki bağımsız değişkenli bir functor açıklar. Üye işlecini operator() tanımlar, böylece nesne işlev olarak çağrıldığında ilk bağımsız değişkenin ikincisini döndürür.

Ayrıca, nesnesini türü delegate_type^ olan ve uygun şekilde dönüştürülecek bir işlev bağımsız değişkeni olarak geçirebilirsiniz.

Örnek

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

Şablon sınıfı çağrıldığında bağımsız değişkenini olumsuzlayan bir functor tanımlar. Bağımsız değişken türü açısından bir işlev nesnesi belirtirken bunu kullanırsınız.

Sözdizimi

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

Parametreler

Arg
Bağımsız değişkenlerin türü.

Üye İşlevleri

Tür Tanımı	Açıklama
argument_type	Functor bağımsız değişkeninin türü.
delegate_type	Genel temsilcinin türü.
result_type	Functor sonucunun türü.

Üye	Açıklama
negate	Functor'ın yapısını oluşturur.

Operator	Açıklama
operator()	İstenen işlevi hesaplar.
operator delegate_type^	Functor'ı bir temsilciye yayınlar.

Açıklamalar

Şablon sınıfı tek bağımsız değişkenli bir functor açıklar. Üye işlecini operator() tanımlar, böylece nesne işlev olarak çağrıldığında bağımsız değişkenini olumsuz olarak döndürür.

Ayrıca, nesnesini türü delegate_type^ olan ve uygun şekilde dönüştürülecek bir işlev bağımsız değişkeni olarak geçirebilirsiniz.

Örnek

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

Şablon sınıfı, çağrıldığında yalnızca ilk bağımsız değişken ikinciye eşit değilse true döndüren bir functor tanımlar. Bağımsız değişken türü açısından bir işlev nesnesi belirtirken bunu kullanırsınız.

Sözdizimi

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

Parametreler

Arg
Bağımsız değişkenlerin türü.

Üye İşlevleri

Tür Tanımı	Açıklama
delegate_type	Genel temsilcinin türü.
first_argument_type	Functor ilk bağımsız değişkeninin türü.
result_type	Functor sonucunun türü.
second_argument_type	Functor ikinci bağımsız değişkeninin türü.

Üye	Açıklama
not_equal_to	Functor'ın yapısını oluşturur.

Operator	Açıklama
operator()	İstenen işlevi hesaplar.
operator delegate_type^	Functor'ı bir temsilciye yayınlar.

Açıklamalar

Şablon sınıfı iki bağımsız değişkenli bir functor açıklar. Üye işlecini operator() tanımlar, böylece nesne işlev olarak çağrıldığında yalnızca ilk bağımsız değişken ikinciye eşit değilse true değerini döndürür.

Ayrıca, nesnesini türü delegate_type^ olan ve uygun şekilde dönüştürülecek bir işlev bağımsız değişkeni olarak geçirebilirsiniz.

Örnek

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

Bir functor için bir unary_negate oluşturur.

Sözdizimi

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

Şablon Parametreleri

Fun
Functor türü.

İşlev Parametreleri

functor
Sarma için functor.

Açıklamalar

İşlev şablonu döndürür unary_negate<Fun>(functor). Tek bağımsız değişkenli bir functor'ı mantıksal NOT değerini sunan bir functor içinde sarmalamanın kullanışlı bir yolu olarak kullanırsınız.

Örnek

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

Bir functor için bir binary_negate oluşturur.

Sözdizimi

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

Şablon Parametreleri

Fun
Functor türü.

İşlev Parametreleri

functor
Sarma için functor.

Açıklamalar

İşlev şablonu döndürür binary_negate<Fun>(functor). İki bağımsız değişkenli bir functor'ı mantıksal NOT değerini sunan bir functor içinde sarmalamanın kullanışlı bir yolu olarak kullanırsınız.

Örnek

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

Şablon sınıfı, çağrıldığında ilk bağımsız değişkeni ve ikinciyi döndüren bir functor açıklar. Bağımsız değişken türü açısından bir işlev nesnesi belirtirken bunu kullanırsınız.

Sözdizimi

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

Parametreler

Arg
Bağımsız değişkenlerin ve dönüş değerinin türü.

Üye İşlevleri

Tür Tanımı	Açıklama
delegate_type	Genel temsilcinin türü.
first_argument_type	Functor ilk bağımsız değişkeninin türü.
result_type	Functor sonucunun türü.
second_argument_type	Functor ikinci bağımsız değişkeninin türü.

Üye	Açıklama
plus	Functor'ın yapısını oluşturur.

Operator	Açıklama
operator()	İstenen işlevi hesaplar.
operator delegate_type^	Functor'ı bir temsilciye yayınlar.

Açıklamalar

Şablon sınıfı iki bağımsız değişkenli bir functor açıklar. Üye işlecini operator() tanımlar, böylece nesne işlev olarak çağrıldığında ilk bağımsız değişkeni ve ikinciyi döndürür.

Ayrıca, nesnesini türü delegate_type^ olan ve uygun şekilde dönüştürülecek bir işlev bağımsız değişkeni olarak geçirebilirsiniz.

Örnek

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

Genel sınıf tek bağımsız değişkenli bir temsilciyi açıklar. Bağımsız değişkeni ve dönüş türleri açısından bir temsilci belirtirsiniz.

Sözdizimi

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

Parametreler

Arg
Bağımsız değişkenin türü.

Result
Dönüş türü.

Açıklamalar

Genel temsilci tek bağımsız değişkenli bir işlevi açıklar.

Bu işlev şablonlarında:

unary_delegate<int, int> Fun1;

unary_delegate<int, int> Fun2;

türleri Fun1 ve Fun2 eş anlamlıdır; bunun için:

delegate int Fun1(int);

delegate int Fun2(int);

aynı türde değil.

Örnek

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

Genel sınıf, döndüren voidtek bağımsız değişkenli bir temsilciyi açıklar. Bir temsilciyi bağımsız değişken türü açısından belirtirsiniz.

Sözdizimi

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

Parametreler

Arg
Bağımsız değişkenin türü.

Açıklamalar

Genel temsilci, döndüren voidtek bağımsız değişkenli bir işlevi açıklar.

Bu işlev şablonlarında:

unary_delegate_noreturn<int> Fun1;

unary_delegate_noreturn<int> Fun2;

türleri Fun1 ve Fun2 eş anlamlıdır; bunun için:

delegate void Fun1(int);

delegate void Fun2(int);

aynı türde değil.

Örnek

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

Şablon sınıfı çağrıldığında depolanan tek bağımsız değişkenli functor'ının mantıksal DEĞİl değerini döndüren bir functor tanımlar. Saklı funktör açısından bir işlev nesnesi belirtmek için kullanırsınız.

Sözdizimi

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

Parametreler

Fun
Depolanan functor türü.

Üye İşlevleri

Tür Tanımı	Açıklama
argument_type	Functor bağımsız değişkeninin türü.
delegate_type	Genel temsilcinin türü.
result_type	Functor sonucunun türü.

Üye	Açıklama
unary_negate	Functor'ın yapısını oluşturur.

Operator	Açıklama
operator()	İstenen işlevi hesaplar.
delegate_type^	Functor'ı bir temsilciye yayınlar.

Açıklamalar

Şablon sınıfı, başka bir bağımsız değişkenli functor depolayan tek bağımsız değişkenli bir functor'i açıklar. Üye işlecini operator() tanımlar, böylece nesne işlev olarak çağrıldığında bağımsız değişkeniyle çağrılan depolanan functor'ın mantıksal NOT değerini döndürür.

Ayrıca, nesnesini türü delegate_type^ olan ve uygun şekilde dönüştürülecek bir işlev bağımsız değişkeni olarak geçirebilirsiniz.

Örnek

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