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