<functional>
, funkcje
Te funkcje są przestarzałe w języku C++11 i usuwane w języku C++17:
bind1st
bind2nd
mem_fun
mem_fun_ref
ptr_fun
Te funkcje są przestarzałe w języku C++17:
bind
Wiąże argumenty z obiektem, który można wywołać.
template <class FT, class T1, class T2, ..., class TN>
unspecified bind(FT fn, T1 t1, T2 t2, ..., TN tN);
template <class RTy, class FT, class T1, class T2, ..., class TN>
unspecified bind(FT fn, T1 t1, T2 t2, ..., TN tN);
Parametry
FT
Typ obiektu do wywołania. Na przykład typ funkcji, obiekt funkcji, wskaźnik/odwołanie funkcji lub wskaźnik funkcji składowej.
RTy
Zwracany typ. Po określeniu będzie to zwracany typ powiązanego wywołania. W przeciwnym razie zwracany typ to zwracany typ FT
.
TN
Typ argumentu wywołania Nth.
fn
Obiekt do wywołania.
tN
Argument wywołania Nth.
Uwagi
Typy FT, T1, T2, ..., TN
muszą być konstruowalne i INVOKE(fn, t1, ..., tN)
muszą być prawidłowym wyrażeniem dla niektórych wartości w1, w2, ..., wN
.
Pierwsza funkcja szablonu zwraca otokę g
wywołań przekazujących ze słabym typem wyniku. Efekt g(u1, u2, ..., uM)
jest INVOKE(f, v1, v2, ..., vN,
invoke_result<FT cv (V1, V2, ..., VN)>::type)
, gdzie cv
jest kwalifikatory g
cv, a wartości i typy powiązanych argumentów v1, v2, ..., vN
są określane zgodnie z poniższym opisem. Służy do powiązania argumentów z obiektem wywołującym w celu utworzenia obiektu z możliwością wywołania z dostosowaną listą argumentów.
Druga funkcja szablonu zwraca otokę g
wywołań przekazujących z zagnieżdżonym typemresult_type
, który jest synonimem .RTy
Efekt g(u1, u2, ..., uM)
to , gdzie cv
to kwalifikatory g
cv, a wartości i typy powiązanych argumentów v1, v2, ..., vN
są określane zgodnie z INVOKE(f, v1, v2, ..., vN, RTy)
poniższym opisem. Służy do powiązania argumentów z obiektem wywołującym w celu utworzenia obiektu z możliwością wywołania z listą dostosowanych argumentów i określonym typem zwrotnym.
Wartości argumentów powiązanych v1, v2, ..., vN
i odpowiadających im typów V1, V2, ..., VN
zależą od typu odpowiadającego mu argumentu ti
typu Ti
w wywołaniu metody bind
i kwalifikatorów cv
cv otoki g
wywołań w następujący sposób:
Jeśli ti
jest typem reference_wrapper<T>
argumentu vi
, ti.get()
a jego typem Vi
jest T&
;
Jeśli wartość std::is_bind_expression<Ti>::value
jest argumentem vi
, ti(u1, u2, ..., uM)
a jego typem Vi
jest result_of<Ti
cv
(U1&, U2&, ..., UN&>::type
;true
Jeśli wartość j
std::is_placeholder<Ti>::value
nie jest równa zero, argument vi
to uj
, a jego typ Vi
to Uj&
;
W przeciwnym razie argument to , a jego typ Vi
to &
cv
Ti
.vi
ti
Na przykład, biorąc pod uwagę funkcję f(int, int)
bind(f, _1, 0)
wyrażenie zwraca otokę cw
wywołań przekazujących, która cw(x)
wywołuje f(x, 0)
metodę . Wyrażenie bind(f, 0, _1)
zwraca otokę cw
wywołań przekazujących, która cw(x)
wywołuje f(0, x)
metodę .
Liczba argumentów w wywołaniu metody bind
i argument fn
musi być równa liczbie argumentów, które można przekazać do obiektu fn
wywołującego . Na przykład bind(cos, 1.0)
jest poprawny, a oba bind(cos)
i bind(cos, _1, 0.0)
są niepoprawne.
Liczba argumentów w wywołaniu funkcji do otoki wywołań zwracanych przez bind
element musi być co najmniej tak duża, jak największa liczba is_placeholder<PH>::value
argumentów dla wszystkich argumentów symboli zastępczych w wywołaniu metody bind
. Na przykład bind(cos, _2)(0.0, 1.0)
wartość jest poprawna (i zwraca cos(1.0)
wartość ) i bind(cos, _2)(0.0)
jest niepoprawna.
Przykład
// std__functional__bind.cpp
// compile with: /EHsc
#include <functional>
#include <algorithm>
#include <iostream>
using namespace std::placeholders;
void square(double x)
{
std::cout << x << "^2 == " << x * x << std::endl;
}
void product(double x, double y)
{
std::cout << x << "*" << y << " == " << x * y << std::endl;
}
int main()
{
double arg[] = { 1, 2, 3 };
std::for_each(&arg[0], arg + 3, square);
std::cout << std::endl;
std::for_each(&arg[0], arg + 3, std::bind(product, _1, 2));
std::cout << std::endl;
std::for_each(&arg[0], arg + 3, std::bind(square, _1));
return (0);
}
1^2 == 1
2^2 == 4
3^2 == 9
1*2 == 2
2*2 == 4
3*2 == 6
1^2 == 1
2^2 == 4
3^2 == 9
bind1st
Funkcja szablonu pomocnika, która tworzy adapter do konwertowania obiektu funkcji binarnej na obiekt funkcji jednoargumentowej. Wiąże pierwszy argument funkcji binarnej z określoną wartością. Przestarzałe w języku C++11 usunięte w języku C++17.
template <class Operation, class Type>
binder1st <Operation> bind1st (const Operation& func, const Type& left);
Parametry
func
Obiekt funkcji binarnej, który ma zostać przekonwertowany na obiekt funkcji jednoargumentowej.
left
Wartość, do której należy powiązać pierwszy argument obiektu funkcji binarnej.
Wartość zwracana
Obiekt funkcji jednoargumentowej, który wynika z powiązania pierwszego argumentu obiektu funkcji binarnej z wartością left
.
Uwagi
Powiązania funkcji są rodzajem adaptera funkcji. Ponieważ zwracają obiekty funkcji, mogą być używane w niektórych typach kompozycji funkcji do konstruowania bardziej skomplikowanych i zaawansowanych wyrażeń.
Jeśli func
jest obiektem typu Operation
i c
jest stałą, bind1st( func, c )
jest to samo co binder1st
konstruktor binder1st<Operation>(func, c)
klasy , i jest bardziej wygodne do użycia.
Przykład
// functional_bind1st.cpp
// compile with: /EHsc
#include <vector>
#include <functional>
#include <algorithm>
#include <iostream>
using namespace std;
// Creation of a user-defined function object
// that inherits from the unary_function base class
class greaterthan5: unary_function<int, bool>
{
public:
result_type operator()(argument_type i)
{
return (result_type)(i > 5);
}
};
int main()
{
vector<int> v1;
vector<int>::iterator Iter;
int i;
for (i = 0; i <= 5; i++)
{
v1.push_back(5 * i);
}
cout << "The vector v1 = ( " ;
for (Iter = v1.begin(); Iter != v1.end(); Iter++)
cout << *Iter << " ";
cout << ")" << endl;
// Count the number of integers > 10 in the vector
vector<int>::iterator::difference_type result1a;
result1a = count_if(v1.begin(), v1.end(), bind1st(less<int>(), 10));
cout << "The number of elements in v1 greater than 10 is: "
<< result1a << "." << endl;
// Compare: counting the number of integers > 5 in the vector
// with a user defined function object
vector<int>::iterator::difference_type result1b;
result1b = count_if(v1.begin(), v1.end(), greaterthan5());
cout << "The number of elements in v1 greater than 5 is: "
<< result1b << "." << endl;
// Count the number of integers < 10 in the vector
vector<int>::iterator::difference_type result2;
result2 = count_if(v1.begin(), v1.end(), bind2nd(less<int>(), 10));
cout << "The number of elements in v1 less than 10 is: "
<< result2 << "." << endl;
}
The vector v1 = ( 0 5 10 15 20 25 )
The number of elements in v1 greater than 10 is: 3.
The number of elements in v1 greater than 5 is: 4.
The number of elements in v1 less than 10 is: 2.
bind2nd
Funkcja szablonu pomocnika, która tworzy adapter do konwertowania obiektu funkcji binarnej na obiekt funkcji jednoargumentowej. Wiąże drugi argument funkcji binarnej z określoną wartością. Przestarzałe w języku C++11 usunięte w języku C++17.
template <class Operation, class Type>
binder2nd <Operation> bind2nd(const Operation& func, const Type& right);
Parametry
func
Obiekt funkcji binarnej, który ma zostać przekonwertowany na obiekt funkcji jednoargumentowej.
right
Wartość, do której ma być powiązany drugi argument obiektu funkcji binarnej.
Wartość zwracana
Wynik obiektu funkcji jednoargumentowej powiązania drugiego argumentu obiektu funkcji binarnej z .right
Uwagi
Powiązania funkcji są rodzajem adaptera funkcji. Ponieważ zwracają obiekty funkcji, mogą być używane w niektórych typach kompozycji funkcji do konstruowania bardziej skomplikowanych i zaawansowanych wyrażeń.
Jeśli func
jest obiektem typu Operation
i c
jest stałą, bind2nd(func, c)
jest to samo co binder2nd
konstruktor binder2nd<Operation>(func, c)
klasy , i wygodniejsze do użycia.
Przykład
// functional_bind2nd.cpp
// compile with: /EHsc
#include <vector>
#include <functional>
#include <algorithm>
#include <iostream>
using namespace std;
// Creation of a user-defined function object
// that inherits from the unary_function base class
class greaterthan15: unary_function<int, bool>
{
public:
result_type operator()(argument_type i)
{
return (result_type)(i > 15);
}
};
int main()
{
vector<int> v1;
vector<int>::iterator Iter;
int i;
for (i = 0; i <= 5; i++)
{
v1.push_back(5 * i);
}
cout << "The vector v1 = ( ";
for (Iter = v1.begin(); Iter != v1.end(); Iter++)
cout << *Iter << " ";
cout << ")" << endl;
// Count the number of integers > 10 in the vector
vector<int>::iterator::difference_type result1a;
result1a = count_if(v1.begin(), v1.end(), bind2nd(greater<int>(), 10));
cout << "The number of elements in v1 greater than 10 is: "
<< result1a << "." << endl;
// Compare counting the number of integers > 15 in the vector
// with a user-defined function object
vector<int>::iterator::difference_type result1b;
result1b = count_if(v1.begin(), v1.end(), greaterthan15());
cout << "The number of elements in v1 greater than 15 is: "
<< result1b << "." << endl;
// Count the number of integers < 10 in the vector
vector<int>::iterator::difference_type result2;
result2 = count_if(v1.begin(), v1.end(), bind1st(greater<int>(), 10));
cout << "The number of elements in v1 less than 10 is: "
<< result2 << "." << endl;
}
The vector v1 = ( 0 5 10 15 20 25 )
The number of elements in v1 greater than 10 is: 3.
The number of elements in v1 greater than 15 is: 2.
The number of elements in v1 less than 10 is: 2.
bit_and
Wstępnie zdefiniowany obiekt funkcji, który wykonuje bitową operację AND (binarną operator&
) na argumentach.
template <class Type = void>
struct bit_and : public binary_function<Type, Type, Type
{
Type operator()(
const Type& Left,
const Type& Right) const;
};
// specialized transparent functor for operator&
template <>
struct bit_and<void>
{
template <class T, class U>
auto operator()(T&& Left, U&& Right) const ->
decltype(std::forward<T>(Left) & std::forward<U>(Right));
};
Parametry
Type
, , T
U
Dowolny typ obsługujący argument , który operator&
przyjmuje operandy określonych lub wywnioskowanych typów.
Left
Lewy operand operacji BITOWEJ AND. Niespecjalizowany szablon przyjmuje argument odwołania lvalue typu Type
. Wyspecjalizowany szablon wykonuje doskonałe przekazywanie argumentów referencyjnych lvalue i rvalue wywnioskowanego typu T
.
Right
Prawy operand operacji BITOWEJ AND. Niespecjalizowany szablon przyjmuje argument odwołania lvalue typu Type
. Wyspecjalizowany szablon wykonuje doskonałe przekazywanie argumentów referencyjnych lvalue i rvalue wywnioskowanego typu U
.
Wartość zwracana
Wynik .Left & Right
Wyspecjalizowany szablon wykonuje doskonałe przekazywanie wyniku, który ma typ zwracany przez operator&
element .
Uwagi
Functor bit_and
jest ograniczony do typów całkowitych dla podstawowych typów danych lub typów zdefiniowanych przez użytkownika, które implementują binarne operator&
.
bit_not
Wstępnie zdefiniowany obiekt funkcji, który wykonuje operację bitowego uzupełniania (NOT) (jednoargumentową operator~
) na jego argumencie. Dodano w języku C++14.
template <class Type = void>
struct bit_not : public unary_function<Type, Type>
{
Type operator()(const Type& Right) const;
};
// specialized transparent functor for operator~
template <>
struct bit_not<void>
{
template <class Type>
auto operator()(Type&& Right) const -> decltype(~std::forward<Type>(Right));
};
Parametry
Type
Typ obsługujący jednoargumentowy operator~
.
Right
Operand operacji uzupełniania bitowego. Niespecjalizowany szablon przyjmuje argument odwołania lvalue typu Type
. Wyspecjalizowany szablon wykonuje doskonałe przekazywanie argumentu odwołania lvalue lub rvalue wywnioskowanego typu Type
.
Wartość zwracana
Wynik .~ Right
Wyspecjalizowany szablon wykonuje doskonałe przekazywanie wyniku, który ma typ zwracany przez operator~
element .
Uwagi
Functor bit_not
jest ograniczony do typów całkowitych dla podstawowych typów danych lub typów zdefiniowanych przez użytkownika, które implementują binarne operator~
.
bit_or
Wstępnie zdefiniowany obiekt funkcji, który wykonuje bitową operację OR (operator|
) na argumentach.
template <class Type = void>
struct bit_or : public binary_function<Type, Type, Type>
{
Type operator()(
const Type& Left,
const Type& Right) const;
};
// specialized transparent functor for operator|
template <>
struct bit_or<void>
{
template <class T, class U>
auto operator()(T&& Left, U&& Right) const
-> decltype(std::forward<T>(Left) | std::forward<U>(Right));
};
Parametry
Type
, , T
U
Dowolny typ obsługujący argument , który operator|
przyjmuje operandy określonych lub wywnioskowanych typów.
Left
Lewy operand operacji bitowej OR. Niespecjalizowany szablon przyjmuje argument odwołania lvalue typu Type
. Wyspecjalizowany szablon wykonuje doskonałe przekazywanie argumentów referencyjnych lvalue i rvalue wywnioskowanego typu T
.
Right
Prawy operand operacji bitowej OR. Niespecjalizowany szablon przyjmuje argument odwołania lvalue typu Type
. Wyspecjalizowany szablon wykonuje doskonałe przekazywanie argumentów referencyjnych lvalue i rvalue wywnioskowanego typu U
.
Wartość zwracana
Wynik .Left | Right
Wyspecjalizowany szablon wykonuje doskonałe przekazywanie wyniku, który ma typ zwracany przez operator|
element .
Uwagi
Functor bit_or
jest ograniczony do typów całkowitych dla podstawowych typów danych lub typów zdefiniowanych przez użytkownika, które implementują operator|
.
bit_xor
Wstępnie zdefiniowany obiekt funkcji, który wykonuje bitową operację XOR (binarną operator^
) na argumentach.
template <class Type = void>
struct bit_xor : public binary_function<Type, Type, Type>
{
Type operator()(
const Type& Left,
const Type& Right) const;
};
// specialized transparent functor for operator^
template <>
struct bit_xor<void>
{
template <class T, class U>
auto operator()(T&& Left, U&& Right) const
-> decltype(std::forward<T>(Left) ^ std::forward<U>(Right));
};
Parametry
Type
, , T
U
Dowolny typ obsługujący argument , który operator^
przyjmuje operandy określonych lub wywnioskowanych typów.
Left
Lewy operand operacji XOR bitowej. Niespecjalizowany szablon przyjmuje argument odwołania lvalue typu Type
. Wyspecjalizowany szablon wykonuje doskonałe przekazywanie argumentów referencyjnych lvalue i rvalue wywnioskowanego typu T
.
Right
Prawy operand operacji XOR bitowej. Niespecjalizowany szablon przyjmuje argument odwołania lvalue typu Type
. Wyspecjalizowany szablon wykonuje doskonałe przekazywanie argumentów referencyjnych lvalue i rvalue wywnioskowanego typu U
.
Wartość zwracana
Wynik .Left ^ Right
Wyspecjalizowany szablon wykonuje doskonałe przekazywanie wyniku, który ma typ zwracany przez operator^
element .
Uwagi
Functor bit_xor
jest ograniczony do typów całkowitych dla podstawowych typów danych lub typów zdefiniowanych przez użytkownika, które implementują binarne operator^
.
cref
Tworzy const reference_wrapper
z argumentu.
template <class Ty>
reference_wrapper<const Ty> cref(const Ty& arg);
template <class Ty>
reference_wrapper<const Ty> cref(const reference_wrapper<Ty>& arg);
Parametry
Ty
Typ argumentu do opakowania.
arg
Argument do zawijania.
Uwagi
Pierwsza funkcja zwraca wartość reference_wrapper<const Ty>(arg.get())
. Służy do zawijania odwołania const. Druga funkcja zwraca wartość reference_wrapper<const Ty>(arg)
. Służy do ponownego opakowania opakowanego odwołania jako odwołania const.
Przykład
// std__functional__cref.cpp
// compile with: /EHsc
#include <functional>
#include <iostream>
int neg(int val)
{
return (-val);
}
int main()
{
int i = 1;
std::cout << "i = " << i << std::endl;
std::cout << "cref(i) = " << std::cref(i) << std::endl;
std::cout << "cref(neg)(i) = "
<< std::cref(&neg)(i) << std::endl;
return (0);
}
i = 1
cref(i) = 1
cref(neg)(i) = -1
wywołać
Wywołuje dowolny obiekt wywołujący z podanymi argumentami. Dodano w języku C++17.
template <class Callable, class... Args>
invoke_result_t<Callable, Args...>
invoke(Callable&& fn, Args&&... args) noexcept(/* specification */);
Parametry
Callable
Typ obiektu do wywołania.
Args
Typy argumentów wywołania.
fn
Obiekt do wywołania.
args
Argumenty wywołania.
specification
Specyfikacja noexcept
std::is_nothrow_invocable_v<Callable, Args>)
.
Uwagi
Wywołuje obiekt fn
wywołujący przy użyciu parametrów args
. W rzeczywistości , INVOKE(std::forward<Callable>(fn), std::forward<Args>(args)...)
gdzie pseudo-funkcja INVOKE(f, t1, t2, ..., tN)
oznacza jedną z następujących rzeczy:
(t1.*f)(t2, ..., tN)
gdyf
jest wskaźnikiem do funkcji składowej klasyT
it1
jest obiektem typu lub odwołaniem do obiektu typuT
T
lub odwołania do obiektu typu lub odwołania do obiektu typu pochodzącego zT
klasy . To znaczy, kiedystd::is_base_of<T, std::decay_t<decltype(t1)>>::value
jest prawdziwe.(t1.get().*f)(t2, ..., tN)
gdyf
jest wskaźnikiem do funkcji składowej klasyT
istd::decay_t<decltype(t1)>
jest specjalizacjąstd::reference_wrapper
.((*t1).*f)(t2, ..., tN)
gdyf
jest wskaźnikiem do funkcji składowej klasyT
it1
nie jest jednym z poprzednich typów.t1.*f
gdy N == 1 if
jest wskaźnikiem do danych składowych klasyT
it1
jest obiektem typu lub odwołaniem do obiektu typuT
T
lub odwołania do obiektu typu lub odwołania do obiektu typu pochodzącego zT
klasy . To znaczy, kiedystd::is_base_of<T, std::decay_t<decltype(t1)>>::value
jest prawdziwe.t1.get().*f
gdy N == 1 if
jest wskaźnikiem do danych składowych klasyT
istd::decay_t<decltype(t1)>
jest specjalizacjąstd::reference_wrapper
.(*t1).*f
gdy N == 1 if
jest wskaźnikiem do danych składowych klasyT
it1
nie jest jednym z poprzednich typów.f(t1, t2, ..., tN)
we wszystkich innych przypadkach.
Aby uzyskać informacje na temat typu wyniku obiektu z możliwością wywołania, zobacz invoke_result. Aby uzyskać predykaty dla typów możliwych do wywołania, zobacz is_invocable, is_invocable_r, is_nothrow_invocable, is_nothrow_invocable_r klasy.
Przykład
// functional_invoke.cpp
// compile using: cl /EHsc /std:c++17 functional_invoke.cpp
#include <functional>
#include <iostream>
struct Demo
{
int n_;
Demo(int const n) : n_{n} {}
void operator()( int const i, int const j ) const
{
std::cout << "Demo operator( " << i << ", "
<< j << " ) is " << i * j << "\n";
}
void difference( int const i ) const
{
std::cout << "Demo.difference( " << i << " ) is "
<< n_ - i << "\n";
}
};
void divisible_by_3(int const i)
{
std::cout << i << ( i % 3 == 0 ? " is" : " isn't" )
<< " divisible by 3.\n";
}
int main()
{
Demo d{ 42 };
Demo * pd{ &d };
auto pmf = &Demo::difference;
auto pmd = &Demo::n_;
// Invoke a function object, like calling d( 3, -7 )
std::invoke( d, 3, -7 );
// Invoke a member function, like calling
// d.difference( 29 ) or (d.*pmf)( 29 )
std::invoke( &Demo::difference, d, 29 );
std::invoke( pmf, pd, 13 );
// Invoke a data member, like access to d.n_ or d.*pmd
std::cout << "d.n_: " << std::invoke( &Demo::n_, d ) << "\n";
std::cout << "pd->n_: " << std::invoke( pmd, pd ) << "\n";
// Invoke a stand-alone (free) function
std::invoke( divisible_by_3, 42 );
// Invoke a lambda
auto divisible_by_7 = []( int const i )
{
std::cout << i << ( i % 7 == 0 ? " is" : " isn't" )
<< " divisible by 7.\n";
};
std::invoke( divisible_by_7, 42 );
}
Demo operator( 3, -7 ) is -21
Demo.difference( 29 ) is 13
Demo.difference( 13 ) is 29
d.n_: 42
pd->n_: 42
42 is divisible by 3.
42 is divisible by 7.
mem_fn
Generuje prostą otokę wywołań.
template <class RTy, class Ty>
unspecified mem_fn(RTy Ty::*pm);
Parametry
RTy
Zwracany typ opakowanej funkcji.
Ty
Typ wskaźnika funkcji składowej.
Uwagi
Funkcja szablonu zwraca prostą otokę cw
wywołań z słabym typem wyniku, tak aby wyrażenie cw(t, a2, ..., aN)
było takie samo jak INVOKE(pm, t, a2, ..., aN)
. Nie zgłasza żadnych wyjątków.
Zwrócona otoka wywołań jest pochodna std::unary_function<cv Ty*, RTy>
(i definiuje typ result_type
zagnieżdżony jako synonim RTy
i typ zagnieżdżony jako synonim dla cv Ty*
), tylko wtedy, gdy typ argument_type
Ty
jest wskaźnikiem do funkcji składowej z kwalifikatorem cv
cv, który nie przyjmuje żadnych argumentów.
Zwrócona otoka wywołań pochodzi z std::binary_function<cv Ty*, T2, RTy>
(i definiuje typ result_type
zagnieżdżony jako synonim dla RTy
, typ first argument_type
zagnieżdżony jako synonim dla cv Ty*
, i typ second argument_type
zagnieżdżony jako synonim dla T2
) tylko wtedy, gdy typ Ty
jest wskaźnikiem do funkcji składowej z kwalifikatorem cv
cv, który przyjmuje jeden argument typu T2
.
Przykład
// std__functional__mem_fn.cpp
// compile with: /EHsc
#include <functional>
#include <iostream>
class Funs
{
public:
void square(double x)
{
std::cout << x << "^2 == " << x * x << std::endl;
}
void product(double x, double y)
{
std::cout << x << "*" << y << " == " << x * y << std::endl;
}
};
int main()
{
Funs funs;
std::mem_fn(&Funs::square)(funs, 3.0);
std::mem_fn(&Funs::product)(funs, 3.0, 2.0);
return (0);
}
3^2 == 9
3*2 == 6
mem_fun
Funkcje szablonu pomocnika używane do konstruowania adapterów obiektów funkcji dla funkcji składowych podczas inicjowania z argumentami wskaźnika. Przestarzałe w języku C++11 for mem_fn
i bind
i usunięte w języku C++17.
template <class Result, class Type>
mem_fun_t<Result, Type> mem_fun (Result(Type::* pMem)());
template <class Result, class Type, class Arg>
mem_fun1_t<Result, Type, Arg> mem_fun(Result (Type::* pMem)(Arg));
template <class Result, class Type>
const_mem_fun_t<Result, Type> mem_fun(Result (Type::* pMem)() const);
template <class Result, class Type, class Arg>
const_mem_fun1_t<Result, Type, Arg> mem_fun(Result (Type::* pMem)(Arg) const);
Parametry
pMem
Wskaźnik do funkcji składowej klasy Type
, która ma zostać przekonwertowana na obiekt funkcji.
Wartość zwracana
Obiekt const
funkcji innej niż const typu mem_fun_t
lub mem_fun1_t
.
Przykład
// functional_mem_fun.cpp
// compile with: /EHsc
#include <vector>
#include <functional>
#include <algorithm>
#include <iostream>
using namespace std;
class StoreVals
{
int val;
public:
StoreVals() { val = 0; }
StoreVals(int j) { val = j; }
bool display() { cout << val << " "; return true; }
int squareval() { val *= val; return val; }
int lessconst(int k) {val -= k; return val; }
};
int main( )
{
vector<StoreVals *> v1;
StoreVals sv1(5);
v1.push_back(&sv1);
StoreVals sv2(10);
v1.push_back(&sv2);
StoreVals sv3(15);
v1.push_back(&sv3);
StoreVals sv4(20);
v1.push_back(&sv4);
StoreVals sv5(25);
v1.push_back(&sv5);
cout << "The original values stored are: " ;
for_each(v1.begin(), v1.end(), mem_fun<bool, StoreVals>(&StoreVals::display));
cout << endl;
// Use of mem_fun calling member function through a pointer
// square each value in the vector using squareval ()
for_each(v1.begin(), v1.end(), mem_fun<int, StoreVals>(&StoreVals::squareval));
cout << "The squared values are: " ;
for_each(v1.begin(), v1.end(), mem_fun<bool, StoreVals>(&StoreVals::display));
cout << endl;
// Use of mem_fun1 calling member function through a pointer
// subtract 5 from each value in the vector using lessconst ()
for_each(v1.begin(), v1.end(),
bind2nd (mem_fun1<int, StoreVals,int>(&StoreVals::lessconst), 5));
cout << "The squared values less 5 are: " ;
for_each(v1.begin(), v1.end(), mem_fun<bool, StoreVals>(&StoreVals::display));
cout << endl;
}
mem_fun_ref
Funkcje szablonu pomocnika używane do konstruowania adapterów obiektów funkcji dla funkcji składowych podczas inicjowania przy użyciu argumentów odwołania. Przestarzałe w języku C++11 usunięte w języku C++17.
template <class Result, class Type>
mem_fun_ref_t<Result, Type> mem_fun_ref(Result (Type::* pMem)());
template <class Result, class Type, class Arg>
mem_fun1_ref_t<Result, Type, Arg> mem_fun_ref(Result (Type::* pMem)(Arg));
template <class Result, class Type>
const_mem_fun_ref_t<Result, Type> mem_fun_ref(Result Type::* pMem)() const);
template <class Result, class Type, class Arg>
const_mem_fun1_ref_t<Result, Type, Arg> mem_fun_ref(Result (T::* pMem)(Arg) const);
Parametry
pMem
Wskaźnik do funkcji składowej klasy Type
, która ma zostać przekonwertowana na obiekt funkcji.
Wartość zwracana
Obiekt const
lub non_const
funkcji typu mem_fun_ref_t
lub mem_fun1_ref_t
.
Przykład
// functional_mem_fun_ref.cpp
// compile with: /EHsc
#include <vector>
#include <functional>
#include <algorithm>
#include <iostream>
using namespace std;
class NumVals
{
int val;
public:
NumVals ( ) { val = 0; }
NumVals ( int j ) { val = j; }
bool display ( ) { cout << val << " "; return true; }
bool isEven ( ) { return ( bool ) !( val %2 ); }
bool isPrime( )
{
if (val < 2) { return true; }
for (int i = 2; i <= val / i; ++i)
{
if (val % i == 0) { return false; }
}
return true;
}
};
int main( )
{
vector <NumVals> v1 ( 13 ), v2 ( 13 );
vector <NumVals>::iterator v1_Iter, v2_Iter;
int i, k;
for ( i = 0; i < 13; i++ ) v1 [ i ] = NumVals ( i+1 );
for ( k = 0; k < 13; k++ ) v2 [ k ] = NumVals ( k+1 );
cout << "The original values stored in v1 are: " ;
for_each( v1.begin( ), v1.end( ),
mem_fun_ref ( &NumVals::display ) );
cout << endl;
// Use of mem_fun_ref calling member function through a reference
// remove the primes in the vector using isPrime ( )
v1_Iter = remove_if ( v1.begin( ), v1.end( ),
mem_fun_ref ( &NumVals::isPrime ) );
cout << "With the primes removed, the remaining values in v1 are: " ;
for_each( v1.begin( ), v1_Iter,
mem_fun_ref ( &NumVals::display ) );
cout << endl;
cout << "The original values stored in v2 are: " ;
for_each( v2.begin( ), v2.end( ),
mem_fun_ref ( &NumVals::display ) );
cout << endl;
// Use of mem_fun_ref calling member function through a reference
// remove the even numbers in the vector v2 using isEven ( )
v2_Iter = remove_if ( v2.begin( ), v2.end( ),
mem_fun_ref ( &NumVals::isEven ) );
cout << "With the even numbers removed, the remaining values are: " ;
for_each( v2.begin( ), v2_Iter,
mem_fun_ref ( &NumVals::display ) );
cout << endl;
}
The original values stored in v1 are: 1 2 3 4 5 6 7 8 9 10 11 12 13
With the primes removed, the remaining values in v1 are: 4 6 8 9 10 12
The original values stored in v2 are: 1 2 3 4 5 6 7 8 9 10 11 12 13
With the even numbers removed, the remaining values are: 1 3 5 7 9 11 13
not1
Zwraca uzupełnienie predykatu jednoargumentowego. Przestarzałe w not_fn
języku C++17.
template <class UnaryPredicate>
unary_negate<UnaryPredicate> not1(const UnaryPredicate& predicate);
Parametry
predicate
Predykat jednoargumentowy do negacji.
Wartość zwracana
Predykat jednoargumentowy, który jest negacją zmodyfikowanego predykatu jednoargumentowego.
Uwagi
Jeśli obiekt unary_negate
jest skonstruowany z predykatu predicate(x)
jednoargumentowego , zwraca wartość !predicate(x)
.
Przykład
// functional_not1.cpp
// compile with: /EHsc
#include <vector>
#include <functional>
#include <algorithm>
#include <iostream>
using namespace std;
int main()
{
vector<int> v1;
vector<int>::iterator Iter;
int i;
for (i = 0; i <= 7; i++)
{
v1.push_back(5 * i);
}
cout << "The vector v1 = ( ";
for (Iter = v1.begin(); Iter != v1.end(); Iter++)
cout << *Iter << " ";
cout << ")" << endl;
vector<int>::iterator::difference_type result1;
// Count the elements greater than 10
result1 = count_if(v1.begin(), v1.end(), bind2nd(greater<int>(), 10));
cout << "The number of elements in v1 greater than 10 is: "
<< result1 << "." << endl;
vector<int>::iterator::difference_type result2;
// Use the negator to count the elements less than or equal to 10
result2 = count_if(v1.begin(), v1.end(),
not1(bind2nd(greater<int>(), 10)));
cout << "The number of elements in v1 not greater than 10 is: "
<< result2 << "." << endl;
}
The vector v1 = ( 0 5 10 15 20 25 30 35 )
The number of elements in v1 greater than 10 is: 5.
The number of elements in v1 not greater than 10 is: 3.
not2
Zwraca uzupełnienie predykatu binarnego. Przestarzałe w not_fn
języku C++17.
template <class BinaryPredicate>
binary_negate<BinaryPredicate> not2(const BinaryPredicate& func);
Parametry
func
Predykat binarny do zanegowania.
Wartość zwracana
Predykat binarny, który jest negacją zmodyfikowanego predykatu binarnego.
Uwagi
Jeśli element binary_negate
jest skonstruowany z predykatu binary_predicate(x, y)
binarnego , zwraca wartość !binary_predicate(x, y)
.
Przykład
// functional_not2.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional>
#include <cstdlib>
#include <iostream>
int main( )
{
using namespace std;
vector <int> v1;
vector <int>::iterator Iter1;
int i;
v1.push_back( 6262 );
v1.push_back( 6262 );
for ( i = 0 ; i < 5 ; i++ )
{
v1.push_back( rand( ) );
}
cout << "Original vector v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")" << endl;
// To sort in ascending order,
// use default binary predicate less<int>( )
sort( v1.begin( ), v1.end( ) );
cout << "Sorted vector v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")" << endl;
// To sort in descending order,
// use the binary_negate helper function not2
sort( v1.begin( ), v1.end( ), not2(less<int>( ) ) );
cout << "Resorted vector v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")" << endl;
}
Original vector v1 = ( 6262 6262 41 18467 6334 26500 19169 )
Sorted vector v1 = ( 41 6262 6262 6334 18467 19169 26500 )
Resorted vector v1 = ( 26500 19169 18467 6334 6262 6262 41 )
not_fn
Szablon not_fn
funkcji przyjmuje obiekt z możliwością wywołania i zwraca obiekt, który można wywołać. Gdy zwrócony obiekt wywoływany jest później wywoływany z niektórymi argumentami, przekazuje je do oryginalnego obiektu z możliwością wywołania i logicznie neguje wynik. Zachowuje zachowanie kategorii const i kategorii wartości opakowanego obiektu wywoływanego. not_fn
jest nowy w języku C++17 i zastępuje przestarzałe std::not1
, std::not2
, std::unary_negate
i std::binary_negate
.
template <class Callable>
/* unspecified */ not_fn(Callable&& func);
Parametry
func
Obiekt wywołujący używany do konstruowania otoki wywołań przekazujących.
Uwagi
Funkcja szablonu zwraca otokę wywołań, taką jak return call_wrapper(std::forward<Callable>(func))
, na podstawie tej klasy tylko ekspozycji:
class call_wrapper
{
using FD = decay_t<Callable>;
explicit call_wrapper(Callable&& func);
public:
call_wrapper(call_wrapper&&) = default;
call_wrapper(call_wrapper const&) = default;
template<class... Args>
auto operator()(Args&&...) & -> decltype(!declval<invoke_result_t<FD&(Args...)>>());
template<class... Args>
auto operator()(Args&&...) const& -> decltype(!declval<invoke_result_t<FD const&(Args...)>>());
template<class... Args>
auto operator()(Args&&...) && -> decltype(!declval<invoke_result_t<FD(Args...)>>());
template<class... Args>
auto operator()(Args&&...) const&& -> decltype(!declval<invoke_result_t<FD const(Args...)>>());
private:
FD fd;
};
Jawny konstruktor obiektu wywołującego func
wymaga typu std::decay_t<Callable>
, aby spełnić wymagania , MoveConstructible
i is_constructible_v<FD, Callable>
musi mieć wartość true. Inicjuje opakowany obiekt fd
wywołujący z std::forward<Callable>(func)
obiektu i zgłasza wszelkie wyjątki zgłaszane przez konstrukcję fd
obiektu .
Otoka uwidacznia operatory wywołań rozróżniane przez kategorię referencyjną lvalue lub rvalue oraz kwalifikację const, jak pokazano poniżej:
template<class... Args> auto operator()(Args&&... args) & -> decltype(!declval<invoke_result_t<FD&(Args...)>>());
template<class... Args> auto operator()(Args&&... args) const& -> decltype(!declval<invoke_result_t<FD const&(Args...)>>());
template<class... Args> auto operator()(Args&&... args) && -> decltype(!declval<invoke_result_t<FD(Args...)>>());
template<class... Args> auto operator()(Args&&... args) const&& -> decltype(!declval<invoke_result_t<FD const(Args...)>>());
Pierwsze dwa są takie same jak return !std::invoke(fd, std::forward<Args>(args)...)
. Drugie dwa są takie same jak return !std::invoke(std::move(fd), std::forward<Args>(args)...)
.
Przykład
// functional_not_fn_.cpp
// compile with: /EHsc /std:c++17
#include <vector>
#include <algorithm>
#include <functional>
#include <iostream>
int main()
{
std::vector<int> v1 = { 99, 6264, 41, 18467, 6334, 26500, 19169 };
auto divisible_by_3 = [](int i){ return i % 3 == 0; };
std::cout << "Vector v1 = ( " ;
for (const auto& item : v1)
{
std::cout << item << " ";
}
std::cout << ")" << std::endl;
// Count the number of vector elements divisible by 3.
int divisible =
std::count_if(v1.begin(), v1.end(), divisible_by_3);
std::cout << "Elements divisible by three: "
<< divisible << std::endl;
// Count the number of vector elements not divisible by 3.
int not_divisible =
std::count_if(v1.begin(), v1.end(), std::not_fn(divisible_by_3));
std::cout << "Elements not divisible by three: "
<< not_divisible << std::endl;
}
Vector v1 = ( 99 6264 41 18467 6334 26500 19169 )
Elements divisible by three: 2
Elements not divisible by three: 5
ptr_fun
Funkcje szablonu pomocnika używane do konwertowania wskaźników funkcji jednoargumentowej i binarnej odpowiednio na funkcje jednoargumentowe i binarne. Przestarzałe w języku C++11 usunięte w języku C++17.
template <class Arg, class Result>
pointer_to_unary_function<Arg, Result, Result (*)(Arg)> ptr_fun(Result (*pfunc)(Arg));
template <class Arg1, class Arg2, class Result>
pointer_to_binary_function<Arg1, Arg2, Result, Result (*)(Arg1, Arg2)> ptr_fun(Result (*pfunc)(Arg1, Arg2));
Parametry
pfunc
Wskaźnik funkcji jednoargumentowej lub binarnej, który ma zostać przekonwertowany na funkcję z możliwością dostosowania.
Wartość zwracana
Pierwsza funkcja szablonu zwraca funkcję jednoargumentową pointer_to_unary_functionResult
><Arg
(* ). pfunc
Druga funkcja szablonu zwraca funkcję binarną pointer_to_binary_function<Arg1
, Arg2
, Result
>(* ). pfunc
Uwagi
Wskaźnik funkcji jest obiektem funkcji. Może zostać przekazany do dowolnego algorytmu, który oczekuje funkcji jako parametru, ale nie można go dostosować. Informacje o typach zagnieżdżonych są wymagane do użycia z adapterem, na przykład w celu powiązania wartości z nią lub negacji. Konwersja wskaźników funkcji jednoargumentowej i binarnej ptr_fun
przez funkcję pomocnika pozwala adapterom funkcji na pracę z jednoargumentowymi i binarnymi wskaźnikami funkcji.
Przykład
// functional_ptr_fun.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional>
#include <cstring>
#include <iostream>
int main( )
{
using namespace std;
vector <char*> v1;
vector <char*>::iterator Iter1, RIter;
v1.push_back ( "Open" );
v1.push_back ( "up" );
v1.push_back ( "the" );
v1.push_back ( "opalescent" );
v1.push_back ( "gates" );
cout << "Original sequence contains: " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; ++Iter1 )
cout << *Iter1 << " ";
cout << endl;
// To search the sequence for "opalescent"
// use a pointer_to_function conversion
RIter = find_if( v1.begin( ), v1.end( ),
not1 ( bind2nd (ptr_fun ( strcmp ), "opalescent" ) ) );
if ( RIter != v1.end( ) )
{
cout << "Found a match: "
<< *RIter << endl;
}
}
ref
Tworzy element reference_wrapper
z argumentu.
template <class Ty>
reference_wrapper<Ty> ref(Ty& arg);
template <class Ty>
reference_wrapper<Ty> ref(reference_wrapper<Ty>& arg);
Wartość zwracana
Odwołanie do arg
; w szczególności reference_wrapper<Ty>(arg)
.
Przykład
Poniższy przykład definiuje dwie funkcje: jedną powiązaną ze zmienną ciągu, drugą powiązaną z odwołaniem do zmiennej ciągu obliczoną przez wywołanie metody ref
. Gdy wartość zmiennej zmieni się, pierwsza funkcja nadal używa starej wartości, a druga funkcja używa nowej wartości.
#include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <ostream>
#include <string>
#include <vector>
using namespace std;
using namespace std;
using namespace std::placeholders;
bool shorter_than(const string& l, const string& r)
{
return l.size() < r.size();
}
int main()
{
vector<string> v_original;
v_original.push_back("tiger");
v_original.push_back("cat");
v_original.push_back("lion");
v_original.push_back("cougar");
copy(v_original.begin(), v_original.end(), ostream_iterator<string>(cout, " "));
cout << endl;
string s("meow");
function<bool (const string&)> f = bind(shorter_than, _1, s);
function<bool (const string&)> f_ref = bind(shorter_than, _1, ref(s));
vector<string> v;
// Remove elements that are shorter than s ("meow")
v = v_original;
v.erase(remove_if(v.begin(), v.end(), f), v.end());
copy(v.begin(), v.end(), ostream_iterator<string>(cout, " "));
cout << endl;
// Now change the value of s.
// f_ref, which is bound to ref(s), will use the
// new value, while f is still bound to the old value.
s = "kitty";
// Remove elements that are shorter than "meow" (f is bound to old value of s)
v = v_original;
v.erase(remove_if(v.begin(), v.end(), f), v.end());
copy(v.begin(), v.end(), ostream_iterator<string>(cout, " "));
cout << endl;
// Remove elements that are shorter than "kitty" (f_ref is bound to ref(s))
v = v_original;
v.erase(remove_if(v.begin(), v.end(), f_ref), v.end());
copy(v.begin(), v.end(), ostream_iterator<string>(cout, " "));
cout << endl;
}
tiger cat lion cougar
tiger lion cougar
tiger lion cougar
tiger cougar
swap
Zamienia dwa function
obiekty.
template <class FT>
void swap(function<FT>& f1, function<FT>& f2);
Parametry
FT
Typ kontrolowany przez obiekty funkcji.
f1
Pierwszy obiekt funkcji.
f2
Drugi obiekt funkcji.
Uwagi
Funkcja zwraca f1.swap(f2)
wartość .
Przykład
// std__functional__swap.cpp
// compile with: /EHsc
#include <functional>
#include <iostream>
int neg(int val)
{
return (-val);
}
int main()
{
std::function<int (int)> fn0(neg);
std::cout << std::boolalpha << "empty == " << !fn0 << std::endl;
std::cout << "val == " << fn0(3) << std::endl;
std::function<int (int)> fn1;
std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;
std::cout << std::endl;
swap(fn0, fn1);
std::cout << std::boolalpha << "empty == " << !fn0 << std::endl;
std::cout << std::boolalpha << "empty == " << !fn1 << std::endl;
std::cout << "val == " << fn1(3) << std::endl;
return (0);
}
empty == false
val == -3
empty == true
empty == true
empty == false
val == -3