functional (STL/CLR)
함수 클래스 템플릿 및 관련 템플릿 대리자 및 함수를 정의하려면 STL/CLR 헤더 <cliext/functional> 를 포함합니다.
구문
#include <functional>
요구 사항
헤더:<cliext/functional>
네임스페이스: cliext
선언
| 대리인 | 설명 |
|---|---|
binary_delegate (STL/CLR) |
두 인수 대리자입니다. |
binary_delegate_noreturn (STL/CLR) |
2 인수 대리자를 반환합니다 void. |
unary_delegate (STL/CLR) |
1 인수 대리자입니다. |
unary_delegate_noreturn (STL/CLR) |
1 인수 대리자를 반환합니다 void. |
| 클래스 | 설명 |
|---|---|
binary_negate (STL/CLR) |
2 인수 펀터를 부정하는 펀터입니다. |
binder1st (STL/CLR) |
첫 번째 인수를 두 인수 functor에 바인딩하는 Functor입니다. |
binder2nd (STL/CLR) |
두 번째 인수를 두 인수 functor에 바인딩하는 Functor입니다. |
divides (STL/CLR) |
Functor를 나눕니다. |
equal_to (STL/CLR) |
같음 비교 펀터입니다. |
greater (STL/CLR) |
더 큰 비교 펀터. |
greater_equal (STL/CLR) |
크거나 같은 비교 펀터입니다. |
less (STL/CLR) |
적은 비교 균사. |
less_equal (STL/CLR) |
보다 작거나 같은 비교 펀터입니다. |
logical_and (STL/CLR) |
논리 및 펀터입니다. |
logical_not (STL/CLR) |
논리 NOT functor입니다. |
logical_or (STL/CLR) |
논리 또는 펀터입니다. |
minus (STL/CLR) |
펑터를 뺍니다. |
modulus (STL/CLR) |
모듈러스 펀터. |
multiplies (STL/CLR) |
Functor를 곱합니다. |
negate (STL/CLR) |
인수를 부정 반환하는 Functor입니다. |
not_equal_to (STL/CLR) |
비교 균등하지 않습니다. |
plus (STL/CLR) |
functor를 추가합니다. |
unary_negate (STL/CLR) |
원 인수 펀터를 부정하는 펀터입니다. |
| 함수 | 설명 |
|---|---|
bind1st (STL/CLR) |
인수 및 functor에 대한 binder1st를 생성합니다. |
bind2nd (STL/CLR) |
인수 및 functor에 대한 binder2nd를 생성합니다. |
not1 (STL/CLR) |
functor에 대한 unary_negate 생성합니다. |
not2 (STL/CLR) |
functor에 대한 binary_negate 생성합니다. |
멤버
binary_delegate (STL/CLR)
제네릭 클래스는 두 인수 대리자를 설명합니다. 인수 및 반환 형식 측면에서 대리자를 지정하는 데 사용합니다.
구문
generic<typename Arg1,
typename Arg2,
typename Result>
delegate Result binary_delegate(Arg1, Arg2);
매개 변수
Arg1
첫 번째 인수의 형식입니다.
Arg2
두 번째 인수의 형식입니다.
Result
반환 형식입니다.
설명
제네릭 대리자는 두 인수 함수를 설명합니다.
다음 함수 템플릿에서 다음을 수행합니다.
binary_delegate<int, int, int> Fun1;
binary_delegate<int, int, int> Fun2;
형식 Fun1 과 Fun2 동의어는 다음과 같습니다.
delegate int Fun1(int, int);
delegate int Fun2(int, int);
형식이 다릅니다.
예시
// 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)
제네릭 클래스는 반환하는 두 인수 대리자를 설명합니다 void. 인수 측면에서 대리자를 지정하는 데 사용합니다.
구문
generic<typename Arg1,
typename Arg2>
delegate void binary_delegate(Arg1, Arg2);
매개 변수
Arg1
첫 번째 인수의 형식입니다.
Arg2
두 번째 인수의 형식입니다.
설명
제네릭 대리자는 반환되는 두 인수 함수를 설명합니다 void.
다음 함수 템플릿에서 다음을 수행합니다.
binary_delegate_noreturn<int, int> Fun1;
binary_delegate_noreturn<int, int> Fun2;
형식 Fun1 과 Fun2 동의어는 다음과 같습니다.
delegate void Fun1(int, int);
delegate void Fun2(int, int);
형식이 다릅니다.
예시
// 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)
템플릿 클래스는 호출될 때 저장된 두 인수 펀터의 논리 NOT을 반환하는 functor를 설명합니다. 이 함수는 저장된 functor의 측면에서 함수 개체를 지정합니다.
구문
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^();
};
매개 변수
Fun
저장된 functor의 형식입니다.
멤버 함수
| 형식 정의 | 설명 |
|---|---|
delegate_type |
제네릭 대리자의 형식입니다. |
first_argument_type |
첫 번째 펀터 인수의 형식입니다. |
result_type |
펀터 결과의 형식입니다. |
second_argument_type |
functor second 인수의 형식입니다. |
stored_function_type |
functor의 형식입니다. |
| 멤버 | 설명 |
|---|---|
binary_negate |
functor를 생성합니다. |
| Operator | 설명 |
|---|---|
operator() |
원하는 함수를 계산합니다. |
operator delegate_type^() |
functor를 대리자로 캐스팅합니다. |
설명
템플릿 클래스는 다른 두 인수 functor를 저장하는 2 인수 펀터에 대해 설명합니다. 개체가 함수로 호출될 때 두 인수로 호출된 저장된 functor의 논리 NOT을 반환할 수 있도록 멤버 연산 operator() 자를 정의합니다.
개체를 형식 delegate_type^ 이 적절한 함수 인수로 전달하여 적절하게 변환할 수도 있습니다.
예시
// 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)
인수 및 functor에 대한 a를 생성합니다 binder1st .
구문
template<typename Fun,
typename Arg>
binder1st<Fun> bind1st(Fun% functor,
Arg left);
템플릿 매개 변수
Arg
인수 형식입니다.
Fun
functor의 형식입니다.
함수 매개 변수
functor
래핑할 펀터입니다.
left
래핑할 첫 번째 인수입니다.
설명
함수 템플릿은 .를 반환합니다 binder1st<Fun>(functor, left). 두 번째 인수로 호출하는 1 인수 펀터에서 2 인수 functor와 첫 번째 인수를 래핑하는 편리한 방법으로 사용합니다.
예시
// 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)
인수 및 functor에 대한 a를 생성합니다 binder2nd .
구문
template<typename Fun,
typename Arg>
binder2nd<Fun> bind2nd(Fun% functor,
Arg right);
템플릿 매개 변수
Arg
인수 형식입니다.
Fun
functor의 형식입니다.
함수 매개 변수
functor
래핑할 펀터입니다.
right
래핑할 두 번째 인수입니다.
설명
함수 템플릿은 .를 반환합니다 binder2nd<Fun>(functor, right). 첫 번째 인수로 호출하는 1 인수 펀터에서 두 인수 펀터와 두 번째 인수를 래핑하는 편리한 방법으로 사용합니다.
예시
// 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)
템플릿 클래스는 호출될 때 저장된 첫 번째 인수와 제공된 두 번째 인수를 사용하여 호출된 저장된 두 인수 functor를 반환하는 1 인수 functor를 설명합니다. 이 함수는 저장된 functor의 측면에서 함수 개체를 지정합니다.
구문
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^();
};
매개 변수
Fun
저장된 functor의 형식입니다.
멤버 함수
| 형식 정의 | 설명 |
|---|---|
delegate_type |
제네릭 대리자의 형식입니다. |
first_argument_type |
첫 번째 펀터 인수의 형식입니다. |
result_type |
펀터 결과의 형식입니다. |
second_argument_type |
functor second 인수의 형식입니다. |
stored_function_type |
functor의 형식입니다. |
| 멤버 | 설명 |
|---|---|
binder1st |
functor를 생성합니다. |
| Operator | 설명 |
|---|---|
operator() |
원하는 함수를 계산합니다. |
operator delegate_type^() |
functor를 대리자로 캐스팅합니다. |
설명
템플릿 클래스는 2 인수 functor와 첫 번째 인수를 저장하는 1 인수 functor를 설명합니다. 개체가 함수로 호출될 때 저장된 첫 번째 인수와 제공된 두 번째 인수를 사용하여 저장된 functor를 호출한 결과를 반환할 수 있도록 멤버 연산 operator() 자를 정의합니다.
개체를 형식 delegate_type^ 이 적절한 함수 인수로 전달하여 적절하게 변환할 수도 있습니다.
예시
// 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)
템플릿 클래스는 호출될 때 제공된 첫 번째 인수와 저장된 두 번째 인수를 사용하여 호출된 저장된 두 인수 functor를 반환하는 1 인수 functor를 설명합니다. 이 함수는 저장된 functor의 측면에서 함수 개체를 지정합니다.
구문
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^();
};
매개 변수
Fun
저장된 functor의 형식입니다.
멤버 함수
| 형식 정의 | 설명 |
|---|---|
delegate_type |
제네릭 대리자의 형식입니다. |
first_argument_type |
첫 번째 펀터 인수의 형식입니다. |
result_type |
펀터 결과의 형식입니다. |
second_argument_type |
functor second 인수의 형식입니다. |
stored_function_type |
functor의 형식입니다. |
| 멤버 | 설명 |
|---|---|
binder2nd |
functor를 생성합니다. |
| Operator | 설명 |
|---|---|
operator() |
원하는 함수를 계산합니다. |
operator delegate_type^() |
functor를 대리자로 캐스팅합니다. |
설명
템플릿 클래스는 2 인수 functor와 두 번째 인수를 저장하는 1 인수 펀터에 대해 설명합니다. 개체가 함수로 호출될 때 제공된 첫 번째 인수와 저장된 두 번째 인수를 사용하여 저장된 functor를 호출한 결과를 반환할 수 있도록 멤버 연산 operator() 자를 정의합니다.
개체를 형식 delegate_type^ 이 적절한 함수 인수로 전달하여 적절하게 변환할 수도 있습니다.
예시
// 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)
템플릿 클래스는 호출할 때 첫 번째 인수를 두 번째로 나눈 값을 반환하는 functor를 설명합니다. 함수 개체를 인수 형식으로 지정하는 데 사용합니다.
구문
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^();
};
매개 변수
Arg
인수 및 반환 값의 형식입니다.
멤버 함수
| 형식 정의 | 설명 |
|---|---|
delegate_type |
제네릭 대리자의 형식입니다. |
first_argument_type |
첫 번째 펀터 인수의 형식입니다. |
result_type |
펀터 결과의 형식입니다. |
second_argument_type |
functor second 인수의 형식입니다. |
| 멤버 | 설명 |
|---|---|
divides |
functor를 생성합니다. |
| Operator | 설명 |
|---|---|
operator() |
원하는 함수를 계산합니다. |
operator delegate_type^() |
functor를 대리자로 캐스팅합니다. |
설명
템플릿 클래스는 두 인수 functor를 설명합니다. 개체가 함수로 호출되면 첫 번째 인수를 두 번째로 나눈 값을 반환할 수 있도록 멤버 연산 operator() 자를 정의합니다.
개체를 형식 delegate_type^ 이 적절한 함수 인수로 전달하여 적절하게 변환할 수도 있습니다.
예시
// 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)
템플릿 클래스는 첫 번째 인수가 두 번째 인수와 같은 경우에만 true를 반환하는 functor를 설명합니다. 함수 개체를 인수 형식으로 지정하는 데 사용합니다.
구문
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^();
};
매개 변수
Arg
인수의 형식입니다.
멤버 함수
| 형식 정의 | 설명 |
|---|---|
delegate_type |
제네릭 대리자의 형식입니다. |
first_argument_type |
첫 번째 펀터 인수의 형식입니다. |
result_type |
펀터 결과의 형식입니다. |
second_argument_type |
functor second 인수의 형식입니다. |
| 멤버 | 설명 |
|---|---|
equal_to |
functor를 생성합니다. |
| Operator | 설명 |
|---|---|
operator() |
원하는 함수를 계산합니다. |
operator delegate_type^() |
functor를 대리자로 캐스팅합니다. |
설명
템플릿 클래스는 두 인수 functor를 설명합니다. 개체가 함수로 호출되면 첫 번째 인수가 두 번째 인수와 같은 경우에만 true를 반환하도록 멤버 연산 operator() 자를 정의합니다.
개체를 형식 delegate_type^ 이 적절한 함수 인수로 전달하여 적절하게 변환할 수도 있습니다.
예시
// 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)
템플릿 클래스는 첫 번째 인수가 두 번째 인수보다 큰 경우에만 true를 반환하는 functor를 설명합니다. 함수 개체를 인수 형식으로 지정하는 데 사용합니다.
구문
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^();
};
매개 변수
Arg
인수의 형식입니다.
멤버 함수
| 형식 정의 | 설명 |
|---|---|
delegate_type |
제네릭 대리자의 형식입니다. |
first_argument_type |
첫 번째 펀터 인수의 형식입니다. |
result_type |
펀터 결과의 형식입니다. |
second_argument_type |
functor second 인수의 형식입니다. |
| 멤버 | 설명 |
|---|---|
greater |
functor를 생성합니다. |
| Operator | 설명 |
|---|---|
operator() |
원하는 함수를 계산합니다. |
operator delegate_type^ |
functor를 대리자로 캐스팅합니다. |
설명
템플릿 클래스는 두 인수 functor를 설명합니다. 개체가 함수로 호출되면 첫 번째 인수가 두 번째 인수보다 큰 경우에만 true를 반환할 수 있도록 멤버 연산 operator() 자를 정의합니다.
개체를 형식 delegate_type^ 이 적절한 함수 인수로 전달하여 적절하게 변환할 수도 있습니다.
예시
// 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)
템플릿 클래스는 첫 번째 인수가 두 번째 인수보다 크거나 같은 경우에만 true를 반환하는 functor를 설명합니다. 함수 개체를 인수 형식으로 지정하는 데 사용합니다.
구문
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^();
};
매개 변수
Arg
인수의 형식입니다.
멤버 함수
| 형식 정의 | 설명 |
|---|---|
delegate_type |
제네릭 대리자의 형식입니다. |
first_argument_type |
첫 번째 펀터 인수의 형식입니다. |
result_type |
펀터 결과의 형식입니다. |
second_argument_type |
functor second 인수의 형식입니다. |
| 멤버 | 설명 |
|---|---|
greater_equal |
functor를 생성합니다. |
| Operator | 설명 |
|---|---|
operator() |
원하는 함수를 계산합니다. |
operator delegate_type^ |
functor를 대리자로 캐스팅합니다. |
설명
템플릿 클래스는 두 인수 functor를 설명합니다. 개체를 함수로 호출할 때 첫 번째 인수가 두 번째 인수보다 크거나 같은 경우에만 true를 반환하도록 멤버 연산 operator() 자를 정의합니다.
개체를 형식 delegate_type^ 이 적절한 함수 인수로 전달하여 적절하게 변환할 수도 있습니다.
예시
// 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)
템플릿 클래스는 첫 번째 인수가 두 번째 인수보다 작은 경우에만 true를 반환하는 functor를 설명합니다. 함수 개체를 인수 형식으로 지정하는 데 사용합니다.
구문
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^();
};
매개 변수
Arg
인수의 형식입니다.
멤버 함수
| 형식 정의 | 설명 |
|---|---|
delegate_type |
제네릭 대리자의 형식입니다. |
first_argument_type |
첫 번째 펀터 인수의 형식입니다. |
result_type |
펀터 결과의 형식입니다. |
second_argument_type |
functor second 인수의 형식입니다. |
| 멤버 | 설명 |
|---|---|
less |
functor를 생성합니다. |
| Operator | 설명 |
|---|---|
operator() |
원하는 함수를 계산합니다. |
operator delegate_type^ |
functor를 대리자로 캐스팅합니다. |
설명
템플릿 클래스는 두 인수 functor를 설명합니다. 개체를 함수로 호출할 때 첫 번째 인수가 두 번째 인수보다 작은 경우에만 true를 반환할 수 있도록 멤버 연산 operator() 자를 정의합니다.
개체를 형식 delegate_type^ 이 적절한 함수 인수로 전달하여 적절하게 변환할 수도 있습니다.
예시
// 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)
템플릿 클래스는 첫 번째 인수가 두 번째 인수보다 작거나 같은 경우에만 true를 반환하는 functor를 설명합니다. 함수 개체를 인수 형식으로 지정하는 데 사용합니다.
구문
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^();
};
매개 변수
Arg
인수의 형식입니다.
멤버 함수
| 형식 정의 | 설명 |
|---|---|
delegate_type |
제네릭 대리자의 형식입니다. |
first_argument_type |
첫 번째 펀터 인수의 형식입니다. |
result_type |
펀터 결과의 형식입니다. |
second_argument_type |
functor second 인수의 형식입니다. |
| 멤버 | 설명 |
|---|---|
less_equal |
functor를 생성합니다. |
| Operator | 설명 |
|---|---|
operator() |
원하는 함수를 계산합니다. |
operator delegate_type^ |
functor를 대리자로 캐스팅합니다. |
설명
템플릿 클래스는 두 인수 functor를 설명합니다. 개체를 함수로 호출할 때 첫 번째 인수가 두 번째 인수보다 작거나 같은 경우에만 true를 반환하도록 멤버 연산 operator() 자를 정의합니다.
개체를 형식 delegate_type^ 이 적절한 함수 인수로 전달하여 적절하게 변환할 수도 있습니다.
예시
// 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)
템플릿 클래스는 호출 시 첫 번째 인수와 두 번째 테스트가 모두 true인 경우에만 true를 반환하는 functor를 설명합니다. 함수 개체를 인수 형식으로 지정하는 데 사용합니다.
구문
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^();
};
매개 변수
Arg
인수의 형식입니다.
멤버 함수
| 형식 정의 | 설명 |
|---|---|
delegate_type |
제네릭 대리자의 형식입니다. |
first_argument_type |
첫 번째 펀터 인수의 형식입니다. |
result_type |
펀터 결과의 형식입니다. |
second_argument_type |
functor second 인수의 형식입니다. |
| 멤버 | 설명 |
|---|---|
logical_and |
functor를 생성합니다. |
| Operator | 설명 |
|---|---|
operator() |
원하는 함수를 계산합니다. |
operator delegate_type^ |
functor를 대리자로 캐스팅합니다. |
설명
템플릿 클래스는 두 인수 functor를 설명합니다. 개체가 함수로 호출되면 첫 번째 인수와 두 번째 테스트가 모두 true인 경우에만 true를 반환할 수 있도록 멤버 연산 operator() 자를 정의합니다.
개체를 형식 delegate_type^ 이 적절한 함수 인수로 전달하여 적절하게 변환할 수도 있습니다.
예시
// 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)
템플릿 클래스는 호출할 때 인수가 false로 테스트되는 경우에만 true를 반환하는 functor를 설명합니다. 함수 개체를 인수 형식으로 지정하는 데 사용합니다.
구문
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^();
};
매개 변수
Arg
인수의 형식입니다.
멤버 함수
| 형식 정의 | 설명 |
|---|---|
argument_type |
functor 인수의 형식입니다. |
delegate_type |
제네릭 대리자의 형식입니다. |
result_type |
펀터 결과의 형식입니다. |
| 멤버 | 설명 |
|---|---|
logical_not |
functor를 생성합니다. |
| Operator | 설명 |
|---|---|
operator() |
원하는 함수를 계산합니다. |
operator delegate_type^ |
functor를 대리자로 캐스팅합니다. |
설명
템플릿 클래스는 한 인수 functor에 대해 설명합니다. 개체가 함수로 호출되면 인수가 false로 테스트되는 경우에만 true를 반환할 수 있도록 멤버 연산 operator() 자를 정의합니다.
개체를 형식 delegate_type^ 이 적절한 함수 인수로 전달하여 적절하게 변환할 수도 있습니다.
예시
// 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)
템플릿 클래스는 호출 시 첫 번째 인수 또는 두 번째 테스트가 true인 경우에만 true를 반환하는 functor를 설명합니다. 함수 개체를 인수 형식으로 지정하는 데 사용합니다.
구문
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^();
};
매개 변수
Arg
인수의 형식입니다.
멤버 함수
| 형식 정의 | 설명 |
|---|---|
delegate_type |
제네릭 대리자의 형식입니다. |
first_argument_type |
첫 번째 펀터 인수의 형식입니다. |
result_type |
펀터 결과의 형식입니다. |
second_argument_type |
functor second 인수의 형식입니다. |
| 멤버 | 설명 |
|---|---|
logical_or |
functor를 생성합니다. |
| Operator | 설명 |
|---|---|
operator() |
원하는 함수를 계산합니다. |
operator delegate_type^ |
functor를 대리자로 캐스팅합니다. |
설명
템플릿 클래스는 두 인수 functor를 설명합니다. 개체가 함수로 호출되면 첫 번째 인수 또는 두 번째 테스트가 true인 경우에만 true를 반환할 수 있도록 멤버 연산 operator() 자를 정의합니다.
개체를 형식 delegate_type^ 이 적절한 함수 인수로 전달하여 적절하게 변환할 수도 있습니다.
예시
// 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)
템플릿 클래스는 호출 시 첫 번째 인수에서 두 번째 인수를 뺀 값을 반환하는 functor를 설명합니다. 함수 개체를 인수 형식으로 지정하는 데 사용합니다.
구문
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^();
};
매개 변수
Arg
인수 및 반환 값의 형식입니다.
멤버 함수
| 형식 정의 | 설명 |
|---|---|
delegate_type |
제네릭 대리자의 형식입니다. |
first_argument_type |
첫 번째 펀터 인수의 형식입니다. |
result_type |
펀터 결과의 형식입니다. |
second_argument_type |
functor second 인수의 형식입니다. |
| 멤버 | 설명 |
|---|---|
minus |
functor를 생성합니다. |
| Operator | 설명 |
|---|---|
operator() |
원하는 함수를 계산합니다. |
operator delegate_type^ |
functor를 대리자로 캐스팅합니다. |
설명
템플릿 클래스는 두 인수 functor를 설명합니다. 개체가 함수로 호출되면 첫 번째 인수에서 두 번째 인수를 뺀 값을 반환할 수 있도록 멤버 연산 operator() 자를 정의합니다.
개체를 형식 delegate_type^ 이 적절한 함수 인수로 전달하여 적절하게 변환할 수도 있습니다.
예시
// 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)
템플릿 클래스는 호출할 때 첫 번째 인수 모듈로를 두 번째 인수로 반환하는 functor를 설명합니다. 함수 개체를 인수 형식으로 지정하는 데 사용합니다.
구문
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^();
};
매개 변수
Arg
인수 및 반환 값의 형식입니다.
멤버 함수
| 형식 정의 | 설명 |
|---|---|
delegate_type |
제네릭 대리자의 형식입니다. |
first_argument_type |
첫 번째 펀터 인수의 형식입니다. |
result_type |
펀터 결과의 형식입니다. |
second_argument_type |
functor second 인수의 형식입니다. |
| 멤버 | 설명 |
|---|---|
modulus |
functor를 생성합니다. |
| Operator | 설명 |
|---|---|
operator() |
원하는 함수를 계산합니다. |
operator delegate_type^ |
functor를 대리자로 캐스팅합니다. |
설명
템플릿 클래스는 두 인수 functor를 설명합니다. 개체를 함수로 호출할 때 첫 번째 인수 모듈로 두 번째 인수를 반환할 수 있도록 멤버 연산 operator() 자를 정의합니다.
개체를 형식 delegate_type^ 이 적절한 함수 인수로 전달하여 적절하게 변환할 수도 있습니다.
예시
// 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)
템플릿 클래스는 호출할 때 첫 번째 인수를 두 번째 인수 횟수로 반환하는 펀터에 대해 설명합니다. 함수 개체를 인수 형식으로 지정하는 데 사용합니다.
구문
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^();
};
매개 변수
Arg
인수 및 반환 값의 형식입니다.
멤버 함수
| 형식 정의 | 설명 |
|---|---|
delegate_type |
제네릭 대리자의 형식입니다. |
first_argument_type |
첫 번째 펀터 인수의 형식입니다. |
result_type |
펀터 결과의 형식입니다. |
second_argument_type |
functor second 인수의 형식입니다. |
| 멤버 | 설명 |
|---|---|
multiplies |
functor를 생성합니다. |
| Operator | 설명 |
|---|---|
operator() |
원하는 함수를 계산합니다. |
operator delegate_type^ |
functor를 대리자로 캐스팅합니다. |
설명
템플릿 클래스는 두 인수 functor를 설명합니다. 개체를 함수로 호출할 때 첫 번째 인수를 두 번째 인수 횟수만큼 반환할 수 있도록 멤버 연산 operator() 자를 정의합니다.
개체를 형식 delegate_type^ 이 적절한 함수 인수로 전달하여 적절하게 변환할 수도 있습니다.
예시
// 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)
템플릿 클래스는 호출될 때 부정된 인수를 반환하는 functor를 설명합니다. 함수 개체를 인수 형식으로 지정하는 데 사용합니다.
구문
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^();
};
매개 변수
Arg
인수의 형식입니다.
멤버 함수
| 형식 정의 | 설명 |
|---|---|
argument_type |
functor 인수의 형식입니다. |
delegate_type |
제네릭 대리자의 형식입니다. |
result_type |
펀터 결과의 형식입니다. |
| 멤버 | 설명 |
|---|---|
negate |
functor를 생성합니다. |
| Operator | 설명 |
|---|---|
operator() |
원하는 함수를 계산합니다. |
operator delegate_type^ |
functor를 대리자로 캐스팅합니다. |
설명
템플릿 클래스는 한 인수 functor에 대해 설명합니다. 개체가 함수로 호출될 때 부정된 인수를 반환할 수 있도록 멤버 연산 operator() 자를 정의합니다.
개체를 형식 delegate_type^ 이 적절한 함수 인수로 전달하여 적절하게 변환할 수도 있습니다.
예시
// 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)
템플릿 클래스는 첫 번째 인수가 두 번째 인수와 같지 않은 경우에만 true를 반환하는 functor를 설명합니다. 함수 개체를 인수 형식으로 지정하는 데 사용합니다.
구문
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^();
};
매개 변수
Arg
인수의 형식입니다.
멤버 함수
| 형식 정의 | 설명 |
|---|---|
delegate_type |
제네릭 대리자의 형식입니다. |
first_argument_type |
첫 번째 펀터 인수의 형식입니다. |
result_type |
펀터 결과의 형식입니다. |
second_argument_type |
functor second 인수의 형식입니다. |
| 멤버 | 설명 |
|---|---|
not_equal_to |
functor를 생성합니다. |
| Operator | 설명 |
|---|---|
operator() |
원하는 함수를 계산합니다. |
operator delegate_type^ |
functor를 대리자로 캐스팅합니다. |
설명
템플릿 클래스는 두 인수 functor를 설명합니다. 개체가 함수로 호출되면 첫 번째 인수가 두 번째 인수와 같지 않은 경우에만 true를 반환하도록 멤버 연산 operator() 자를 정의합니다.
개체를 형식 delegate_type^ 이 적절한 함수 인수로 전달하여 적절하게 변환할 수도 있습니다.
예시
// 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)
functor용을 unary_negate 생성합니다.
구문
template<typename Fun>
unary_negate<Fun> not1(Fun% functor);
템플릿 매개 변수
Fun
functor의 형식입니다.
함수 매개 변수
functor
래핑할 펀터입니다.
설명
함수 템플릿은 .를 반환합니다 unary_negate<Fun>(functor). 논리적 NOT을 제공하는 펀터에서 하나의 인수 펀터를 래핑하는 편리한 방법으로 사용합니다.
예시
// 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)
functor용을 binary_negate 생성합니다.
구문
template<typename Fun>
binary_negate<Fun> not2(Fun% functor);
템플릿 매개 변수
Fun
functor의 형식입니다.
함수 매개 변수
functor
래핑할 펀터입니다.
설명
함수 템플릿은 .를 반환합니다 binary_negate<Fun>(functor). 논리적 NOT을 제공하는 펀터에 2 인수 펀터를 래핑하는 편리한 방법으로 사용합니다.
예시
// 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)
템플릿 클래스는 호출 시 첫 번째 인수와 두 번째 인수를 반환하는 functor를 설명합니다. 함수 개체를 인수 형식으로 지정하는 데 사용합니다.
구문
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^();
};
매개 변수
Arg
인수 및 반환 값의 형식입니다.
멤버 함수
| 형식 정의 | 설명 |
|---|---|
delegate_type |
제네릭 대리자의 형식입니다. |
first_argument_type |
첫 번째 펀터 인수의 형식입니다. |
result_type |
펀터 결과의 형식입니다. |
second_argument_type |
functor second 인수의 형식입니다. |
| 멤버 | 설명 |
|---|---|
plus |
functor를 생성합니다. |
| Operator | 설명 |
|---|---|
operator() |
원하는 함수를 계산합니다. |
operator delegate_type^ |
functor를 대리자로 캐스팅합니다. |
설명
템플릿 클래스는 두 인수 functor를 설명합니다. 개체가 함수로 호출되면 첫 번째 인수와 두 번째 인수를 반환할 수 있도록 멤버 연산 operator() 자를 정의합니다.
개체를 형식 delegate_type^ 이 적절한 함수 인수로 전달하여 적절하게 변환할 수도 있습니다.
예시
// 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)
제네릭 클래스는 한 인수 대리자를 설명합니다. 인수 및 반환 형식 측면에서 대리자를 지정하는 데 사용합니다.
구문
generic<typename Arg,
typename Result>
delegate Result unary_delegate(Arg);
매개 변수
Arg
인수 형식입니다.
Result
반환 형식입니다.
설명
제네릭 대리자는 한 인수 함수를 설명합니다.
다음 함수 템플릿에서 다음을 수행합니다.
unary_delegate<int, int> Fun1;
unary_delegate<int, int> Fun2;
형식 Fun1 과 Fun2 동의어는 다음과 같습니다.
delegate int Fun1(int);
delegate int Fun2(int);
형식이 다릅니다.
예시
// 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)
제네릭 클래스는 반환하는 1 인수 대리자를 설명합니다 void. 인수 형식의 측면에서 대리자를 지정하는 데 사용합니다.
구문
generic<typename Arg>
delegate void unary_delegate_noreturn(Arg);
매개 변수
Arg
인수 형식입니다.
설명
제네릭 대리자는 반환되는 한 인수 함수를 설명합니다 void.
다음 함수 템플릿에서 다음을 수행합니다.
unary_delegate_noreturn<int> Fun1;
unary_delegate_noreturn<int> Fun2;
형식 Fun1 과 Fun2 동의어는 다음과 같습니다.
delegate void Fun1(int);
delegate void Fun2(int);
형식이 다릅니다.
예시
// 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)
템플릿 클래스는 호출될 때 저장된 1 인수 펀터의 논리 NOT을 반환하는 functor를 설명합니다. 이 함수는 저장된 functor의 측면에서 함수 개체를 지정합니다.
구문
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^();
};
매개 변수
Fun
저장된 functor의 형식입니다.
멤버 함수
| 형식 정의 | 설명 |
|---|---|
argument_type |
functor 인수의 형식입니다. |
delegate_type |
제네릭 대리자의 형식입니다. |
result_type |
펀터 결과의 형식입니다. |
| 멤버 | 설명 |
|---|---|
unary_negate |
functor를 생성합니다. |
| Operator | 설명 |
|---|---|
operator() |
원하는 함수를 계산합니다. |
delegate_type^ |
functor를 대리자로 캐스팅합니다. |
설명
템플릿 클래스는 다른 한 인수 functor를 저장하는 한 인수 functor를 설명합니다. 개체가 함수로 호출될 때 인수를 사용하여 호출된 저장된 functor의 논리 NOT을 반환할 수 있도록 멤버 연산 operator() 자를 정의합니다.
개체를 형식 delegate_type^ 이 적절한 함수 인수로 전달하여 적절하게 변환할 수도 있습니다.
예제
// 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