Classes
Wrapper classes
Wrapper classes are classes that hold an object and have an interface similar to that object, but adding or changing some of its features:
binary_negate
template <class Predicate> class binary_negate;
Negate binary function object class
二元函数对象类,其调用返回与传递给其构造函数的另一个二元函数相反的值。 类型为binary_enegate的对象通常使用函数not2构造。 类的定义行为与以下行为相同:
template <class Predicate> class binary_negate
{
protected:
Predicate fn_;
public:
explicit binary_negate (const Predicate& pred) : fn_ (pred) {}
bool operator() (const typename Predicate::argument_type& x) const {return !fn_(x,y);}
typedef typename Predicate::first_argument_type first_argument_type;
typedef typename Predicate::second_argument_type second_argument_type;
typedef bool result_type;
};
// binary_negate example
#include <iostream> // std::cout
#include <functional> // std::binary_negate, std::equal_to
#include <algorithm> // std::mismatch
#include <utility> // std::pair
int main () {
std::equal_to<int> equality;
std::binary_negate < std::equal_to<int> > nonequality (equality);
int foo[] = {10,20,30,40,50};
int bar[] = {0,15,30,45,60};
std::pair<int*,int*> firstmatch,firstmismatch;
firstmismatch = std::mismatch (foo,foo+5,bar,equality);
firstmatch = std::mismatch (foo,foo+5,bar,nonequality);
std::cout << "First mismatch in bar is " << *firstmismatch.second << "\n";
std::cout << "First match in bar is " << *firstmatch.second << "\n";
return 0;
}
Output:
First mismatch in bar is 0 First match in bar is 30 |
function
template <class T> function; // undefinedtemplate <class Ret, class... Args> class function<Ret(Args...)>;
Function wrapper
类,该类可以将任何类型的可调用元素(如函数和函数对象)包装成可复制对象,并且其类型仅取决于其调用签名(而不取决于可调用元素类型本身)。
函数类实例化的对象可以包装以下任何类型的可调用对象:函数、函数指针、指向成员的指针或任何类型的函数对象(即,其类定义运算符()的对象,包括闭包)。
包装的可调用对象的衰减副本由对象内部存储,该对象成为函数的目标。不需要此目标可调用对象的特定类型来实例化函数包装类;只有其呼叫签名。
函数对象可以被复制和移动,并且可以用于直接调用具有指定调用签名的可调用对象(请参见成员运算符())。
函数对象也可以处于没有目标可调用对象的状态。在这种情况下,它们被称为空函数,调用它们会引发bad_function_call异常。
reference_wrapper
template <class T> class reference_wrapper;
Reference wrapper
Class that emulates a reference to an element of type T, but which can be copied (it is both copy-constructible and copy-assignable).
// reference_wrapper example:
#include <iostream> // std::cout
#include <functional> // std::reference_wrapper
int main () {
int a(10),b(20),c(30);
// an array of "references":
std::reference_wrapper<int> refs[] = {a,b,c};
std::cout << "refs:";
for (int& x : refs) std::cout << ' ' << x;
std::cout << '\n';
return 0;
}
Possible output:
refs: 10 20 30 |
unary_negate
template <class Predicate> class unary_negate;
Negate unary function object class
一元函数对象类,其调用返回与传递给其构造函数的另一个一元函数相反的结果。
类型为unary_onegate的对象通常使用函数not1构造。
类的定义行为与以下行为相同:
template <class Predicate> class unary_negate
{
protected:
Predicate fn_;
public:
explicit unary_negate (const Predicate& pred) : fn_ (pred) {}
bool operator() (const typename Predicate::argument_type& x) const {return !fn_(x);}
typedef typename Predicate::argument_type argument_type;
typedef bool result_type;
};
// unary_negate example
#include <iostream> // std::cout
#include <functional> // std::unary_negate
#include <algorithm> // std::count_if
struct IsOdd_class {
bool operator() (const int& x) const {return x%2==1;}
typedef int argument_type;
} IsOdd_object;
int main () {
std::unary_negate<IsOdd_class> IsEven_object (IsOdd_object);
int values[] = {1,2,3,4,5};
int cx;
cx = std::count_if ( values, values+5, IsEven_object );
std::cout << "There are " << cx << " elements with even values.\n";
return 0;
}
Output:
There are 2 elements with even values. |
Operator classes
Operator classes are classes that define functional objects that call operators:
bit_and
template <class T> struct bit_and;
Bitwise AND function object class
二元函数对象,其调用返回在其两个参数之间应用按位“and”运算的结果(由运算符&返回)。
一般来说,函数对象是定义了成员函数运算符()的类的实例。此成员函数允许使用与函数调用相同的语法来使用对象。
它的定义与以下行为相同:
template <class T> struct bit_and {
T operator() (const T& x, const T& y) const {return x&y;}
typedef T first_argument_type;
typedef T second_argument_type;
typedef T result_type;
};
// bit_and example
#include <iostream> // std::cout
#include <functional> // std::bit_and
#include <algorithm> // std::transform
#include <iterator> // std::end
int main () {
int values[] = {100,200,300,400,500};
int masks[] = {0xf,0xf,0xf,255,255};
int results[5];
std::transform (values, std::end(values), masks, results, std::bit_and<int>());
std::cout << "results:";
for (const int& x: results)
std::cout << ' ' << x;
std::cout << '\n';
return 0;
}
Output:
results: 4 8 12 144 244 |
bit_or
template <class T> struct bit_or;
Bitwise OR function object class
二元函数对象类,其调用返回在其两个参数之间应用按位“或”运算的结果(由运算符|返回)。
一般来说,函数对象是定义了成员函数运算符()的类的实例。此成员函数允许使用与函数调用相同的语法来使用对象。
它的定义与以下行为相同:
template <class T> struct bit_or {
T operator() (const T& x, const T& y) const {return x|y;}
typedef T first_argument_type;
typedef T second_argument_type;
typedef T result_type;
};
// bit_or example
#include <iostream> // std::cout
#include <functional> // std::bit_or
#include <numeric> // std::accumulate
#include <iterator> // std::end
int main () {
int flags[] = {1,2,4,8,16,32,64,128};
int acc = std::accumulate (flags, std::end(flags), 0, std::bit_or<int>());
std::cout << "accumulated: " << acc << '\n';
return 0;
}
Output:
accumulated: 255 |
bit_xor
template <class T> struct bit_xor;
Bitwise XOR function object class
二元函数对象类,其调用返回在其两个参数之间应用逐位“异或”运算的结果(由运算符^返回)。
一般来说,函数对象是定义了成员函数运算符()的类的实例。此成员函数允许使用与函数调用相同的语法来使用对象。
它的定义与以下行为相同:
template <class T> struct bit_xor {
T operator() (const T& x, const T& y) const {return x^y;}
typedef T first_argument_type;
typedef T second_argument_type;
typedef T result_type;
};
// bit_xor example
#include <iostream> // std::cout
#include <functional> // std::bit_xor
#include <algorithm> // std::accumulate
#include <iterator> // std::end
int main () {
int flags[] = {1,2,3,4,5,6,7,8,9,10};
int acc = std::accumulate (flags, std::end(flags), 0, std::bit_xor<int>());
std::cout << "xor: " << acc << '\n';
return 0;
}
Output:
xor: 11 |
divides
template <class T> struct divides;
Division function object class
二元函数对象类,其调用返回第一个参数除以第二个参数的结果(由运算符/返回)。
一般来说,函数对象是定义了成员函数运算符()的类的实例。此成员函数允许使用与函数调用相同的语法来使用对象。
它的定义与以下行为相同:
template <class T> struct divides {
T operator() (const T& x, const T& y) const {return x/y;}
typedef T first_argument_type;
typedef T second_argument_type;
typedef T result_type;
};
// divides example
#include <iostream> // std::cout
#include <functional> // std::divides
#include <algorithm> // std::transform
int main () {
int first[]={10,40,90,40,10};
int second[]={1,2,3,4,5};
int results[5];
std::transform (first, first+5, second, results, std::divides<int>());
for (int i=0; i<5; i++)
std::cout << results[i] << ' ';
std::cout << '\n';
return 0;
}
Output:
10 20 30 10 2 |
equal_to
template <class T> struct equal_to;
Function object class for equality comparison
二元函数对象类,其调用返回其两个参数是否相等(由运算符==返回)。
一般来说,函数对象是定义了成员函数运算符()的类的实例。此成员函数允许使用与函数调用相同的语法来使用对象。
它的定义与以下行为相同:
template <class T> struct equal_to {
bool operator() (const T& x, const T& y) const {return x==y;}
typedef T first_argument_type;
typedef T second_argument_type;
typedef bool result_type;
};
// equal_to example
#include <iostream> // std::cout
#include <utility> // std::pair
#include <functional> // std::equal_to
#include <algorithm> // std::mismatch
int main () {
std::pair<int*,int*> ptiter;
int foo[]={10,20,30,40,50};
int bar[]={10,20,40,80,160};
ptiter = std::mismatch (foo, foo+5, bar, std::equal_to<int>());
std::cout << "First mismatching pair is: " << *ptiter.first;
std::cout << " and " << *ptiter.second << '\n';
return 0;
}
Output:
First mismatching pair is: 30 and 40 |
greater
template <class T> struct greater;
Function object class for greater-than inequality comparison
二元函数对象类,其调用返回其第一个参数是否大于第二个参数(由运算符>返回)。
一般来说,函数对象是定义了成员函数运算符()的类的实例。此成员函数允许使用与函数调用相同的语法来使用对象。
它的定义与以下行为相同:
template <class T> struct greater {
bool operator() (const T& x, const T& y) const {return x>y;}
typedef T first_argument_type;
typedef T second_argument_type;
typedef bool result_type;
};
// greater example
#include <iostream> // std::cout
#include <functional> // std::greater
#include <algorithm> // std::sort
int main () {
int numbers[]={20,40,50,10,30};
std::sort (numbers, numbers+5, std::greater<int>());
for (int i=0; i<5; i++)
std::cout << numbers[i] << ' ';
std::cout << '\n';
return 0;
}
Output:
50 40 30 20 10 |
greater_equal
template <class T> struct greater_equal;
Function object class for greater-than-or-equal-to comparison
二元函数对象类,其调用返回其第一个参数是否大于或等于第二个参数(由运算符>=返回)。
一般来说,函数对象是定义了成员函数运算符()的类的实例。此成员函数允许使用与函数调用相同的语法来使用对象。
它的定义与以下行为相同:
template <class T> struct greater_equal {
bool operator() (const T& x, const T& y) const {return x>=y;}
typedef T first_argument_type;
typedef T second_argument_type;
typedef bool result_type;
};
// greater_equal example
#include <iostream> // std::cout
#include <functional> // std::greater_equal, std::bind2nd
#include <algorithm> // std::count_if
int main () {
int numbers[]={20,-30,10,-40,0};
int cx = std::count_if (numbers, numbers+5, std::bind2nd(std::greater_equal<int>(),0));
std::cout << "There are " << cx << " non-negative elements.\n";
return 0;
}
Output:
There are 3 non-negative elements. |
less
template <class T> struct less;
Function object class for less-than inequality comparison
二元函数对象类,其调用返回其第一个参数是否小于第二个参数(由运算符<返回)。
一般来说,函数对象是定义了成员函数运算符()的类的实例。此成员函数允许使用与函数调用相同的语法来使用对象。
它的定义与以下行为相同:
template <class T> struct less {
bool operator() (const T& x, const T& y) const {return x<y;}
typedef T first_argument_type;
typedef T second_argument_type;
typedef bool result_type;
};
// less example
#include <iostream> // std::cout
#include <functional> // std::less
#include <algorithm> // std::sort, std::includes
int main () {
int foo[]={10,20,5,15,25};
int bar[]={15,10,20};
std::sort (foo, foo+5, std::less<int>()); // 5 10 15 20 25
std::sort (bar, bar+3, std::less<int>()); // 10 15 20
if (std::includes (foo, foo+5, bar, bar+3, std::less<int>()))
std::cout << "foo includes bar.\n";
return 0;
}
Output:
foo includes bar. |
less_equal
template <class T> struct less_equal;
Function object class for less-than-or-equal-to comparison
二元函数对象类,其调用返回其第一个参数是否小于或等于第二个参数(由运算符<=返回)。
一般来说,函数对象是定义了成员函数运算符()的类的实例。
此成员函数允许使用与函数调用相同的语法来使用对象。 它的定义与以下行为相同:
template <class T> struct less_equal {
bool operator() (const T& x, const T& y) const {return x<=y;}
typedef T first_argument_type;
typedef T second_argument_type;
typedef bool result_type;
};
// less_equal example
#include <iostream> // std::cout
#include <functional> // std::less_equal, std::bind2nd
#include <algorithm> // std::count_if
int main () {
int numbers[]={25,50,75,100,125};
int cx = std::count_if (numbers, numbers+5, std::bind2nd(std::less_equal<int>(),100));
std::cout << "There are " << cx << " elements lower than or equal to 100.\n";
return 0;
}
Output:
There are 4 elements lower or equal to 100. |
logical_and
template <class T> struct logical_and;
Logical AND function object class
二元函数对象类,其调用返回其两个参数之间的逻辑“and”运算的结果(由运算符&&返回)。
一般来说,函数对象是定义了成员函数运算符()的类的实例。此成员函数允许使用与函数调用相同的语法来使用对象。
它的定义与以下行为相同:
template <class T> struct logical_and {
bool operator() (const T& x, const T& y) const {return x&&y;}
typedef T first_argument_type;
typedef T second_argument_type;
typedef bool result_type;
};
// logical_and example
#include <iostream> // std::cout, std::boolalpha
#include <functional> // std::logical_and
#include <algorithm> // std::transform
int main () {
bool foo[] = {true,false,true,false};
bool bar[] = {true,true,false,false};
bool result[4];
std::transform (foo, foo+4, bar, result, std::logical_and<bool>());
std::cout << std::boolalpha << "Logical AND:\n";
for (int i=0; i<4; i++)
std::cout << foo[i] << " AND " << bar[i] << " = " << result[i] << "\n";
return 0;
}
Output:
Logical AND: true AND true = true false AND true = false true AND false = false false AND false = false |
logical_not
template <class T> struct logical_not;
Logical NOT function object class
一元函数对象类,其调用返回其参数的逻辑“not”运算的结果(由运算符返回!)。
一般来说,函数对象是定义了成员函数运算符()的类的实例。此成员函数允许使用与函数调用相同的语法来使用对象。
它的定义与以下行为相同:
template <class T> struct logical_not {
bool operator() (const T& x) const {return !x;}
typedef T argument_type;
typedef bool result_type;
};
// logical_not example
#include <iostream> // std::cout, std::boolalpha
#include <functional> // std::logical_not
#include <algorithm> // std::transform
int main () {
bool values[] = {true,false};
bool result[2];
std::transform (values, values+2, result, std::logical_not<bool>());
std::cout << std::boolalpha << "Logical NOT:\n";
for (int i=0; i<2; i++)
std::cout << "NOT " << values[i] << " = " << result[i] << "\n";
return 0;
}
Output:
Logical NOT: NOT true = false NOT false = true |
logical_or
template <class T> struct logical_or;
Logical OR function object class
二元函数对象类,其调用返回其两个参数之间的逻辑“或”运算的结果(由运算符||返回)。
一般来说,函数对象是定义了成员函数运算符()的类的实例。此成员函数允许使用与函数调用相同的语法来使用对象。
它的定义与以下行为相同:
template <class T> struct logical_or {
bool operator() (const T& x, const T& y) const {return x||y;}
typedef T first_argument_type;
typedef T second_argument_type;
typedef bool result_type;
};
// logical_or example
#include <iostream> // std::cout, std::boolalpha
#include <functional> // std::logical_or
#include <algorithm> // std::transform
int main () {
bool foo[] = {true,false,true,false};
bool bar[] = {true,true,false,false};
bool result[4];
std::transform (foo, foo+4, bar, result, std::logical_or<bool>());
std::cout << std::boolalpha << "Logical OR:\n";
for (int i=0; i<4; i++)
std::cout << foo[i] << " OR " << bar[i] << " = " << result[i] << "\n";
return 0;
}
Output:
Logical OR: true OR true = true false OR true = true true OR false = true false OR false = false |
minus
template <class T> struct minus;
Subtraction function object class
二元函数对象类,其调用返回从第一个参数减去第二个参数的结果(由二进制运算符-返回)。
一般来说,函数对象是定义了成员函数运算符()的类的实例。此成员函数允许使用与函数调用相同的语法来使用对象。
它的定义与以下行为相同:
template <class T> struct minus {
T operator() (const T& x, const T& y) const {return x-y;}
typedef T first_argument_type;
typedef T second_argument_type;
typedef T result_type;
};
// minus example
#include <iostream> // std::cout
#include <functional> // std::minus
#include <algorithm> // std::transform
int main () {
int numbers[]={10,20,30};
int result;
result = std::accumulate (numbers, numbers+3, 100, std::minus<int>());
std::cout << "The result of 100-10-20-30 is " << result << ".\n";
return 0;
}
Output:
The result of 100-10-20-30 is 40. |
modulus
template <class T> struct modulus;
Modulus function object class
二元函数对象类,其调用返回其两个参数之间的模运算结果(由运算符%返回)。
一般来说,函数对象是定义了成员函数运算符()的类的实例。此成员函数允许使用与函数调用相同的语法来使用对象。
它的定义与以下行为相同:
template <class T> struct modulus {
T operator() (const T& x, const T& y) const {return x%y;}
typedef T first_argument_type;
typedef T second_argument_type;
typedef T result_type;
};
// modulus example
#include <iostream> // std::cout
#include <functional> // std::modulus, std::bind2nd
#include <algorithm> // std::transform
int main () {
int numbers[]={1,2,3,4,5};
int remainders[5];
std::transform (numbers, numbers+5, remainders, std::bind2nd(std::modulus<int>(),2));
for (int i=0; i<5; i++)
std::cout << numbers[i] << " is " << (remainders[i]==0?"even":"odd") << '\n';
return 0;
}
Output:
1 is odd 2 is even 3 is odd 4 is even 5 is odd |
multiplies
template <class T> struct multiplies;
Multiplication function object class
二元函数对象类,其调用返回其两个参数相乘的结果(由运算符*返回)。
一般来说,函数对象是定义了成员函数运算符()的类的实例。此成员函数允许使用与函数调用相同的语法来使用对象。
它的定义与以下行为相同:
template <class T> struct multiplies {
T operator() (const T& x, const T& y) const {return x*y;}
typedef T first_argument_type;
typedef T second_argument_type;
typedef T result_type;
};
// factorials (multiplies example)
#include <iostream> // std::cout
#include <functional> // std::multiplies
#include <numeric> // std::partial_sum
int main () {
int numbers[9];
int factorials[9];
for (int i=0;i<9;i++) numbers[i]=i+1;
std::partial_sum (numbers, numbers+9, factorials, std::multiplies<int>());
for (int i=0; i<9; i++)
std::cout << numbers[i] << "! is " << factorials[i] << '\n';
return 0;
}
Output:
1! is 1 2! is 2 3! is 6 4! is 24 5! is 120 6! is 720 7! is 5040 8! is 40320 9! is 362880 |
negate
template <class T> struct negate;
Negative function object class
一元函数对象类,其调用返回否定其参数的结果(由一元运算符-返回)。
对一个值取反将返回相同的值,但符号相反。
一般来说,函数对象是定义了成员函数运算符()的类的实例。此成员函数允许使用与函数调用相同的语法来使用对象。
它的定义与以下行为相同:
template <class T> struct negate {
T operator() (const T& x) const {return -x;}
typedef T argument_type;
typedef T result_type;
};
// negate example
#include <iostream> // std::cout
#include <functional> // std::negate
#include <algorithm> // std::transform
int main () {
int numbers[]={10,-20,30,-40,50};
std::transform (numbers, numbers+5, numbers, std::negate<int>());
for (int i=0; i<5; i++)
std::cout << numbers[i] << ' ';
std::cout << '\n';
return 0;
}
Output:
-10 20 -30 40 -50 |
not_equal_to
template <class T> struct not_equal_to;
Function object class for non-equality comparison
二元函数对象类,其调用返回其两个参数是否比较不相等(由运算符运算符返回!=)。
一般来说,函数对象是定义了成员函数运算符()的类的实例。
此成员函数允许使用与函数调用相同的语法来使用对象。
它的定义与以下行为相同:
template <class T> struct not_equal_to {
bool operator() (const T& x, const T& y) const {return x!=y;}
typedef T first_argument_type;
typedef T second_argument_type;
typedef bool result_type;
};
// not_equal_to example
#include <iostream> // std::cout
#include <functional> // std::not_equal_to
#include <algorithm> // std::adjacent_find
int main () {
int numbers[]={10,10,10,20,20};
int* pt = std::adjacent_find (numbers, numbers+5, std::not_equal_to<int>()) +1;
std::cout << "The first different element is " << *pt << '\n';
return 0;
}
Output:
The first different element is 20 |
plus
template <class T> struct plus;
Addition function object class
二元函数对象类,其调用返回添加其两个参数的结果(由运算符+返回)。
一般来说,函数对象是定义了成员函数运算符()的类的实例。此成员函数允许使用与函数调用相同的语法来使用对象。
它的定义与以下行为相同:
template <class T> struct plus {
T operator() (const T& x, const T& y) const {return x+y;}
typedef T first_argument_type;
typedef T second_argument_type;
typedef T result_type;
};
// plus example
#include <iostream> // std::cout
#include <functional> // std::plus
#include <algorithm> // std::transform
int main () {
int first[]={1,2,3,4,5};
int second[]={10,20,30,40,50};
int results[5];
std::transform (first, first+5, second, results, std::plus<int>());
for (int i=0; i<5; i++)
std::cout << results[i] << ' ';
std::cout << '\n';
return 0;
}
Output:
11 22 33 44 55 |
Other classes
bad_function_call
class bad_function_call;
Exception thrown on bad call
在调用空函数对象的函数调用时由其抛出的类型。
空函数对象是没有目标可调用对象的函数对象。
此类派生自异常。有关标准异常的成员定义,请参见异常类。
// bad_function_call example
#include <iostream> // std::cout
#include <functional> // std::function, std::plus, std::bad_function_call
int main () {
std::function<int(int,int)> foo = std::plus<int>();
std::function<int(int,int)> bar;
try {
std::cout << foo(10,20) << '\n';
std::cout << bar(10,20) << '\n';
}
catch (std::bad_function_call& e)
{
std::cout << "ERROR: Bad function call\n";
}
return 0;
}
Output:
30 ERROR: Bad function call |
hash
template <class T> struct hash;
Default hash function object class
一元函数对象类,用于定义标准库使用的默认哈希函数。
函数调用返回其参数的哈希值:哈希值是一个仅依赖于其参数的值,对于相同的参数(对于给定的程序执行)总是返回相同的值。返回的值与为不同参数返回的值相同的可能性很小(碰撞的可能性接近1/numeric_limits<size_t>:max)。
其他函数对象类型可以用作无序容器的哈希,前提是它们的行为如上所述,并且它们至少是可复制的、可破坏的函数对象。
默认的hash是一个模板类,它不是为一般情况定义的。但是,所有库实现都至少提供以下特定于类型的专业化:
除了可以用适当类型的参数调用外,哈希实例化的所有对象都是默认可构造的、可复制可构造的,可复制可分配的、可破坏的和可交换的。
用户可以使用这些相同的属性为此模板提供自定义专业化。
// hash example
#include <iostream>
#include <functional>
#include <string>
int main ()
{
char nts1[] = "Test";
char nts2[] = "Test";
std::string str1 (nts1);
std::string str2 (nts2);
std::hash<char*> ptr_hash;
std::hash<std::string> str_hash;
std::cout << "same hashes:\n" << std::boolalpha;
std::cout << "nts1 and nts2: " << (ptr_hash(nts1)==ptr_hash(nts2)) << '\n';
std::cout << "str1 and str2: " << (str_hash(str1)==str_hash(str2)) << '\n';
return 0;
}
Output:
same hashes: nts1 and nts2: false str1 and str2: true |
is_bind_expression
template <class T> struct is_bind_expression;
Is bind expression
用于标识T是否为绑定表达式的Trait类。
bind函数使用这个特性来确定其每个参数的类型是否是子表达式(即,它本身是否是bind返回的类型)。用户可以将此模板专门用于将被视为绑定子表达式的类型。
// is_bind_expression example
#include <iostream> // std::cout, std::boolalpha
#include <functional> // std::bind, std::plus, std::placeholders, std::is_bind_expression
int main () {
using namespace std::placeholders; // introduces _1
auto increase_int = std::bind (std::plus<int>(),_1,1);
std::cout << std::boolalpha;
std::cout << std::is_bind_expression<decltype(increase_int)>::value << '\n';
return 0;
}
Output:
true |
is_placeholder
template <class T> struct is_placeholder;
Is placeholder
用于标识T是否为绑定占位符的Trait类。
bind函数使用此特性来确定其每个参数的类型是否为占位符。用户可以将此模板专门用于将被视为占位符的类型。
// is_placeholder example
#include <iostream> // std::cout, std::boolalpha
#include <functional> // std::is_placeholder, std::placeholders
int main () {
using namespace std::placeholders; // introduces _1
std::cout << std::is_placeholder<decltype(_1)>::value << '\n';
std::cout << std::is_placeholder<decltype(_2)>::value << '\n';
std::cout << std::is_placeholder<int>::value << '\n';
return 0;
}
Output:
1 2 0 |
placeholders
namespace placeholders { extern /* unspecified */ _1; extern /* unspecified */ _2; extern /* unspecified */ _3; // ...}
Bind argument placeholders
此命名空间声明了未指定数量的对象:_1,_2,_3,。。。,用于指定函数绑定调用中的占位符。
当调用bind返回的函数对象时,占位符为_1的参数会被调用中的第一个参数替换,_2会被调用的第二个参数替换等等…例如:
using namespace std::placeholders;
auto bound_fn = std::bind (fn,100,_1);
bound_fn(5); // calls fn(100,5), i.e.: replacing _1 by the first argument: 5
这些占位符对象的类型是未指定的(这取决于库实现,请参见is_placeholder),但在所有情况下,它们的类型至少应为nothrow默认可构造和nothrow副本可构造。是否支持赋值操作或附加构造函数是由实现定义的,但任何复制赋值或移动构造函数也不应抛出。
当一个绑定调用被用作另一个绑定的调用中的子表达式时,占位符是相对于最外层的绑定表达式的。