C++/C++11中头文件functional的使用

<functional>是C++标准库中的一个头文件，定义了C++标准中多个用于表示函数对象(function object)的类模板，包括算法操作、比较操作、逻辑操作；以及用于绑定函数对象的实参值的绑定器(binder)。这些类模板的实例是具有函数调用运算符(function call operator)的C++类，这些类的实例可以如同函数一样调用。不必写新的函数对象，而仅是组合预定义的函数对象与函数对象适配器(function object adaptor)，就可以执行非常复杂的操作。

std::bind：将一个或多个参数绑定到函数对象，更详细的用法可参考 http://blog.csdn.net/fengbingchun/article/details/52613910 ；

std::is_bind_expression:用于判断指定表达式是否为std::bind函数返回的结果类型；

std::reference_wrapper：类模板，用于包装对一个实例的引用，它是可拷贝和可赋值的；

std::ref：构造一个适当的std::reference_wrapper类型的对象来保存对elem(实例对象)的引用；

std::cref：构造一个适当的std::reference_wrapper类型的对象来保存对elem(实例对象)的const 引用；

std::mem_fn：将成员函数转换为函数对象；

std::not1：返回一个对谓词(一元函数)的结果取反的函数对象；

std::not2：返回一个对二元谓词(二元函数)的结果取反的函数对象；

std::unary_negate：一元谓词对象类，其调用时把另一个一元谓词的返回值取反；

std::binary_negate：二元谓词对象类，其调用时把另一个二元谓词的返回值取反；

std::function：类模版，是一种通用、多态的函数封装。std::function的实例可以对任何可以调用的目标实体进行存储、复制、和调用操作，这些目标实体包括普通函数、Lambda表达式、函数指针、以及其它函数对象等，更详细的用法可参考 http://blog.csdn.net/fengbingchun/article/details/52562918 ；

std::and：二元谓词对象类, x& y；

std::or：二元谓词对象类, x |y；

std::xor：二元谓词对象类， x ^y；

std::plus：二元谓词对象类, x +y；

std::minus：二元谓词对象类, x -y；

std::multiplies：二元谓词对象类, x *y；

std::divides：二元谓词对象类, x /y；

std::modulus：二元谓词对象类, x %y；

std::negate：一元谓词对象类, -x；

std::equal_to: 二元谓词对象类, x ==y；

std::not_equal_to:二元谓词对象类, x != y；

std::greater: 二元谓词对象类, x >y；

std::less: 二元谓词对象类, x <y；

std::greater_equal:二元谓词对象类, x >= y；

std::less_equal:二元谓词对象类, x <= y；

std::logical_and:二元谓词对象类, x && y；

std::logical_or:二元谓词对象类, x || y；

std::logical_not:一元谓词对象类, !x；

std::bad_function_call：这是一个被抛出的异常类，用于表示被调用的函数对象为空；

std::hash：一元函数对象类，用于定义标准库使用的默认散列函数；

std::placeholders：命名空间，该命名空间声明一个未指定数量的对象：_1，_2，_3，...，用于在函数std::bind的调用中指定占位符；

std::is_placeholder：用于判断指定表达式是否为std::placeholders中定义的placeholder类型。

C++11中也废弃了一些旧式的函数对象。

下面是从其它文章中copy的<functional>测试代码，详细内容介绍可以参考对应的reference：

#include "functional.hpp"
#include <functional>
#include <iostream>
#include <algorithm>
#include <utility>
#include <iterator>
#include <numeric>
#include <string>// reference: http://www.cplusplus.com/reference/functional/namespace functional_ {
///
// a function: (also works with function object: std::divides<double> my_divide;)
static double my_divide(double x, double y) { return x / y; }struct MyPair {double a, b;double multiply() { return a*b; }
};int test_functional_bind()
{using namespace std::placeholders;    // adds visibility of _1, _2, _3,...// binding functions:auto fn_five = std::bind(my_divide, 10, 2);               // returns 10/2std::cout << fn_five() << '\n';                           // 5auto fn_half = std::bind(my_divide, _1, 2);               // returns x/2std::cout << fn_half(10) << '\n';                         // 5auto fn_invert = std::bind(my_divide, _2, _1);            // returns y/xstd::cout << fn_invert(10, 2) << '\n';                    // 0.2auto fn_rounding = std::bind<int>(my_divide, _1, _2);     // returns int(x/y)std::cout << fn_rounding(10, 3) << '\n';                  // 3MyPair ten_two{ 10, 2 };// binding members:auto bound_member_fn = std::bind(&MyPair::multiply, _1); // returns x.multiply()std::cout << bound_member_fn(ten_two) << '\n';           // 20auto bound_member_data = std::bind(&MyPair::a, ten_two); // returns ten_two.astd::cout << bound_member_data() << '\n';                // 10return 0;
}//
int test_functional_cref()
{int foo(10);auto bar = std::cref(foo);std::cout << bar << '\n'; // 10++foo;std::cout << bar << '\n'; // 11return 0;
}/
int test_functional_ref()
{int foo(10);auto bar = std::ref(foo);std::cout << bar << '\n'; // 10++bar;std::cout << foo << '\n'; // 11std::cout << bar << '\n'; // 11return 0;
}//
struct int_holder {int value;int triple() { return value * 3; }
};int test_functional_mem_fn()
{int_holder five{ 5 };// call member directly:std::cout << five.triple() << '\n'; // 15// same as above using a mem_fn:auto triple = std::mem_fn(&int_holder::triple);std::cout << triple(five) << '\n'; // 15return 0;
}//
struct IsOdd {bool operator() (const int& x) const { return x % 2 == 1; }typedef int argument_type;
};int test_functional_not1()
{int values[] = { 1, 2, 3, 4, 5 };int cx = std::count_if(values, values + 5, std::not1(IsOdd()));std::cout << "There are " << cx << " elements with even values.\n"; // 2return 0;
}int test_functional_not2()
{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, std::equal_to<int>());firstmatch = std::mismatch(foo, foo + 5, bar, std::not2(std::equal_to<int>()));std::cout << "First mismatch in bar is " << *firstmismatch.second << '\n'; // 0std::cout << "First match in bar is " << *firstmatch.second << '\n'; // 30return 0;
}//
int test_functional_binary_negate()
{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"; // 0std::cout << "First match in bar is " << *firstmatch.second << "\n"; // 30return 0;
}struct IsOdd_class {bool operator() (const int& x) const { return x % 2 == 1; }typedef int argument_type;
} IsOdd_object;int test_functional_unary_negate()
{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"; // 2return 0;
}// a function:
static int half(int x) { return x / 2; }// a function object class:
struct third_t {int operator()(int x) { return x / 3; }
};// a class with data members:
struct MyValue {int value;int fifth() { return value / 5; }
};int test_functional_function()
{std::function<int(int)> fn1 = half;                       // functionstd::function<int(int)> fn2 = ½                      // function pointerstd::function<int(int)> fn3 = third_t();                  // function objectstd::function<int(int)> fn4 = [](int x){return x / 4; };  // lambda expressionstd::function<int(int)> fn5 = std::negate<int>();         // standard function objectstd::cout << "fn1(60): " << fn1(60) << '\n'; // 30std::cout << "fn2(60): " << fn2(60) << '\n'; // 30std::cout << "fn3(60): " << fn3(60) << '\n'; // 20std::cout << "fn4(60): " << fn4(60) << '\n'; // 15std::cout << "fn5(60): " << fn5(60) << '\n'; // -06// stuff with members:std::function<int(MyValue)> value = &MyValue::value;  // pointer to data memberstd::function<int(MyValue)> fifth = &MyValue::fifth;  // pointer to member functionMyValue sixty{ 60 };std::cout << "value(sixty): " << value(sixty) << '\n'; // 60std::cout << "fifth(sixty): " << fifth(sixty) << '\n'; // 12return 0;
}int test_functional_reference_wrapper()
{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; // 10 20 30std::cout << '\n';return 0;
}//
int test_functional_bit()
{
{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; // 4 8 12 144 244std::cout << '\n';
}{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'; // 255
}{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'; // 11
}return 0;
}//
int test_functional_arithmetic()
{
{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] << ' '; // 11 22 33 44 55std::cout << '\n';
}{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"; // 40
}{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'; // 1 2 6 24 120 720 5040 40320 362880
}{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] << ' '; // 10 20 30 10 2std::cout << '\n';
}{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';
}{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] << ' '; // -10 20 -30 40 -50std::cout << '\n';
}return 0;
}///
int test_functional_compare()
{
{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; // 30std::cout << " and " << *ptiter.second << '\n'; // 40
}{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'; // 20
}{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] << ' '; // 50 40 30 20 10std::cout << '\n';
}{int foo[] = { 10, 20, 5, 15, 25 };int bar[] = { 15, 10, 20 };std::sort(foo, foo + 5, std::less<int>());  // 5 10 15 20 25std::sort(bar, bar + 3, std::less<int>());  //   10 15 20if (std::includes(foo, foo + 5, bar, bar + 3, std::less<int>()))std::cout << "foo includes bar.\n"; // foo includes bar
}{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"; // 3
}{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"; // 4
}return 0;
}///
int test_functional_logical()
{
{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"; // true false false false
}{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"; // true true true false
}{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"; // false true
}return 0;
}int test_functional_bad_function_call()
{std::function<int(int, int)> foo = std::plus<int>();std::function<int(int, int)> bar;try {std::cout << foo(10, 20) << '\n'; // 30std::cout << bar(10, 20) << '\n';} catch (std::bad_function_call& e){std::cout << "ERROR: Bad function call\n"; // ERROR: Bad function call}return 0;
}//
int test_functional_hash()
{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'; // falsestd::cout << "str1 and str2: " << (str_hash(str1) == str_hash(str2)) << '\n'; // truereturn 0;
}/
int test_functional_is_bind_expression()
{using namespace std::placeholders;  // introduces _1auto increase_int = std::bind(std::plus<int>(), _1, 1);std::cout << std::boolalpha;std::cout << std::is_bind_expression<decltype(increase_int)>::value << '\n'; // truereturn 0;
}/
int test_functional_is_placeholder()
{using namespace std::placeholders;  // introduces _1std::cout << std::is_placeholder<decltype(_1)>::value << '\n'; // 1std::cout << std::is_placeholder<decltype(_2)>::value << '\n'; // 2std::cout << std::is_placeholder<int>::value << '\n'; // 0return 0;
}} // namespace functional_

GitHub： https://github.com/fengbingchun/Messy_Test

C++/C++11中头文件functional的使用相关推荐

C++11中头文件thread的使用
C++11中加入了<thread>头文件,此头文件主要声明了std::thread线程类.C++11的标准类std::thread对线程进行了封装.std::thread代表了一个线程对象 ...
C++11中头文件type_traits介绍
C++11中的头文件type_traits定义了一系列模板类,在编译期获得某一参数.某一变量.某一个类等等类型信息,主要做静态检查. 此头文件包含三部分: (1).Helper类:帮助创建编译时常量的 ...
C++11中头文件atomic的使用
原子库为细粒度的原子操作提供组件,允许无锁并发编程.涉及同一对象的每个原子操作,相对于任何其他原子操作是不可分的.原子对象不具有数据竞争(data race).原子类型对象的主要特点就是从不同线程访问 ...
C++11中头文件chrono的使用
在C++11中,<chrono>是标准模板库中与时间有关的头文件.该头文件中所有函数与类模板均定义在std::chrono命名空间中. std::chrono是在C++11中引入的,是一个 ...
C++/C++11中头文件sstream介绍
C++使用标准库类来处理面向流的输入和输出:(1).iostream处理控制台IO:(2).fstream处理命名文件IO:(3).stringstream完成内存string的IO. 类fstrea ...
C++11中头文件ratio的使用
include<ratio>是在C++11中引入的,在此文件中有一些模板类. 模板类std::ratio及相关的模板类(如std::ratio_add)提供编译时有理数算术支持.此模板的每 ...
C++/C++11中头文件numeric的使用
<numeric>是C++标准程序库中的一个头文件,定义了C++ STL标准中的基础性的数值算法(均为函数模板): (1).accumulate: 以init为初值,对迭代器给出的值序列做 ...
C++/C++11中头文件algorithm的使用
<algorithm>是C++标准程序库中的一个头文件,定义了C++ STL标准中的基础性的算法(均为函数模板).<algorithm>定义了设计用于元素范围的函数集合.任何对 ...
C++/C++11中头文件iterator的使用
<iterator>是C++标准程序库中的一个头文件,定义了C++ STL标准中的一些迭代器模板类,这些类都是以std::iterator为基类派生出来的.迭代器提供对集合(容器)元素的操 ...

C++/C++11中头文件functional的使用

C++/C++11中头文件functional的使用相关推荐

最新文章

热门文章