functional (STL/CLR)
Incluez l’en-tête <cliext/functional> STL/CLR pour définir des modèles de classe fonctionnelle et des délégués et fonctions de modèle associés.
Syntaxe
#include <functional>
Spécifications
Header :<cliext/fonctionnel>
Espace de noms : cliext
Déclarations
| Déléguer | Description |
|---|---|
binary_delegate (STL/CLR) |
Délégué à deux arguments. |
binary_delegate_noreturn (STL/CLR) |
Délégué à deux arguments retournant void. |
unary_delegate (STL/CLR) |
Délégué à un argument. |
unary_delegate_noreturn (STL/CLR) |
Délégué à un argument retournant void. |
| Classe | Description |
|---|---|
binary_negate (STL/CLR) |
Fonctor pour négation d’un fonctor à deux arguments. |
binder1st (STL/CLR) |
Fonctor pour lier le premier argument à un fonctor à deux arguments. |
binder2nd (STL/CLR) |
Fonctor pour lier le deuxième argument à un fonctor à deux arguments. |
divides (STL/CLR) |
Divisez le functor. |
equal_to (STL/CLR) |
Fonctor de comparaison égal. |
greater (STL/CLR) |
Plus grand fonctor de comparaison. |
greater_equal (STL/CLR) |
Fonctor de comparaison supérieur ou égal. |
less (STL/CLR) |
Moins de fonctor de comparaison. |
less_equal (STL/CLR) |
Fonctor de comparaison inférieur ou égal. |
logical_and (STL/CLR) |
Fonctor logique ET. |
logical_not (STL/CLR) |
Fonctor logique NOT. |
logical_or (STL/CLR) |
Fonctor or logique. |
minus (STL/CLR) |
Soustraire le fonctor. |
modulus (STL/CLR) |
Fonctor modulus. |
multiplies (STL/CLR) |
Multipliez le fonctor. |
negate (STL/CLR) |
Fonctor pour renvoyer son argument n’a pas été supprimé. |
not_equal_to (STL/CLR) |
Le fonctor de comparaison n’est pas égal. |
plus (STL/CLR) |
Ajouter un fonctor. |
unary_negate (STL/CLR) |
Fonctor pour négation d’un fonctor à argument unique. |
| Fonction | Description |
|---|---|
bind1st (STL/CLR) |
Génère un binder1st pour un argument et un fonctor. |
bind2nd (STL/CLR) |
Génère un binder2nd pour un argument et un fonctor. |
not1 (STL/CLR) |
Génère une unary_negate pour un fonctor. |
not2 (STL/CLR) |
Génère une binary_negate pour un fonctor. |
Membres
binary_delegate (STL/CLR)
La classe générique décrit un délégué à deux arguments. Vous l’utilisez pour spécifier un délégué en termes d’argument et de types de retour.
Syntaxe
generic<typename Arg1,
typename Arg2,
typename Result>
delegate Result binary_delegate(Arg1, Arg2);
Paramètres
Arg1
Type du premier argument.
Arg2
Type du deuxième argument.
Result
Type de retour.
Notes
Le délégué générique décrit une fonction à deux arguments.
Dans ces modèles de fonction :
binary_delegate<int, int, int> Fun1;
binary_delegate<int, int, int> Fun2;
les types Fun1 et Fun2 sont des synonymes, tandis que pour :
delegate int Fun1(int, int);
delegate int Fun2(int, int);
ils ne sont pas du même type.
Exemple
// 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 générique décrit un délégué à deux arguments qui retourne void. Vous l’utilisez pour spécifier un délégué en termes d’argument.
Syntaxe
generic<typename Arg1,
typename Arg2>
delegate void binary_delegate(Arg1, Arg2);
Paramètres
Arg1
Type du premier argument.
Arg2
Type du deuxième argument.
Notes
Le délégué générique décrit une fonction à deux arguments qui retourne void.
Dans ces modèles de fonction :
binary_delegate_noreturn<int, int> Fun1;
binary_delegate_noreturn<int, int> Fun2;
les types Fun1 et Fun2 sont des synonymes, tandis que pour :
delegate void Fun1(int, int);
delegate void Fun2(int, int);
ils ne sont pas du même type.
Exemple
// 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 de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne la logique NOT de son fonctor à deux arguments stocké. Vous l’utilisez pour spécifier un objet de fonction en termes de fonctor stocké.
Syntaxe
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^();
};
Paramètres
Fun
Type du fonctor stocké.
Fonctions de membre
| Définition de type | Description |
|---|---|
delegate_type |
Type du délégué générique. |
first_argument_type |
Type du premier argument du fonctor. |
result_type |
Type du résultat du fonctor. |
second_argument_type |
Type du deuxième argument du fonctor. |
stored_function_type |
Type du functor. |
| Membre | Description |
|---|---|
binary_negate |
Construit le functor. |
| Opérateur | Description |
|---|---|
operator() |
Calcule la fonction souhaitée. |
operator delegate_type^() |
Convertit le fonctor en délégué. |
Notes
La classe de modèle décrit un fonctor à deux arguments qui stocke un autre fonctor à deux arguments. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne la logique NOT du fonctor stocké appelé avec les deux arguments.
Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.
Exemple
// 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)
Génère un argument et un binder1st fonctor.
Syntaxe
template<typename Fun,
typename Arg>
binder1st<Fun> bind1st(Fun% functor,
Arg left);
Paramètres de modèle
Arg
Type de l’argument.
Fun
Type du functor.
Paramètres de fonction
functor
Le functor à envelopper.
left
Premier argument à encapsuler.
Notes
Le modèle de fonction retourne binder1st<Fun>(functor, left). Vous l’utilisez comme moyen pratique d’encapsuler un fonctor à deux arguments et son premier argument dans un fonctor à un argument qui l’appelle avec un deuxième argument.
Exemple
// 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)
Génère un argument et un binder2nd fonctor.
Syntaxe
template<typename Fun,
typename Arg>
binder2nd<Fun> bind2nd(Fun% functor,
Arg right);
Paramètres de modèle
Arg
Type de l’argument.
Fun
Type du functor.
Paramètres de fonction
functor
Le functor à envelopper.
right
Deuxième argument à encapsuler.
Notes
Le modèle de fonction retourne binder2nd<Fun>(functor, right). Vous l’utilisez comme moyen pratique d’encapsuler un fonctor à deux arguments et son deuxième argument dans un fonctor à un argument qui l’appelle avec un premier argument.
Exemple
// 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 de modèle décrit un fonctor à argument unique qui, lorsqu’elle est appelée, retourne son fonctor à deux arguments stocké appelé avec son premier argument stocké et le deuxième argument fourni. Vous l’utilisez pour spécifier un objet de fonction en termes de fonctor stocké.
Syntaxe
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^();
};
Paramètres
Fun
Type du fonctor stocké.
Fonctions de membre
| Définition de type | Description |
|---|---|
delegate_type |
Type du délégué générique. |
first_argument_type |
Type du premier argument du fonctor. |
result_type |
Type du résultat du fonctor. |
second_argument_type |
Type du deuxième argument du fonctor. |
stored_function_type |
Type du functor. |
| Membre | Description |
|---|---|
binder1st |
Construit le functor. |
| Opérateur | Description |
|---|---|
operator() |
Calcule la fonction souhaitée. |
operator delegate_type^() |
Convertit le fonctor en délégué. |
Notes
La classe de modèle décrit un fonctor à argument unique qui stocke un fonctor à deux arguments et un premier argument. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne le résultat de l’appel du fonctor stocké avec le premier argument stocké et le deuxième argument fourni.
Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.
Exemple
// 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 de modèle décrit un fonctor à argument unique qui, lorsqu’elle est appelée, retourne son fonctor à deux arguments stocké appelé avec le premier argument fourni et son deuxième argument stocké. Vous l’utilisez pour spécifier un objet de fonction en termes de fonctor stocké.
Syntaxe
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^();
};
Paramètres
Fun
Type du fonctor stocké.
Fonctions de membre
| Définition de type | Description |
|---|---|
delegate_type |
Type du délégué générique. |
first_argument_type |
Type du premier argument du fonctor. |
result_type |
Type du résultat du fonctor. |
second_argument_type |
Type du deuxième argument du fonctor. |
stored_function_type |
Type du functor. |
| Membre | Description |
|---|---|
binder2nd |
Construit le functor. |
| Opérateur | Description |
|---|---|
operator() |
Calcule la fonction souhaitée. |
operator delegate_type^() |
Convertit le fonctor en délégué. |
Notes
La classe de modèle décrit un fonctor à argument unique qui stocke un fonctor à deux arguments et un deuxième argument. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne le résultat de l’appel du fonctor stocké avec le premier argument fourni et le deuxième argument stocké.
Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.
Exemple
// 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 de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne le premier argument divisé par la seconde. Vous l’utilisez pour spécifier un objet de fonction en termes de son type d’argument.
Syntaxe
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^();
};
Paramètres
Arg
Type des arguments et valeur de retour.
Fonctions de membre
| Définition de type | Description |
|---|---|
delegate_type |
Type du délégué générique. |
first_argument_type |
Type du premier argument du fonctor. |
result_type |
Type du résultat du fonctor. |
second_argument_type |
Type du deuxième argument du fonctor. |
| Membre | Description |
|---|---|
divides |
Construit le functor. |
| Opérateur | Description |
|---|---|
operator() |
Calcule la fonction souhaitée. |
operator delegate_type^() |
Convertit le fonctor en délégué. |
Notes
La classe de modèle décrit un fonctor à deux arguments. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne le premier argument divisé par la seconde.
Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.
Exemple
// 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 de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne true uniquement si le premier argument est égal à la seconde. Vous l’utilisez pour spécifier un objet de fonction en termes de son type d’argument.
Syntaxe
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^();
};
Paramètres
Arg
Type des arguments.
Fonctions de membre
| Définition de type | Description |
|---|---|
delegate_type |
Type du délégué générique. |
first_argument_type |
Type du premier argument du fonctor. |
result_type |
Type du résultat du fonctor. |
second_argument_type |
Type du deuxième argument du fonctor. |
| Membre | Description |
|---|---|
equal_to |
Construit le functor. |
| Opérateur | Description |
|---|---|
operator() |
Calcule la fonction souhaitée. |
operator delegate_type^() |
Convertit le fonctor en délégué. |
Notes
La classe de modèle décrit un fonctor à deux arguments. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne true uniquement si le premier argument est égal à la seconde.
Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.
Exemple
// 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 de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne true uniquement si le premier argument est supérieur à la seconde. Vous l’utilisez pour spécifier un objet de fonction en termes de son type d’argument.
Syntaxe
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^();
};
Paramètres
Arg
Type des arguments.
Fonctions de membre
| Définition de type | Description |
|---|---|
delegate_type |
Type du délégué générique. |
first_argument_type |
Type du premier argument du fonctor. |
result_type |
Type du résultat du fonctor. |
second_argument_type |
Type du deuxième argument du fonctor. |
| Membre | Description |
|---|---|
greater |
Construit le functor. |
| Opérateur | Description |
|---|---|
operator() |
Calcule la fonction souhaitée. |
operator delegate_type^ |
Convertit le fonctor en délégué. |
Notes
La classe de modèle décrit un fonctor à deux arguments. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne true uniquement si le premier argument est supérieur à la seconde.
Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.
Exemple
// 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 de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne true uniquement si le premier argument est supérieur ou égal à la seconde. Vous l’utilisez pour spécifier un objet de fonction en termes de son type d’argument.
Syntaxe
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^();
};
Paramètres
Arg
Type des arguments.
Fonctions de membre
| Définition de type | Description |
|---|---|
delegate_type |
Type du délégué générique. |
first_argument_type |
Type du premier argument du fonctor. |
result_type |
Type du résultat du fonctor. |
second_argument_type |
Type du deuxième argument du fonctor. |
| Membre | Description |
|---|---|
greater_equal |
Construit le functor. |
| Opérateur | Description |
|---|---|
operator() |
Calcule la fonction souhaitée. |
operator delegate_type^ |
Convertit le fonctor en délégué. |
Notes
La classe de modèle décrit un fonctor à deux arguments. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne true uniquement si le premier argument est supérieur ou égal à la seconde.
Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.
Exemple
// 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 de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne true uniquement si le premier argument est inférieur à la seconde. Vous l’utilisez pour spécifier un objet de fonction en termes de son type d’argument.
Syntaxe
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^();
};
Paramètres
Arg
Type des arguments.
Fonctions de membre
| Définition de type | Description |
|---|---|
delegate_type |
Type du délégué générique. |
first_argument_type |
Type du premier argument du fonctor. |
result_type |
Type du résultat du fonctor. |
second_argument_type |
Type du deuxième argument du fonctor. |
| Membre | Description |
|---|---|
less |
Construit le functor. |
| Opérateur | Description |
|---|---|
operator() |
Calcule la fonction souhaitée. |
operator delegate_type^ |
Convertit le fonctor en délégué. |
Notes
La classe de modèle décrit un fonctor à deux arguments. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne true uniquement si le premier argument est inférieur à la seconde.
Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.
Exemple
// 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 de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne true uniquement si le premier argument est inférieur ou égal à la seconde. Vous l’utilisez pour spécifier un objet de fonction en termes de son type d’argument.
Syntaxe
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^();
};
Paramètres
Arg
Type des arguments.
Fonctions de membre
| Définition de type | Description |
|---|---|
delegate_type |
Type du délégué générique. |
first_argument_type |
Type du premier argument du fonctor. |
result_type |
Type du résultat du fonctor. |
second_argument_type |
Type du deuxième argument du fonctor. |
| Membre | Description |
|---|---|
less_equal |
Construit le functor. |
| Opérateur | Description |
|---|---|
operator() |
Calcule la fonction souhaitée. |
operator delegate_type^ |
Convertit le fonctor en délégué. |
Notes
La classe de modèle décrit un fonctor à deux arguments. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne true uniquement si le premier argument est inférieur ou égal à la seconde.
Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.
Exemple
// 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 de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne true uniquement si le premier argument et le deuxième test sont vrais. Vous l’utilisez pour spécifier un objet de fonction en termes de son type d’argument.
Syntaxe
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^();
};
Paramètres
Arg
Type des arguments.
Fonctions de membre
| Définition de type | Description |
|---|---|
delegate_type |
Type du délégué générique. |
first_argument_type |
Type du premier argument du fonctor. |
result_type |
Type du résultat du fonctor. |
second_argument_type |
Type du deuxième argument du fonctor. |
| Membre | Description |
|---|---|
logical_and |
Construit le functor. |
| Opérateur | Description |
|---|---|
operator() |
Calcule la fonction souhaitée. |
operator delegate_type^ |
Convertit le fonctor en délégué. |
Notes
La classe de modèle décrit un fonctor à deux arguments. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne true uniquement si le premier argument et le deuxième test sont vrais.
Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.
Exemple
// 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 de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne true uniquement si son argument teste la valeur false. Vous l’utilisez pour spécifier un objet de fonction en termes de son type d’argument.
Syntaxe
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^();
};
Paramètres
Arg
Type des arguments.
Fonctions de membre
| Définition de type | Description |
|---|---|
argument_type |
Type de l’argument fonctor. |
delegate_type |
Type du délégué générique. |
result_type |
Type du résultat du fonctor. |
| Membre | Description |
|---|---|
logical_not |
Construit le functor. |
| Opérateur | Description |
|---|---|
operator() |
Calcule la fonction souhaitée. |
operator delegate_type^ |
Convertit le fonctor en délégué. |
Notes
La classe de modèle décrit un fonctor à argument unique. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne true uniquement si son argument teste comme false.
Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.
Exemple
// 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 de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne true uniquement si le premier argument ou le deuxième test est vrai. Vous l’utilisez pour spécifier un objet de fonction en termes de son type d’argument.
Syntaxe
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^();
};
Paramètres
Arg
Type des arguments.
Fonctions de membre
| Définition de type | Description |
|---|---|
delegate_type |
Type du délégué générique. |
first_argument_type |
Type du premier argument du fonctor. |
result_type |
Type du résultat du fonctor. |
second_argument_type |
Type du deuxième argument du fonctor. |
| Membre | Description |
|---|---|
logical_or |
Construit le functor. |
| Opérateur | Description |
|---|---|
operator() |
Calcule la fonction souhaitée. |
operator delegate_type^ |
Convertit le fonctor en délégué. |
Notes
La classe de modèle décrit un fonctor à deux arguments. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne true uniquement si le premier argument ou le second teste la valeur true.
Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.
Exemple
// 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 de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne le premier argument moins le deuxième. Vous l’utilisez pour spécifier un objet de fonction en termes de son type d’argument.
Syntaxe
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^();
};
Paramètres
Arg
Type des arguments et valeur de retour.
Fonctions de membre
| Définition de type | Description |
|---|---|
delegate_type |
Type du délégué générique. |
first_argument_type |
Type du premier argument du fonctor. |
result_type |
Type du résultat du fonctor. |
second_argument_type |
Type du deuxième argument du fonctor. |
| Membre | Description |
|---|---|
minus |
Construit le functor. |
| Opérateur | Description |
|---|---|
operator() |
Calcule la fonction souhaitée. |
operator delegate_type^ |
Convertit le fonctor en délégué. |
Notes
La classe de modèle décrit un fonctor à deux arguments. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne le premier argument moins le deuxième.
Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.
Exemple
// 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 de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne le premier argument modulo le deuxième. Vous l’utilisez pour spécifier un objet de fonction en termes de son type d’argument.
Syntaxe
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^();
};
Paramètres
Arg
Type des arguments et valeur de retour.
Fonctions de membre
| Définition de type | Description |
|---|---|
delegate_type |
Type du délégué générique. |
first_argument_type |
Type du premier argument du fonctor. |
result_type |
Type du résultat du fonctor. |
second_argument_type |
Type du deuxième argument du fonctor. |
| Membre | Description |
|---|---|
modulus |
Construit le functor. |
| Opérateur | Description |
|---|---|
operator() |
Calcule la fonction souhaitée. |
operator delegate_type^ |
Convertit le fonctor en délégué. |
Notes
La classe de modèle décrit un fonctor à deux arguments. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne le premier argument modulo le second.
Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.
Exemple
// 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 de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne le premier argument fois la seconde. Vous l’utilisez pour spécifier un objet de fonction en termes de son type d’argument.
Syntaxe
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^();
};
Paramètres
Arg
Type des arguments et valeur de retour.
Fonctions de membre
| Définition de type | Description |
|---|---|
delegate_type |
Type du délégué générique. |
first_argument_type |
Type du premier argument du fonctor. |
result_type |
Type du résultat du fonctor. |
second_argument_type |
Type du deuxième argument du fonctor. |
| Membre | Description |
|---|---|
multiplies |
Construit le functor. |
| Opérateur | Description |
|---|---|
operator() |
Calcule la fonction souhaitée. |
operator delegate_type^ |
Convertit le fonctor en délégué. |
Notes
La classe de modèle décrit un fonctor à deux arguments. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne le premier argument fois la seconde.
Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.
Exemple
// 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 de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne son argument négation. Vous l’utilisez pour spécifier un objet de fonction en termes de son type d’argument.
Syntaxe
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^();
};
Paramètres
Arg
Type des arguments.
Fonctions de membre
| Définition de type | Description |
|---|---|
argument_type |
Type de l’argument fonctor. |
delegate_type |
Type du délégué générique. |
result_type |
Type du résultat du fonctor. |
| Membre | Description |
|---|---|
negate |
Construit le functor. |
| Opérateur | Description |
|---|---|
operator() |
Calcule la fonction souhaitée. |
operator delegate_type^ |
Convertit le fonctor en délégué. |
Notes
La classe de modèle décrit un fonctor à argument unique. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne son argument négation.
Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.
Exemple
// 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 de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne true uniquement si le premier argument n’est pas égal à la seconde. Vous l’utilisez pour spécifier un objet de fonction en termes de son type d’argument.
Syntaxe
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^();
};
Paramètres
Arg
Type des arguments.
Fonctions de membre
| Définition de type | Description |
|---|---|
delegate_type |
Type du délégué générique. |
first_argument_type |
Type du premier argument du fonctor. |
result_type |
Type du résultat du fonctor. |
second_argument_type |
Type du deuxième argument du fonctor. |
| Membre | Description |
|---|---|
not_equal_to |
Construit le functor. |
| Opérateur | Description |
|---|---|
operator() |
Calcule la fonction souhaitée. |
operator delegate_type^ |
Convertit le fonctor en délégué. |
Notes
La classe de modèle décrit un fonctor à deux arguments. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne true uniquement si le premier argument n’est pas égal à la seconde.
Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.
Exemple
// 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)
Génère un unary_negate fonctor pour un fonctor.
Syntaxe
template<typename Fun>
unary_negate<Fun> not1(Fun% functor);
Paramètres de modèle
Fun
Type du functor.
Paramètres de fonction
functor
Le functor à envelopper.
Notes
Le modèle de fonction retourne unary_negate<Fun>(functor). Vous l’utilisez comme moyen pratique d’encapsuler un functor à argument unique dans un functor qui fournit son non logique.
Exemple
// 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)
Génère un binary_negate fonctor pour un fonctor.
Syntaxe
template<typename Fun>
binary_negate<Fun> not2(Fun% functor);
Paramètres de modèle
Fun
Type du functor.
Paramètres de fonction
functor
Le functor à envelopper.
Notes
Le modèle de fonction retourne binary_negate<Fun>(functor). Vous l’utilisez comme moyen pratique d’encapsuler un fonctor à deux arguments dans un functor qui fournit son non logique.
Exemple
// 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 de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne le premier argument plus le deuxième. Vous l’utilisez pour spécifier un objet de fonction en termes de son type d’argument.
Syntaxe
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^();
};
Paramètres
Arg
Type des arguments et valeur de retour.
Fonctions de membre
| Définition de type | Description |
|---|---|
delegate_type |
Type du délégué générique. |
first_argument_type |
Type du premier argument du fonctor. |
result_type |
Type du résultat du fonctor. |
second_argument_type |
Type du deuxième argument du fonctor. |
| Membre | Description |
|---|---|
plus |
Construit le functor. |
| Opérateur | Description |
|---|---|
operator() |
Calcule la fonction souhaitée. |
operator delegate_type^ |
Convertit le fonctor en délégué. |
Notes
La classe de modèle décrit un fonctor à deux arguments. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne le premier argument plus le deuxième.
Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.
Exemple
// 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 générique décrit un délégué à un argument. Vous l’utilisez pour spécifier un délégué en termes d’argument et de types de retour.
Syntaxe
generic<typename Arg,
typename Result>
delegate Result unary_delegate(Arg);
Paramètres
Arg
Type de l’argument.
Result
Type de retour.
Notes
Le délégué générique décrit une fonction à argument unique.
Dans ces modèles de fonction :
unary_delegate<int, int> Fun1;
unary_delegate<int, int> Fun2;
les types Fun1 et Fun2 sont des synonymes, tandis que pour :
delegate int Fun1(int);
delegate int Fun2(int);
ils ne sont pas du même type.
Exemple
// 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 générique décrit un délégué à un argument qui retourne void. Vous l’utilisez pour spécifier un délégué en termes de type d’argument.
Syntaxe
generic<typename Arg>
delegate void unary_delegate_noreturn(Arg);
Paramètres
Arg
Type de l’argument.
Notes
Le délégué générique décrit une fonction à argument unique qui retourne void.
Dans ces modèles de fonction :
unary_delegate_noreturn<int> Fun1;
unary_delegate_noreturn<int> Fun2;
les types Fun1 et Fun2 sont des synonymes, tandis que pour :
delegate void Fun1(int);
delegate void Fun2(int);
ils ne sont pas du même type.
Exemple
// 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 de modèle décrit un fonctor qui, lorsqu’il est appelé, retourne la logique NOT de son fonctor un argument stocké. Vous l’utilisez pour spécifier un objet de fonction en termes de fonctor stocké.
Syntaxe
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^();
};
Paramètres
Fun
Type du fonctor stocké.
Fonctions de membre
| Définition de type | Description |
|---|---|
argument_type |
Type de l’argument fonctor. |
delegate_type |
Type du délégué générique. |
result_type |
Type du résultat du fonctor. |
| Membre | Description |
|---|---|
unary_negate |
Construit le functor. |
| Opérateur | Description |
|---|---|
operator() |
Calcule la fonction souhaitée. |
delegate_type^ |
Convertit le fonctor en délégué. |
Notes
La classe de modèle décrit un fonctor à argument unique qui stocke un autre fonctor un argument. Il définit l’opérateur operator() membre de sorte que, lorsque l’objet est appelé en tant que fonction, il retourne la logique NOT du fonctor stocké appelé avec l’argument.
Vous pouvez également passer l’objet en tant qu’argument de fonction dont le type est delegate_type^ et qu’il sera converti de manière appropriée.
Exemple
// 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