functional (STL/CLR)
Includere l'intestazione <cliext/functional> STL/CLR per definire modelli di classe funzionale e delegati e funzioni del modello correlati.
Sintassi
#include <functional>
Requisiti
Intestazione:<cliext/functional>
Spazio dei nomi: cliext
Dichiarazioni
| Delegare | Descrizione |
|---|---|
binary_delegate (STL/CLR) |
Delegato a due argomenti. |
binary_delegate_noreturn (STL/CLR) |
Delegato a due argomenti che restituisce void. |
unary_delegate (STL/CLR) |
Delegato a un solo argomento. |
unary_delegate_noreturn (STL/CLR) |
Delegato a un argomento che restituisce void. |
| Classe | Descrizione |
|---|---|
binary_negate (STL/CLR) |
Functor per negare un funtore a due argomenti. |
binder1st (STL/CLR) |
Functor per associare il primo argomento a un funtore a due argomenti. |
binder2nd (STL/CLR) |
Functor per associare il secondo argomento a un funtore a due argomenti. |
divides (STL/CLR) |
Divide functor. |
equal_to (STL/CLR) |
Funtore di confronto uguale. |
greater (STL/CLR) |
Funtore di confronto maggiore. |
greater_equal (STL/CLR) |
Funtore di confronto maggiore o uguale. |
less (STL/CLR) |
Funtore di confronto minore. |
less_equal (STL/CLR) |
Funtore di confronto minore o uguale. |
logical_and (STL/CLR) |
Funtore AND logico. |
logical_not (STL/CLR) |
Funtore NOT logico. |
logical_or (STL/CLR) |
Funtore OR logico. |
minus (STL/CLR) |
Sottrae funtore. |
modulus (STL/CLR) |
Functor modulo. |
multiplies (STL/CLR) |
Moltiplicare il funtore. |
negate (STL/CLR) |
Functor per restituire l'argomento negato. |
not_equal_to (STL/CLR) |
Funtore di confronto diverso. |
plus (STL/CLR) |
Aggiungere functor. |
unary_negate (STL/CLR) |
Functor per negare un funtore a un argomento. |
| Funzione | Descrizione |
|---|---|
bind1st (STL/CLR) |
Genera un binder1st per un argomento e un funtore. |
bind2nd (STL/CLR) |
Genera un binder2nd per un argomento e un funtore. |
not1 (STL/CLR) |
Genera un unary_negate per un functor. |
not2 (STL/CLR) |
Genera un binary_negate per un functor. |
Membri
binary_delegate (STL/CLR)
La classe generica descrive un delegato a due argomenti. Viene usato per specificare un delegato in termini di argomento e tipi restituiti.
Sintassi
generic<typename Arg1,
typename Arg2,
typename Result>
delegate Result binary_delegate(Arg1, Arg2);
Parametri
Arg1
Tipo del primo argomento.
Arg2
Tipo del secondo argomento.
Result
Tipo restituito.
Osservazioni:
Il delegato generico descrive una funzione a due argomenti.
Nei modelli di funzione seguenti:
binary_delegate<int, int, int> Fun1;
binary_delegate<int, int, int> Fun2;
i tipi Fun1 e Fun2 sono sinonimi, mentre per:
delegate int Fun1(int, int);
delegate int Fun2(int, int);
non sono dello stesso tipo.
Esempio
// 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)
La classe generica descrive un delegato a due argomenti che restituisce void. Viene usato per specificare un delegato in termini di argomento.
Sintassi
generic<typename Arg1,
typename Arg2>
delegate void binary_delegate(Arg1, Arg2);
Parametri
Arg1
Tipo del primo argomento.
Arg2
Tipo del secondo argomento.
Osservazioni:
Il delegato generico descrive una funzione a due argomenti che restituisce void.
Nei modelli di funzione seguenti:
binary_delegate_noreturn<int, int> Fun1;
binary_delegate_noreturn<int, int> Fun2;
i tipi Fun1 e Fun2 sono sinonimi, mentre per:
delegate void Fun1(int, int);
delegate void Fun2(int, int);
non sono dello stesso tipo.
Esempio
// 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)
La classe modello descrive un funtore che, quando viene chiamato, restituisce il NOT logico del funtore a due argomenti archiviato. Viene usato per specificare un oggetto funzione in termini di funtore archiviato.
Sintassi
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^();
};
Parametri
Fun
Tipo del funtore archiviato.
Funzioni di membro
| Definizione del tipo | Descrizione |
|---|---|
delegate_type |
Tipo del delegato generico. |
first_argument_type |
Tipo del functor primo argomento. |
result_type |
Tipo del risultato del funtore. |
second_argument_type |
Tipo del secondo argomento functor. |
stored_function_type |
Tipo del funtore. |
| Membro | Descrizione |
|---|---|
binary_negate |
Costruisce il funtore. |
| Operatore | Descrizione |
|---|---|
operator() |
Calcola la funzione desiderata. |
operator delegate_type^() |
Esegue il cast del funtore a un delegato. |
Osservazioni:
La classe modello descrive un funtore a due argomenti che archivia un altro funtore a due argomenti. Definisce l'operatore operator() membro in modo che, quando l'oggetto viene chiamato come funzione, restituisce il NOT logico del funtore archiviato chiamato con i due argomenti.
È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.
Esempio
// 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)
Genera un oggetto per un binder1st argomento e un funtore.
Sintassi
template<typename Fun,
typename Arg>
binder1st<Fun> bind1st(Fun% functor,
Arg left);
Parametri modello
Arg
Il tipo di argomento.
Fun
Tipo del funtore.
Parametri della funzione
functor
Funtore da avvolgere.
left
Primo argomento a capo.
Osservazioni:
Il modello di funzione restituisce binder1st<Fun>(functor, left). Lo si usa come modo pratico per eseguire il wrapping di un funtore a due argomenti e il primo argomento in un funtore a un argomento che lo chiama con un secondo argomento.
Esempio
// 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)
Genera un oggetto per un binder2nd argomento e un funtore.
Sintassi
template<typename Fun,
typename Arg>
binder2nd<Fun> bind2nd(Fun% functor,
Arg right);
Parametri modello
Arg
Il tipo di argomento.
Fun
Tipo del funtore.
Parametri della funzione
functor
Funtore da avvolgere.
right
Secondo argomento di cui eseguire il wrapping.
Osservazioni:
Il modello di funzione restituisce binder2nd<Fun>(functor, right). Lo si usa come modo pratico per eseguire il wrapping di un funtore a due argomenti e il secondo argomento in un funtore a un argomento che lo chiama con un primo argomento.
Esempio
// 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)
La classe modello descrive un funtore a un argomento che, quando viene chiamato, restituisce il funtore a due argomenti archiviato chiamato con il primo argomento archiviato e il secondo argomento fornito. Viene usato per specificare un oggetto funzione in termini di funtore archiviato.
Sintassi
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^();
};
Parametri
Fun
Tipo del funtore archiviato.
Funzioni di membro
| Definizione del tipo | Descrizione |
|---|---|
delegate_type |
Tipo del delegato generico. |
first_argument_type |
Tipo del functor primo argomento. |
result_type |
Tipo del risultato del funtore. |
second_argument_type |
Tipo del secondo argomento functor. |
stored_function_type |
Tipo del funtore. |
| Membro | Descrizione |
|---|---|
binder1st |
Costruisce il funtore. |
| Operatore | Descrizione |
|---|---|
operator() |
Calcola la funzione desiderata. |
operator delegate_type^() |
Esegue il cast del funtore a un delegato. |
Osservazioni:
La classe modello descrive un funtore a un argomento che archivia un funtore a due argomenti e un primo argomento. Definisce l'operatore operator() membro in modo che, quando l'oggetto viene chiamato come funzione, restituisce il risultato della chiamata del funtore archiviato con il primo argomento archiviato e il secondo argomento fornito.
È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.
Esempio
// 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)
La classe modello descrive un funtore a un argomento che, quando viene chiamato, restituisce il funtore a due argomenti archiviato chiamato con il primo argomento fornito e il secondo argomento archiviato. Viene usato per specificare un oggetto funzione in termini di funtore archiviato.
Sintassi
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^();
};
Parametri
Fun
Tipo del funtore archiviato.
Funzioni di membro
| Definizione del tipo | Descrizione |
|---|---|
delegate_type |
Tipo del delegato generico. |
first_argument_type |
Tipo del functor primo argomento. |
result_type |
Tipo del risultato del funtore. |
second_argument_type |
Tipo del secondo argomento functor. |
stored_function_type |
Tipo del funtore. |
| Membro | Descrizione |
|---|---|
binder2nd |
Costruisce il funtore. |
| Operatore | Descrizione |
|---|---|
operator() |
Calcola la funzione desiderata. |
operator delegate_type^() |
Esegue il cast del funtore a un delegato. |
Osservazioni:
La classe modello descrive un funtore a un argomento che archivia un funtore a due argomenti e un secondo argomento. Definisce l'operatore operator() membro in modo che, quando l'oggetto viene chiamato come funzione, restituisce il risultato della chiamata del funtore archiviato con il primo argomento fornito e il secondo argomento archiviato.
È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.
Esempio
// 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)
La classe modello descrive un funtore che, quando viene chiamato, restituisce il primo argomento diviso per il secondo. Viene usato per specificare un oggetto funzione in termini di tipo argomento.
Sintassi
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^();
};
Parametri
Arg
Tipo di argomenti e valore restituito.
Funzioni di membro
| Definizione del tipo | Descrizione |
|---|---|
delegate_type |
Tipo del delegato generico. |
first_argument_type |
Tipo del functor primo argomento. |
result_type |
Tipo del risultato del funtore. |
second_argument_type |
Tipo del secondo argomento functor. |
| Membro | Descrizione |
|---|---|
divides |
Costruisce il funtore. |
| Operatore | Descrizione |
|---|---|
operator() |
Calcola la funzione desiderata. |
operator delegate_type^() |
Esegue il cast del funtore a un delegato. |
Osservazioni:
La classe modello descrive un funtore a due argomenti. Definisce l'operatore operator() membro in modo che, quando l'oggetto viene chiamato come funzione, restituisce il primo argomento diviso per il secondo.
È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.
Esempio
// 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)
La classe modello descrive un funtore che, quando viene chiamato, restituisce true solo se il primo argomento è uguale al secondo. Viene usato per specificare un oggetto funzione in termini di tipo argomento.
Sintassi
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^();
};
Parametri
Arg
Tipo degli argomenti.
Funzioni di membro
| Definizione del tipo | Descrizione |
|---|---|
delegate_type |
Tipo del delegato generico. |
first_argument_type |
Tipo del functor primo argomento. |
result_type |
Tipo del risultato del funtore. |
second_argument_type |
Tipo del secondo argomento functor. |
| Membro | Descrizione |
|---|---|
equal_to |
Costruisce il funtore. |
| Operatore | Descrizione |
|---|---|
operator() |
Calcola la funzione desiderata. |
operator delegate_type^() |
Esegue il cast del funtore a un delegato. |
Osservazioni:
La classe modello descrive un funtore a due argomenti. Definisce l'operatore operator() membro in modo che, quando l'oggetto viene chiamato come funzione, restituisce true solo se il primo argomento è uguale al secondo.
È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.
Esempio
// 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)
La classe modello descrive un funtore che, quando viene chiamato, restituisce true solo se il primo argomento è maggiore del secondo. Viene usato per specificare un oggetto funzione in termini di tipo argomento.
Sintassi
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^();
};
Parametri
Arg
Tipo degli argomenti.
Funzioni di membro
| Definizione del tipo | Descrizione |
|---|---|
delegate_type |
Tipo del delegato generico. |
first_argument_type |
Tipo del functor primo argomento. |
result_type |
Tipo del risultato del funtore. |
second_argument_type |
Tipo del secondo argomento functor. |
| Membro | Descrizione |
|---|---|
greater |
Costruisce il funtore. |
| Operatore | Descrizione |
|---|---|
operator() |
Calcola la funzione desiderata. |
operator delegate_type^ |
Esegue il cast del funtore a un delegato. |
Osservazioni:
La classe modello descrive un funtore a due argomenti. Definisce l'operatore operator() membro in modo che, quando l'oggetto viene chiamato come funzione, restituisce true solo se il primo argomento è maggiore del secondo.
È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.
Esempio
// 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)
La classe modello descrive un funtore che, quando viene chiamato, restituisce true solo se il primo argomento è maggiore o uguale al secondo. Viene usato per specificare un oggetto funzione in termini di tipo argomento.
Sintassi
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^();
};
Parametri
Arg
Tipo degli argomenti.
Funzioni di membro
| Definizione del tipo | Descrizione |
|---|---|
delegate_type |
Tipo del delegato generico. |
first_argument_type |
Tipo del functor primo argomento. |
result_type |
Tipo del risultato del funtore. |
second_argument_type |
Tipo del secondo argomento functor. |
| Membro | Descrizione |
|---|---|
greater_equal |
Costruisce il funtore. |
| Operatore | Descrizione |
|---|---|
operator() |
Calcola la funzione desiderata. |
operator delegate_type^ |
Esegue il cast del funtore a un delegato. |
Osservazioni:
La classe modello descrive un funtore a due argomenti. Definisce l'operatore operator() membro in modo che, quando l'oggetto viene chiamato come funzione, restituisce true solo se il primo argomento è maggiore o uguale al secondo.
È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.
Esempio
// 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)
La classe modello descrive un funtore che, quando viene chiamato, restituisce true solo se il primo argomento è minore del secondo. Viene usato per specificare un oggetto funzione in termini di tipo argomento.
Sintassi
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^();
};
Parametri
Arg
Tipo degli argomenti.
Funzioni di membro
| Definizione del tipo | Descrizione |
|---|---|
delegate_type |
Tipo del delegato generico. |
first_argument_type |
Tipo del functor primo argomento. |
result_type |
Tipo del risultato del funtore. |
second_argument_type |
Tipo del secondo argomento functor. |
| Membro | Descrizione |
|---|---|
less |
Costruisce il funtore. |
| Operatore | Descrizione |
|---|---|
operator() |
Calcola la funzione desiderata. |
operator delegate_type^ |
Esegue il cast del funtore a un delegato. |
Osservazioni:
La classe modello descrive un funtore a due argomenti. Definisce l'operatore operator() membro in modo che, quando l'oggetto viene chiamato come funzione, restituisce true solo se il primo argomento è minore del secondo.
È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.
Esempio
// 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)
La classe modello descrive un funtore che, quando viene chiamato, restituisce true solo se il primo argomento è minore o uguale al secondo. Viene usato per specificare un oggetto funzione in termini di tipo argomento.
Sintassi
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^();
};
Parametri
Arg
Tipo degli argomenti.
Funzioni di membro
| Definizione del tipo | Descrizione |
|---|---|
delegate_type |
Tipo del delegato generico. |
first_argument_type |
Tipo del functor primo argomento. |
result_type |
Tipo del risultato del funtore. |
second_argument_type |
Tipo del secondo argomento functor. |
| Membro | Descrizione |
|---|---|
less_equal |
Costruisce il funtore. |
| Operatore | Descrizione |
|---|---|
operator() |
Calcola la funzione desiderata. |
operator delegate_type^ |
Esegue il cast del funtore a un delegato. |
Osservazioni:
La classe modello descrive un funtore a due argomenti. Definisce l'operatore operator() membro in modo che, quando l'oggetto viene chiamato come funzione, restituisce true solo se il primo argomento è minore o uguale al secondo.
È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.
Esempio
// 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)
La classe modello descrive un funtore che, quando viene chiamato, restituisce true solo se sia il primo argomento che il secondo test come true. Viene usato per specificare un oggetto funzione in termini di tipo argomento.
Sintassi
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^();
};
Parametri
Arg
Tipo degli argomenti.
Funzioni di membro
| Definizione del tipo | Descrizione |
|---|---|
delegate_type |
Tipo del delegato generico. |
first_argument_type |
Tipo del functor primo argomento. |
result_type |
Tipo del risultato del funtore. |
second_argument_type |
Tipo del secondo argomento functor. |
| Membro | Descrizione |
|---|---|
logical_and |
Costruisce il funtore. |
| Operatore | Descrizione |
|---|---|
operator() |
Calcola la funzione desiderata. |
operator delegate_type^ |
Esegue il cast del funtore a un delegato. |
Osservazioni:
La classe modello descrive un funtore a due argomenti. Definisce l'operatore operator() membro in modo che, quando l'oggetto viene chiamato come funzione, restituisce true solo se sia il primo argomento che il secondo test come true.
È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.
Esempio
// 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)
La classe modello descrive un funtore che, quando viene chiamato, restituisce true solo se uno dei relativi argomenti viene verificato come false. Viene usato per specificare un oggetto funzione in termini di tipo argomento.
Sintassi
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^();
};
Parametri
Arg
Tipo degli argomenti.
Funzioni di membro
| Definizione del tipo | Descrizione |
|---|---|
argument_type |
Tipo dell'argomento functor. |
delegate_type |
Tipo del delegato generico. |
result_type |
Tipo del risultato del funtore. |
| Membro | Descrizione |
|---|---|
logical_not |
Costruisce il funtore. |
| Operatore | Descrizione |
|---|---|
operator() |
Calcola la funzione desiderata. |
operator delegate_type^ |
Esegue il cast del funtore a un delegato. |
Osservazioni:
La classe modello descrive un funtore a un argomento. Definisce l'operatore operator() membro in modo che, quando l'oggetto viene chiamato come funzione, restituisce true solo se il relativo argomento viene verificato come false.
È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.
Esempio
// 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)
La classe modello descrive un funtore che, quando viene chiamato, restituisce true solo se il primo argomento o il secondo test è true. Viene usato per specificare un oggetto funzione in termini di tipo argomento.
Sintassi
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^();
};
Parametri
Arg
Tipo degli argomenti.
Funzioni di membro
| Definizione del tipo | Descrizione |
|---|---|
delegate_type |
Tipo del delegato generico. |
first_argument_type |
Tipo del functor primo argomento. |
result_type |
Tipo del risultato del funtore. |
second_argument_type |
Tipo del secondo argomento functor. |
| Membro | Descrizione |
|---|---|
logical_or |
Costruisce il funtore. |
| Operatore | Descrizione |
|---|---|
operator() |
Calcola la funzione desiderata. |
operator delegate_type^ |
Esegue il cast del funtore a un delegato. |
Osservazioni:
La classe modello descrive un funtore a due argomenti. Definisce l'operatore operator() membro in modo che, quando l'oggetto viene chiamato come funzione, restituisce true solo se il primo argomento o il secondo test come true.
È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.
Esempio
// 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)
La classe modello descrive un funtore che, quando viene chiamato, restituisce il primo argomento meno il secondo. Viene usato per specificare un oggetto funzione in termini di tipo argomento.
Sintassi
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^();
};
Parametri
Arg
Tipo di argomenti e valore restituito.
Funzioni di membro
| Definizione del tipo | Descrizione |
|---|---|
delegate_type |
Tipo del delegato generico. |
first_argument_type |
Tipo del functor primo argomento. |
result_type |
Tipo del risultato del funtore. |
second_argument_type |
Tipo del secondo argomento functor. |
| Membro | Descrizione |
|---|---|
minus |
Costruisce il funtore. |
| Operatore | Descrizione |
|---|---|
operator() |
Calcola la funzione desiderata. |
operator delegate_type^ |
Esegue il cast del funtore a un delegato. |
Osservazioni:
La classe modello descrive un funtore a due argomenti. Definisce l'operatore operator() membro in modo che, quando l'oggetto viene chiamato come funzione, restituisce il primo argomento meno il secondo.
È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.
Esempio
// 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)
La classe modello descrive un funtore che, quando viene chiamato, restituisce il primo argomento modulo il secondo. Viene usato per specificare un oggetto funzione in termini di tipo argomento.
Sintassi
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^();
};
Parametri
Arg
Tipo di argomenti e valore restituito.
Funzioni di membro
| Definizione del tipo | Descrizione |
|---|---|
delegate_type |
Tipo del delegato generico. |
first_argument_type |
Tipo del functor primo argomento. |
result_type |
Tipo del risultato del funtore. |
second_argument_type |
Tipo del secondo argomento functor. |
| Membro | Descrizione |
|---|---|
modulus |
Costruisce il funtore. |
| Operatore | Descrizione |
|---|---|
operator() |
Calcola la funzione desiderata. |
operator delegate_type^ |
Esegue il cast del funtore a un delegato. |
Osservazioni:
La classe modello descrive un funtore a due argomenti. Definisce l'operatore operator() membro in modo che, quando l'oggetto viene chiamato come funzione, restituisce il primo argomento modulo il secondo.
È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.
Esempio
// 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)
La classe modello descrive un funtore che, quando viene chiamato, restituisce il primo argomento volte al secondo. Viene usato per specificare un oggetto funzione in termini di tipo argomento.
Sintassi
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^();
};
Parametri
Arg
Tipo di argomenti e valore restituito.
Funzioni di membro
| Definizione del tipo | Descrizione |
|---|---|
delegate_type |
Tipo del delegato generico. |
first_argument_type |
Tipo del functor primo argomento. |
result_type |
Tipo del risultato del funtore. |
second_argument_type |
Tipo del secondo argomento functor. |
| Membro | Descrizione |
|---|---|
multiplies |
Costruisce il funtore. |
| Operatore | Descrizione |
|---|---|
operator() |
Calcola la funzione desiderata. |
operator delegate_type^ |
Esegue il cast del funtore a un delegato. |
Osservazioni:
La classe modello descrive un funtore a due argomenti. Definisce l'operatore operator() membro in modo che, quando l'oggetto viene chiamato come funzione, restituisce il primo argomento volte al secondo.
È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.
Esempio
// 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)
La classe modello descrive un funtore che, quando viene chiamato, restituisce il relativo argomento negato. Viene usato per specificare un oggetto funzione in termini di tipo argomento.
Sintassi
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^();
};
Parametri
Arg
Tipo degli argomenti.
Funzioni di membro
| Definizione del tipo | Descrizione |
|---|---|
argument_type |
Tipo dell'argomento functor. |
delegate_type |
Tipo del delegato generico. |
result_type |
Tipo del risultato del funtore. |
| Membro | Descrizione |
|---|---|
negate |
Costruisce il funtore. |
| Operatore | Descrizione |
|---|---|
operator() |
Calcola la funzione desiderata. |
operator delegate_type^ |
Esegue il cast del funtore a un delegato. |
Osservazioni:
La classe modello descrive un funtore a un argomento. Definisce l'operatore operator() membro in modo che, quando l'oggetto viene chiamato come funzione, restituisce il relativo argomento negato.
È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.
Esempio
// 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)
La classe modello descrive un funtore che, quando viene chiamato, restituisce true solo se il primo argomento non è uguale al secondo. Viene usato per specificare un oggetto funzione in termini di tipo argomento.
Sintassi
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^();
};
Parametri
Arg
Tipo degli argomenti.
Funzioni di membro
| Definizione del tipo | Descrizione |
|---|---|
delegate_type |
Tipo del delegato generico. |
first_argument_type |
Tipo del functor primo argomento. |
result_type |
Tipo del risultato del funtore. |
second_argument_type |
Tipo del secondo argomento functor. |
| Membro | Descrizione |
|---|---|
not_equal_to |
Costruisce il funtore. |
| Operatore | Descrizione |
|---|---|
operator() |
Calcola la funzione desiderata. |
operator delegate_type^ |
Esegue il cast del funtore a un delegato. |
Osservazioni:
La classe modello descrive un funtore a due argomenti. Definisce l'operatore operator() membro in modo che, quando l'oggetto viene chiamato come funzione, restituisce true solo se il primo argomento non è uguale al secondo.
È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.
Esempio
// 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)
Genera un oggetto unary_negate per un funtore.
Sintassi
template<typename Fun>
unary_negate<Fun> not1(Fun% functor);
Parametri modello
Fun
Tipo del funtore.
Parametri della funzione
functor
Funtore da avvolgere.
Osservazioni:
Il modello di funzione restituisce unary_negate<Fun>(functor). Lo si usa come modo pratico per eseguire il wrapping di un funtore a un argomento in un funtore che fornisce il relativo NOT logico.
Esempio
// 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)
Genera un oggetto binary_negate per un funtore.
Sintassi
template<typename Fun>
binary_negate<Fun> not2(Fun% functor);
Parametri modello
Fun
Tipo del funtore.
Parametri della funzione
functor
Funtore da avvolgere.
Osservazioni:
Il modello di funzione restituisce binary_negate<Fun>(functor). Lo si usa come modo pratico per eseguire il wrapping di un funtore a due argomenti in un funtore che fornisce il relativo NOT logico.
Esempio
// 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)
La classe modello descrive un funtore che, quando viene chiamato, restituisce il primo argomento più il secondo. Viene usato per specificare un oggetto funzione in termini di tipo argomento.
Sintassi
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^();
};
Parametri
Arg
Tipo di argomenti e valore restituito.
Funzioni di membro
| Definizione del tipo | Descrizione |
|---|---|
delegate_type |
Tipo del delegato generico. |
first_argument_type |
Tipo del functor primo argomento. |
result_type |
Tipo del risultato del funtore. |
second_argument_type |
Tipo del secondo argomento functor. |
| Membro | Descrizione |
|---|---|
plus |
Costruisce il funtore. |
| Operatore | Descrizione |
|---|---|
operator() |
Calcola la funzione desiderata. |
operator delegate_type^ |
Esegue il cast del funtore a un delegato. |
Osservazioni:
La classe modello descrive un funtore a due argomenti. Definisce l'operatore operator() membro in modo che, quando l'oggetto viene chiamato come funzione, restituisce il primo argomento più il secondo.
È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.
Esempio
// 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)
La classe generica descrive un delegato di un argomento. Viene usato per specificare un delegato in termini di argomento e tipi restituiti.
Sintassi
generic<typename Arg,
typename Result>
delegate Result unary_delegate(Arg);
Parametri
Arg
Il tipo di argomento.
Result
Tipo restituito.
Osservazioni:
Il delegato generico descrive una funzione con un solo argomento.
Nei modelli di funzione seguenti:
unary_delegate<int, int> Fun1;
unary_delegate<int, int> Fun2;
i tipi Fun1 e Fun2 sono sinonimi, mentre per:
delegate int Fun1(int);
delegate int Fun2(int);
non sono dello stesso tipo.
Esempio
// 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)
La classe generica descrive un delegato di un argomento che restituisce void. Viene usato per specificare un delegato in termini di tipo argomento.
Sintassi
generic<typename Arg>
delegate void unary_delegate_noreturn(Arg);
Parametri
Arg
Il tipo di argomento.
Osservazioni:
Il delegato generico descrive una funzione a un argomento che restituisce void.
Nei modelli di funzione seguenti:
unary_delegate_noreturn<int> Fun1;
unary_delegate_noreturn<int> Fun2;
i tipi Fun1 e Fun2 sono sinonimi, mentre per:
delegate void Fun1(int);
delegate void Fun2(int);
non sono dello stesso tipo.
Esempio
// 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)
La classe modello descrive un funtore che, quando viene chiamato, restituisce il not logico del funtore a un argomento archiviato. Viene usato per specificare un oggetto funzione in termini di funtore archiviato.
Sintassi
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^();
};
Parametri
Fun
Tipo del funtore archiviato.
Funzioni di membro
| Definizione del tipo | Descrizione |
|---|---|
argument_type |
Tipo dell'argomento functor. |
delegate_type |
Tipo del delegato generico. |
result_type |
Tipo del risultato del funtore. |
| Membro | Descrizione |
|---|---|
unary_negate |
Costruisce il funtore. |
| Operatore | Descrizione |
|---|---|
operator() |
Calcola la funzione desiderata. |
delegate_type^ |
Esegue il cast del funtore a un delegato. |
Osservazioni:
La classe modello descrive un funtore a un argomento che archivia un altro funtore a argomento. Definisce l'operatore operator() membro in modo che, quando l'oggetto viene chiamato come funzione, restituisce il NOT logico del funtore archiviato chiamato con l'argomento .
È anche possibile passare l'oggetto come argomento della funzione il cui tipo è delegate_type^ e verrà convertito in modo appropriato.
Esempio
// 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