functional (STL/CLR)
Fügen Sie den STL/CLR-Header <cliext/functional> ein, um funktionale Klassenvorlagen und zugehörige Vorlagendelegatten und -funktionen zu definieren.
Syntax
#include <functional>
Anforderungen
Header:<cliext/functional>
Namespace:cliext
Deklarationen
| Delegieren | Beschreibung |
|---|---|
binary_delegate (STL/CLR) |
Stellvertretung mit zwei Argumenten. |
binary_delegate_noreturn (STL/CLR) |
Stellvertretung mit zwei Argumenten, die zurückgegeben wird void. |
unary_delegate (STL/CLR) |
Stellvertretung mit einem Argument. |
unary_delegate_noreturn (STL/CLR) |
Stellvertretung mit einem Argument, die zurückgegeben wird void. |
| Klasse | Beschreibung |
|---|---|
binary_negate (STL/CLR) |
Functor zum Negieren eines Zwei-Argument-Functors. |
binder1st (STL/CLR) |
Functor zum Binden des ersten Arguments an einen Zwei-Argument-Functor. |
binder2nd (STL/CLR) |
Functor zum Binden des zweiten Arguments an einen Zwei-Argument-Functor. |
divides (STL/CLR) |
Teilen Sie den Functor. |
equal_to (STL/CLR) |
Gleicher Vergleichs-Functor. |
greater (STL/CLR) |
Größerer Vergleichs-Functor. |
greater_equal (STL/CLR) |
Größer oder gleicher Vergleichs-Functor. |
less (STL/CLR) |
Weniger Vergleichs-Functor. |
less_equal (STL/CLR) |
Kleiner oder gleicher Vergleichs-Functor. |
logical_and (STL/CLR) |
Logische UND Functor. |
logical_not (STL/CLR) |
LogischeR NOT-Functor. |
logical_or (STL/CLR) |
LogischeR ODER-Functor. |
minus (STL/CLR) |
Subtrahieren Sie den Functor. |
modulus (STL/CLR) |
Modulus Functor. |
multiplies (STL/CLR) |
Multiplizieren sie. |
negate (STL/CLR) |
Functor, um sein Argument negiert zurückzugeben. |
not_equal_to (STL/CLR) |
Kein gleicher Vergleichs-Functor. |
plus (STL/CLR) |
Fügen Sie einen Functor hinzu. |
unary_negate (STL/CLR) |
Functor zum Negieren eines Ein-Argument-Functors. |
| Funktion | Beschreibung |
|---|---|
bind1st (STL/CLR) |
Generiert einen Binder1st für ein Argument und einen Functor. |
bind2nd (STL/CLR) |
Generiert einen Binder2nd für ein Argument und einen Functor. |
not1 (STL/CLR) |
Generiert eine unary_negate für einen Functor. |
not2 (STL/CLR) |
Generiert eine binary_negate für einen Functor. |
Member
binary_delegate (STL/CLR)
Die generische Klasse beschreibt einen Zwei-Argument-Delegaten. Sie verwenden ihn, um einen Delegat in Bezug auf das Argument und die Rückgabetypen anzugeben.
Syntax
generic<typename Arg1,
typename Arg2,
typename Result>
delegate Result binary_delegate(Arg1, Arg2);
Parameter
Arg1
Der Typ des ersten Arguments.
Arg2
Der Typ des zweiten Arguments.
Result
Der Rückgabetyp.
Hinweise
Der generische Delegat beschreibt eine Zwei-Argument-Funktion.
In diesen Funktionsvorlagen:
binary_delegate<int, int, int> Fun1;
binary_delegate<int, int, int> Fun2;
die Typen Fun1 und Fun2 Synonyme sind, während für:
delegate int Fun1(int, int);
delegate int Fun2(int, int);
sie sind nicht derselbe Typ.
Beispiel
// 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)
Die generische Klasse beschreibt einen Zwei-Argument-Delegaten, der zurückgegeben wird void. Sie verwenden ihn, um einen Delegat in Bezug auf das Argument anzugeben.
Syntax
generic<typename Arg1,
typename Arg2>
delegate void binary_delegate(Arg1, Arg2);
Parameter
Arg1
Der Typ des ersten Arguments.
Arg2
Der Typ des zweiten Arguments.
Hinweise
Der generische Delegat beschreibt eine Zwei-Argument-Funktion, die zurückgegeben wird void.
In diesen Funktionsvorlagen:
binary_delegate_noreturn<int, int> Fun1;
binary_delegate_noreturn<int, int> Fun2;
die Typen Fun1 und Fun2 Synonyme sind, während für:
delegate void Fun1(int, int);
delegate void Fun2(int, int);
sie sind nicht derselbe Typ.
Beispiel
// 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)
Die Vorlagenklasse beschreibt einen Functor, der, wenn sie aufgerufen wird, die logische NOT des gespeicherten Zwei-Argument-Functors zurückgibt. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den gespeicherten Functor anzugeben.
Syntax
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^();
};
Parameter
Fun
Der Typ des gespeicherten Functors.
Elementfunktionen
| Typendefinition | Beschreibung |
|---|---|
delegate_type |
Der Typ des generischen Delegaten. |
first_argument_type |
Der Typ des ersten Arguments des Functors. |
result_type |
Der Typ des Functorergebnisses. |
second_argument_type |
Der Typ des zweiten Arguments des Functors. |
stored_function_type |
Der Typ des Functors. |
| Member | Beschreibung |
|---|---|
binary_negate |
Erstellt den Functor. |
| Operator | Beschreibung |
|---|---|
operator() |
Berechnet die gewünschte Funktion. |
operator delegate_type^() |
Wandelt den Functor in eine Stellvertretung um. |
Hinweise
Die Vorlagenklasse beschreibt einen Zwei-Argument-Functor, der einen weiteren Zwei-Argument-Functor speichert. Er definiert den Memberoperator operator() , sodass, wenn das Objekt als Funktion aufgerufen wird, die logische NOT des gespeicherten Functors zurückgibt, der mit den beiden Argumenten aufgerufen wird.
Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.
Beispiel
// 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)
Generiert ein Argument und einen binder1st Functor.
Syntax
template<typename Fun,
typename Arg>
binder1st<Fun> bind1st(Fun% functor,
Arg left);
Vorlagenparameter
Arg
Der Typ des Arguments.
Fun
Der Typ des Functors.
Funktionsparameter
functor
Der Functor, der umbrochen werden soll.
left
Das erste Argument, das umbrochen werden soll.
Hinweise
Die Funktionsvorlage gibt zurück binder1st<Fun>(functor, left). Sie verwenden es als bequeme Möglichkeit, einen Zwei-Argument-Functor und sein erstes Argument in einem Ein-Argument-Functor umzuschließen, der ihn mit einem zweiten Argument aufruft.
Beispiel
// 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)
Generiert ein Argument und einen binder2nd Functor.
Syntax
template<typename Fun,
typename Arg>
binder2nd<Fun> bind2nd(Fun% functor,
Arg right);
Vorlagenparameter
Arg
Der Typ des Arguments.
Fun
Der Typ des Functors.
Funktionsparameter
functor
Der Functor, der umbrochen werden soll.
right
Das zweite Argument, das umbrochen werden soll.
Hinweise
Die Funktionsvorlage gibt zurück binder2nd<Fun>(functor, right). Sie verwenden es als bequeme Möglichkeit, einen Zwei-Argument-Functor und das zweite Argument in einem Ein-Argument-Functor umzuschließen, der ihn mit einem ersten Argument aufruft.
Beispiel
// 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)
Die Vorlagenklasse beschreibt einen Ein-Argument-Functor, der, wenn aufgerufen wird, seinen gespeicherten Zwei-Argument-Functor zurückgibt, der mit dem gespeicherten ersten Argument und dem angegebenen zweiten Argument aufgerufen wird. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den gespeicherten Functor anzugeben.
Syntax
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^();
};
Parameter
Fun
Der Typ des gespeicherten Functors.
Elementfunktionen
| Typendefinition | Beschreibung |
|---|---|
delegate_type |
Der Typ des generischen Delegaten. |
first_argument_type |
Der Typ des ersten Arguments des Functors. |
result_type |
Der Typ des Functorergebnisses. |
second_argument_type |
Der Typ des zweiten Arguments des Functors. |
stored_function_type |
Der Typ des Functors. |
| Member | Beschreibung |
|---|---|
binder1st |
Erstellt den Functor. |
| Operator | Beschreibung |
|---|---|
operator() |
Berechnet die gewünschte Funktion. |
operator delegate_type^() |
Wandelt den Functor in eine Stellvertretung um. |
Hinweise
Die Vorlagenklasse beschreibt einen Ein-Argument-Functor, der einen Zwei-Argument-Functor und ein erstes Argument speichert. Er definiert den Memberoperator operator() , sodass, wenn das Objekt als Funktion aufgerufen wird, das Ergebnis des Aufrufs des gespeicherten Functors mit dem gespeicherten ersten Argument und dem angegebenen zweiten Argument zurückgibt.
Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.
Beispiel
// 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)
Die Vorlagenklasse beschreibt einen Ein-Argument-Functor, der, wenn sie aufgerufen wird, den gespeicherten Zwei-Argument-Functor zurückgibt, der mit dem angegebenen ersten Argument und dem gespeicherten zweiten Argument aufgerufen wird. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den gespeicherten Functor anzugeben.
Syntax
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^();
};
Parameter
Fun
Der Typ des gespeicherten Functors.
Elementfunktionen
| Typendefinition | Beschreibung |
|---|---|
delegate_type |
Der Typ des generischen Delegaten. |
first_argument_type |
Der Typ des ersten Arguments des Functors. |
result_type |
Der Typ des Functorergebnisses. |
second_argument_type |
Der Typ des zweiten Arguments des Functors. |
stored_function_type |
Der Typ des Functors. |
| Member | Beschreibung |
|---|---|
binder2nd |
Erstellt den Functor. |
| Operator | Beschreibung |
|---|---|
operator() |
Berechnet die gewünschte Funktion. |
operator delegate_type^() |
Wandelt den Functor in eine Stellvertretung um. |
Hinweise
Die Vorlagenklasse beschreibt einen Ein-Argument-Functor, der einen Zwei-Argument-Functor und ein zweites Argument speichert. Er definiert den Memberoperator operator() so, dass beim Aufrufen des Objekts als Funktion das Ergebnis des Aufrufs des gespeicherten Functors mit dem angegebenen ersten Argument und dem gespeicherten zweiten Argument zurückgegeben wird.
Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.
Beispiel
// 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)
Die Vorlagenklasse beschreibt einen Functor, der, wenn sie aufgerufen wird, das erste Argument dividiert durch die zweite zurückgibt. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den Argumenttyp anzugeben.
Syntax
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^();
};
Parameter
Arg
Der Typ der Argumente und des Rückgabewerts.
Elementfunktionen
| Typendefinition | Beschreibung |
|---|---|
delegate_type |
Der Typ des generischen Delegaten. |
first_argument_type |
Der Typ des ersten Arguments des Functors. |
result_type |
Der Typ des Functorergebnisses. |
second_argument_type |
Der Typ des zweiten Arguments des Functors. |
| Member | Beschreibung |
|---|---|
divides |
Erstellt den Functor. |
| Operator | Beschreibung |
|---|---|
operator() |
Berechnet die gewünschte Funktion. |
operator delegate_type^() |
Wandelt den Functor in eine Stellvertretung um. |
Hinweise
Die Vorlagenklasse beschreibt einen Zwei-Argument-Functor. Er definiert den Memberoperator operator() so, dass, wenn das Objekt als Funktion aufgerufen wird, das erste Argument dividiert durch die zweite zurückgibt.
Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.
Beispiel
// 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)
Die Vorlagenklasse beschreibt einen Functor, der, wenn sie aufgerufen wird, nur true zurückgibt, wenn das erste Argument gleich der zweiten ist. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den Argumenttyp anzugeben.
Syntax
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^();
};
Parameter
Arg
Der Typ der Argumente.
Elementfunktionen
| Typendefinition | Beschreibung |
|---|---|
delegate_type |
Der Typ des generischen Delegaten. |
first_argument_type |
Der Typ des ersten Arguments des Functors. |
result_type |
Der Typ des Functorergebnisses. |
second_argument_type |
Der Typ des zweiten Arguments des Functors. |
| Member | Beschreibung |
|---|---|
equal_to |
Erstellt den Functor. |
| Operator | Beschreibung |
|---|---|
operator() |
Berechnet die gewünschte Funktion. |
operator delegate_type^() |
Wandelt den Functor in eine Stellvertretung um. |
Hinweise
Die Vorlagenklasse beschreibt einen Zwei-Argument-Functor. Er definiert den Memberoperator operator() , sodass das erste Argument nur dann wahr ist, wenn das Objekt als Funktion aufgerufen wird.
Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.
Beispiel
// 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)
Die Vorlagenklasse beschreibt einen Functor, der bei Aufruf nur "true" zurückgibt, wenn das erste Argument größer als die zweite ist. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den Argumenttyp anzugeben.
Syntax
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^();
};
Parameter
Arg
Der Typ der Argumente.
Elementfunktionen
| Typendefinition | Beschreibung |
|---|---|
delegate_type |
Der Typ des generischen Delegaten. |
first_argument_type |
Der Typ des ersten Arguments des Functors. |
result_type |
Der Typ des Functorergebnisses. |
second_argument_type |
Der Typ des zweiten Arguments des Functors. |
| Member | Beschreibung |
|---|---|
greater |
Erstellt den Functor. |
| Operator | Beschreibung |
|---|---|
operator() |
Berechnet die gewünschte Funktion. |
operator delegate_type^ |
Wandelt den Functor in eine Stellvertretung um. |
Hinweise
Die Vorlagenklasse beschreibt einen Zwei-Argument-Functor. Er definiert den Memberoperator operator() , sodass das erste Argument nur dann true zurückgibt, wenn das erste Argument größer als die zweite ist, wenn das Objekt als Funktion aufgerufen wird.
Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.
Beispiel
// 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)
Die Vorlagenklasse beschreibt einen Functor, der bei Aufruf nur "true" zurückgibt, wenn das erste Argument größer oder gleich dem zweiten ist. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den Argumenttyp anzugeben.
Syntax
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^();
};
Parameter
Arg
Der Typ der Argumente.
Elementfunktionen
| Typendefinition | Beschreibung |
|---|---|
delegate_type |
Der Typ des generischen Delegaten. |
first_argument_type |
Der Typ des ersten Arguments des Functors. |
result_type |
Der Typ des Functorergebnisses. |
second_argument_type |
Der Typ des zweiten Arguments des Functors. |
| Member | Beschreibung |
|---|---|
greater_equal |
Erstellt den Functor. |
| Operator | Beschreibung |
|---|---|
operator() |
Berechnet die gewünschte Funktion. |
operator delegate_type^ |
Wandelt den Functor in eine Stellvertretung um. |
Hinweise
Die Vorlagenklasse beschreibt einen Zwei-Argument-Functor. Er definiert den Memberoperator operator() , sodass das Erste Argument größer oder gleich der zweiten ist, wenn das Objekt als Funktion aufgerufen wird, "true" zurück.
Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.
Beispiel
// 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)
Die Vorlagenklasse beschreibt einen Functor, der bei Aufruf nur "true" zurückgibt, wenn das erste Argument kleiner als der zweite ist. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den Argumenttyp anzugeben.
Syntax
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^();
};
Parameter
Arg
Der Typ der Argumente.
Elementfunktionen
| Typendefinition | Beschreibung |
|---|---|
delegate_type |
Der Typ des generischen Delegaten. |
first_argument_type |
Der Typ des ersten Arguments des Functors. |
result_type |
Der Typ des Functorergebnisses. |
second_argument_type |
Der Typ des zweiten Arguments des Functors. |
| Member | Beschreibung |
|---|---|
less |
Erstellt den Functor. |
| Operator | Beschreibung |
|---|---|
operator() |
Berechnet die gewünschte Funktion. |
operator delegate_type^ |
Wandelt den Functor in eine Stellvertretung um. |
Hinweise
Die Vorlagenklasse beschreibt einen Zwei-Argument-Functor. Er definiert den Memberoperator operator() , sodass das erste Argument nur dann wahr ist, wenn das Objekt als Funktion aufgerufen wird.
Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.
Beispiel
// 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)
Die Vorlagenklasse beschreibt einen Functor, der bei Aufruf nur "true" zurückgibt, wenn das erste Argument kleiner oder gleich dem zweiten ist. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den Argumenttyp anzugeben.
Syntax
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^();
};
Parameter
Arg
Der Typ der Argumente.
Elementfunktionen
| Typendefinition | Beschreibung |
|---|---|
delegate_type |
Der Typ des generischen Delegaten. |
first_argument_type |
Der Typ des ersten Arguments des Functors. |
result_type |
Der Typ des Functorergebnisses. |
second_argument_type |
Der Typ des zweiten Arguments des Functors. |
| Member | Beschreibung |
|---|---|
less_equal |
Erstellt den Functor. |
| Operator | Beschreibung |
|---|---|
operator() |
Berechnet die gewünschte Funktion. |
operator delegate_type^ |
Wandelt den Functor in eine Stellvertretung um. |
Hinweise
Die Vorlagenklasse beschreibt einen Zwei-Argument-Functor. Er definiert den Memberoperator operator() , sodass, wenn das Objekt als Funktion aufgerufen wird, nur true zurückgibt, wenn das erste Argument kleiner oder gleich dem zweiten ist.
Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.
Beispiel
// 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)
Die Vorlagenklasse beschreibt einen Functor, der bei Aufruf nur "true" zurückgibt, wenn sowohl das erste Argument als auch der zweite Test als "true" verwendet werden. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den Argumenttyp anzugeben.
Syntax
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^();
};
Parameter
Arg
Der Typ der Argumente.
Elementfunktionen
| Typendefinition | Beschreibung |
|---|---|
delegate_type |
Der Typ des generischen Delegaten. |
first_argument_type |
Der Typ des ersten Arguments des Functors. |
result_type |
Der Typ des Functorergebnisses. |
second_argument_type |
Der Typ des zweiten Arguments des Functors. |
| Member | Beschreibung |
|---|---|
logical_and |
Erstellt den Functor. |
| Operator | Beschreibung |
|---|---|
operator() |
Berechnet die gewünschte Funktion. |
operator delegate_type^ |
Wandelt den Functor in eine Stellvertretung um. |
Hinweise
Die Vorlagenklasse beschreibt einen Zwei-Argument-Functor. Er definiert den Memberoperator operator() so, dass das Objekt, wenn das Objekt als Funktion aufgerufen wird, nur true zurückgibt, wenn sowohl das erste Argument als auch der zweite Test als "true" angegeben werden.
Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.
Beispiel
// 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)
Die Vorlagenklasse beschreibt einen Functor, der bei Aufruf nur "true" zurückgibt, wenn beide Argumente als "false" getestet werden. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den Argumenttyp anzugeben.
Syntax
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^();
};
Parameter
Arg
Der Typ der Argumente.
Elementfunktionen
| Typendefinition | Beschreibung |
|---|---|
argument_type |
Der Typ des Functor-Arguments. |
delegate_type |
Der Typ des generischen Delegaten. |
result_type |
Der Typ des Functorergebnisses. |
| Member | Beschreibung |
|---|---|
logical_not |
Erstellt den Functor. |
| Operator | Beschreibung |
|---|---|
operator() |
Berechnet die gewünschte Funktion. |
operator delegate_type^ |
Wandelt den Functor in eine Stellvertretung um. |
Hinweise
Die Vorlagenklasse beschreibt einen Ein-Argument-Functor. Er definiert den Memberoperator operator() , sodass das Objekt, wenn das Objekt als Funktion aufgerufen wird, nur true zurückgibt, wenn das Argument als falsch getestet wird.
Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.
Beispiel
// 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)
Die Vorlagenklasse beschreibt einen Functor, der, wenn sie aufgerufen wird, nur true zurückgibt, wenn entweder das erste Argument oder die zweite Prüfung als wahr ausgeführt wird. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den Argumenttyp anzugeben.
Syntax
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^();
};
Parameter
Arg
Der Typ der Argumente.
Elementfunktionen
| Typendefinition | Beschreibung |
|---|---|
delegate_type |
Der Typ des generischen Delegaten. |
first_argument_type |
Der Typ des ersten Arguments des Functors. |
result_type |
Der Typ des Functorergebnisses. |
second_argument_type |
Der Typ des zweiten Arguments des Functors. |
| Member | Beschreibung |
|---|---|
logical_or |
Erstellt den Functor. |
| Operator | Beschreibung |
|---|---|
operator() |
Berechnet die gewünschte Funktion. |
operator delegate_type^ |
Wandelt den Functor in eine Stellvertretung um. |
Hinweise
Die Vorlagenklasse beschreibt einen Zwei-Argument-Functor. Er definiert den Memberoperator operator() , sodass das Objekt, wenn das Objekt als Funktion aufgerufen wird, nur true zurückgibt, wenn entweder das erste Argument oder die zweite Als wahr getestet wird.
Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.
Beispiel
// 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)
Die Vorlagenklasse beschreibt einen Functor, der bei Aufruf das erste Argument minus der zweiten zurückgibt. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den Argumenttyp anzugeben.
Syntax
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^();
};
Parameter
Arg
Der Typ der Argumente und des Rückgabewerts.
Elementfunktionen
| Typendefinition | Beschreibung |
|---|---|
delegate_type |
Der Typ des generischen Delegaten. |
first_argument_type |
Der Typ des ersten Arguments des Functors. |
result_type |
Der Typ des Functorergebnisses. |
second_argument_type |
Der Typ des zweiten Arguments des Functors. |
| Member | Beschreibung |
|---|---|
minus |
Erstellt den Functor. |
| Operator | Beschreibung |
|---|---|
operator() |
Berechnet die gewünschte Funktion. |
operator delegate_type^ |
Wandelt den Functor in eine Stellvertretung um. |
Hinweise
Die Vorlagenklasse beschreibt einen Zwei-Argument-Functor. Er definiert den Memberoperator operator() , sodass, wenn das Objekt als Funktion aufgerufen wird, das erste Argument minus der zweiten zurückgibt.
Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.
Beispiel
// 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)
Die Vorlagenklasse beschreibt einen Functor, der, wenn sie aufgerufen wird, das erste Argumentmodul für die zweite zurückgibt. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den Argumenttyp anzugeben.
Syntax
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^();
};
Parameter
Arg
Der Typ der Argumente und des Rückgabewerts.
Elementfunktionen
| Typendefinition | Beschreibung |
|---|---|
delegate_type |
Der Typ des generischen Delegaten. |
first_argument_type |
Der Typ des ersten Arguments des Functors. |
result_type |
Der Typ des Functorergebnisses. |
second_argument_type |
Der Typ des zweiten Arguments des Functors. |
| Member | Beschreibung |
|---|---|
modulus |
Erstellt den Functor. |
| Operator | Beschreibung |
|---|---|
operator() |
Berechnet die gewünschte Funktion. |
operator delegate_type^ |
Wandelt den Functor in eine Stellvertretung um. |
Hinweise
Die Vorlagenklasse beschreibt einen Zwei-Argument-Functor. Er definiert den Memberoperator operator() , sodass, wenn das Objekt als Funktion aufgerufen wird, das erste Argumentmodul die zweite zurückgibt.
Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.
Beispiel
// 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)
Die Vorlagenklasse beschreibt einen Functor, der beim Aufrufen das erste Argument mal die zweite zurückgibt. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den Argumenttyp anzugeben.
Syntax
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^();
};
Parameter
Arg
Der Typ der Argumente und des Rückgabewerts.
Elementfunktionen
| Typendefinition | Beschreibung |
|---|---|
delegate_type |
Der Typ des generischen Delegaten. |
first_argument_type |
Der Typ des ersten Arguments des Functors. |
result_type |
Der Typ des Functorergebnisses. |
second_argument_type |
Der Typ des zweiten Arguments des Functors. |
| Member | Beschreibung |
|---|---|
multiplies |
Erstellt den Functor. |
| Operator | Beschreibung |
|---|---|
operator() |
Berechnet die gewünschte Funktion. |
operator delegate_type^ |
Wandelt den Functor in eine Stellvertretung um. |
Hinweise
Die Vorlagenklasse beschreibt einen Zwei-Argument-Functor. Er definiert den Memberoperator operator() , sodass beim Aufrufen des Objekts als Funktion das erste Argument beim zweiten Argument zurückgegeben wird.
Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.
Beispiel
// 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)
Die Vorlagenklasse beschreibt einen Functor, der, wenn sie aufgerufen wird, das Argument negiert zurückgibt. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den Argumenttyp anzugeben.
Syntax
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^();
};
Parameter
Arg
Der Typ der Argumente.
Elementfunktionen
| Typendefinition | Beschreibung |
|---|---|
argument_type |
Der Typ des Functor-Arguments. |
delegate_type |
Der Typ des generischen Delegaten. |
result_type |
Der Typ des Functorergebnisses. |
| Member | Beschreibung |
|---|---|
negate |
Erstellt den Functor. |
| Operator | Beschreibung |
|---|---|
operator() |
Berechnet die gewünschte Funktion. |
operator delegate_type^ |
Wandelt den Functor in eine Stellvertretung um. |
Hinweise
Die Vorlagenklasse beschreibt einen Ein-Argument-Functor. Er definiert den Memberoperator operator() , sodass, wenn das Objekt als Funktion aufgerufen wird, sein Argument negiert zurückgibt.
Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.
Beispiel
// 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)
Die Vorlagenklasse beschreibt einen Functor, der, wenn sie aufgerufen wird, nur true zurückgibt, wenn das erste Argument nicht gleich dem zweiten ist. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den Argumenttyp anzugeben.
Syntax
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^();
};
Parameter
Arg
Der Typ der Argumente.
Elementfunktionen
| Typendefinition | Beschreibung |
|---|---|
delegate_type |
Der Typ des generischen Delegaten. |
first_argument_type |
Der Typ des ersten Arguments des Functors. |
result_type |
Der Typ des Functorergebnisses. |
second_argument_type |
Der Typ des zweiten Arguments des Functors. |
| Member | Beschreibung |
|---|---|
not_equal_to |
Erstellt den Functor. |
| Operator | Beschreibung |
|---|---|
operator() |
Berechnet die gewünschte Funktion. |
operator delegate_type^ |
Wandelt den Functor in eine Stellvertretung um. |
Hinweise
Die Vorlagenklasse beschreibt einen Zwei-Argument-Functor. Er definiert den Memberoperator operator() , sodass das erste Argument, wenn das Objekt als Funktion aufgerufen wird, nur true zurückgibt, wenn das erste Argument nicht dem zweiten entspricht.
Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.
Beispiel
// 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)
Generiert einen unary_negate für einen Functor.
Syntax
template<typename Fun>
unary_negate<Fun> not1(Fun% functor);
Vorlagenparameter
Fun
Der Typ des Functors.
Funktionsparameter
functor
Der Functor, der umbrochen werden soll.
Hinweise
Die Funktionsvorlage gibt zurück unary_negate<Fun>(functor). Sie verwenden es als bequeme Möglichkeit, einen Ein-Argument-Functor in einen Functor zu umschließen, der seine logische NOT liefert.
Beispiel
// 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)
Generiert einen binary_negate für einen Functor.
Syntax
template<typename Fun>
binary_negate<Fun> not2(Fun% functor);
Vorlagenparameter
Fun
Der Typ des Functors.
Funktionsparameter
functor
Der Functor, der umbrochen werden soll.
Hinweise
Die Funktionsvorlage gibt zurück binary_negate<Fun>(functor). Sie verwenden es als bequeme Möglichkeit, einen Zwei-Argument-Functor in einen Functor zu umschließen, der seine logische NOT liefert.
Beispiel
// 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)
Die Vorlagenklasse beschreibt einen Functor, der bei Aufruf das erste Argument plus die zweite zurückgibt. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den Argumenttyp anzugeben.
Syntax
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^();
};
Parameter
Arg
Der Typ der Argumente und des Rückgabewerts.
Elementfunktionen
| Typendefinition | Beschreibung |
|---|---|
delegate_type |
Der Typ des generischen Delegaten. |
first_argument_type |
Der Typ des ersten Arguments des Functors. |
result_type |
Der Typ des Functorergebnisses. |
second_argument_type |
Der Typ des zweiten Arguments des Functors. |
| Member | Beschreibung |
|---|---|
plus |
Erstellt den Functor. |
| Operator | Beschreibung |
|---|---|
operator() |
Berechnet die gewünschte Funktion. |
operator delegate_type^ |
Wandelt den Functor in eine Stellvertretung um. |
Hinweise
Die Vorlagenklasse beschreibt einen Zwei-Argument-Functor. Er definiert den Memberoperator operator() , sodass, wenn das Objekt als Funktion aufgerufen wird, das erste Argument plus die zweite zurückgibt.
Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.
Beispiel
// 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)
Die generische Klasse beschreibt einen 1-Argument-Delegaten. Sie verwenden ihn, um einen Delegat in Bezug auf das Argument und die Rückgabetypen anzugeben.
Syntax
generic<typename Arg,
typename Result>
delegate Result unary_delegate(Arg);
Parameter
Arg
Der Typ des Arguments.
Result
Der Rückgabetyp.
Hinweise
Der generische Delegat beschreibt eine Ein-Argument-Funktion.
In diesen Funktionsvorlagen:
unary_delegate<int, int> Fun1;
unary_delegate<int, int> Fun2;
die Typen Fun1 und Fun2 Synonyme sind, während für:
delegate int Fun1(int);
delegate int Fun2(int);
sie sind nicht derselbe Typ.
Beispiel
// 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)
Die generische Klasse beschreibt einen Ein-Argument-Delegaten, der zurückgegeben wird void. Sie verwenden ihn, um einen Delegat in Bezug auf den Argumenttyp anzugeben.
Syntax
generic<typename Arg>
delegate void unary_delegate_noreturn(Arg);
Parameter
Arg
Der Typ des Arguments.
Hinweise
Der generische Delegat beschreibt eine Ein-Argument-Funktion, die zurückgegeben wird void.
In diesen Funktionsvorlagen:
unary_delegate_noreturn<int> Fun1;
unary_delegate_noreturn<int> Fun2;
die Typen Fun1 und Fun2 Synonyme sind, während für:
delegate void Fun1(int);
delegate void Fun2(int);
sie sind nicht derselbe Typ.
Beispiel
// 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)
Die Vorlagenklasse beschreibt einen Functor, der, wenn sie aufgerufen wird, die logische NOT des gespeicherten Ein-Argument-Functors zurückgibt. Sie verwenden es, um ein Funktionsobjekt in Bezug auf den gespeicherten Functor anzugeben.
Syntax
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^();
};
Parameter
Fun
Der Typ des gespeicherten Functors.
Elementfunktionen
| Typendefinition | Beschreibung |
|---|---|
argument_type |
Der Typ des Functor-Arguments. |
delegate_type |
Der Typ des generischen Delegaten. |
result_type |
Der Typ des Functorergebnisses. |
| Member | Beschreibung |
|---|---|
unary_negate |
Erstellt den Functor. |
| Operator | Beschreibung |
|---|---|
operator() |
Berechnet die gewünschte Funktion. |
delegate_type^ |
Wandelt den Functor in eine Stellvertretung um. |
Hinweise
Die Vorlagenklasse beschreibt einen Ein-Argument-Functor, der einen anderen Ein-Argument-Functor speichert. Er definiert den Memberoperator operator() so, dass, wenn das Objekt als Funktion aufgerufen wird, die logische NOT des gespeicherten Functors zurückgibt, der mit dem Argument aufgerufen wird.
Sie können das Objekt auch als Funktionsargument übergeben, dessen Typ und delegate_type^ er entsprechend konvertiert wird.
Beispiel
// 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