c语言中的stl模板指针,C++进阶：STL仿函数总结

1. 概念

模仿函数的类，使用方式如同函数。本质是类中重载括弧运算符operator()。

2. 场景

不同函数复用相同处理代码。

3. 使用

3.1 C语言的处理方式

使用函数指针和回调函数来实现代码复用。例如qsort()

#include

#include

int arr_sort( const void *a, const void *b) {

return *(int*)a-*(int*)b;

}

int main() {

int arr[5] = { 4, 1, 2, 5, 6 };

qsort(arr, 5, sizeof(arr[0]), arr_sort);

int i;

for (i = 0; i < 5; i++){

printf("%i\n", arr[i]);

}

return 0;

}

3.2 C++语言的处理方式

函数指针方式

#include

#include

using namespace std;

inline bool Sort(int a,int b){

return a > b;

}

inline void Display(int a){

cout << a << endl;

}

int main() {

int arr[5] = { 4, 1, 2, 5, 6 };

sort(arr, arr+5,Sort);

for_each(arr,arr+5,Display);

return 0;

}

函数模板方式

#include

#include

using namespace std;

template

inline bool Sort(T const& a,T const& b){

return a > b;

}

template

inline void Display(T a){

cout << a << endl;

}

int main() {

int arr[5] = { 4, 1, 2, 5, 6 };

sort(arr, arr+5,Sort);

for_each(arr,arr+5,Display);

return 0;

}

仿函数方式

class Sort{

public:

bool operator()(int a,int b) const {

return a > b;

}

};

class Display{

public:

void operator()(int a) const{

cout << a << endl;

}

};

int main()

{

int arr[5] = { 4, 1, 2, 5, 6 };

sort(arr, arr+5,Sort());

for_each(arr,arr+5,Display());

return 0;

}

4.仿函数模板方式

template

class Sort{

public:

inline bool operator()(T const& a,T const& b) const {

return a > b;

}

};

template

class Display{

public:

inline void operator()(T const& a) const{

cout << a << endl;

}

};

int main()

{

int arr[5] = { 4, 1, 2, 5, 6 };

sort(arr, arr+5,Sort());

for_each(arr,arr+5,Display());

return 0;

}

STL的仿函数

在头文件中定义了如下三类仿函数：

1. 算术类仿函数

操作

仿函数

加

plus

减

minus

乘

multiplies

除

divides

取模

modulus

取反

negate

使用实例1

累积相乘

#include

#include // accumulate

#include //

using namespace std;

int main(){

int arr[]={1,2,3,4,5};

vector iv(ia,ia+5);

cout<< accumulate(iv.begin(),iv.end(),1,multiplies()) <

return 0;

}

Boost lambda表达式

cout<< accumulate(iv.begin(),iv.end(),1,_1*_2) <

使用实例2

两个数组对应元素相加

#include

#include // for_each() transform()

#include

using namespace std;

inline void Print(int a){

cout << a << endl;

}

int main(){

int first[]={1,2,3,4,5};

int second[]={10,20,30,40,50};

int results[5];

transform (first, first+5, second, results, std::plus());

for_each(results,results+5,Print);

return 0;

}

Boost lambda表达式

transform (first, first+5, second, results, _1+_2);

基本实现

template

struct plus{

T operator()(int a,int b){

return a+b;

}

};

template

struct multiplies{

T operator()(int a,int b){

return a*b;

}

};

2. 关系运算类仿函数

操作

仿函数

等于

equal_to

不等于

not_equal_to

大于

greater

大于等于

greater_equal

小于

less

小于等于

less_equal

使用实例

降序排序

#include

#include // for_each() sort()

#include

using namespace std;

inline void Print(int a){

cout << a << endl;

}

int main(){

int arr[]={1,2,3,4,5};

sort(arr,arr+5,greater());

for_each(arr,arr+5,Print);

return 0;

}

Boost lambda表达式

sort(arr,arr+5,_1>_2);

基本实现

template

struct greater{

bool operator()(const T& a,const T& b){

return a>b;

}

};

template

struct less{

bool operator()(const T& a,const T& b){

return a

}

};

3. 逻辑运算仿函数

操作

仿函数

逻辑与

logical_and

逻辑或

logical_or

逻辑否

logical_not

使用实例

布尔数组整体取反

#include // cout, boolalpha

#include // std::logical_not

#include // std::transform

using namespace std;

inline void Print(bool a){

cout << a << endl;

}

int main () {

bool values[] = {true,false,true,false};

transform (values, values+4, values, logical_not());

cout.flags(ios::boolalpha);

for_each(values, values+4,Print);

return 0;

}

Boost lambda表达式

transform (values, values+4, values, !_1);

使用实例

两个布尔数组对应元素相与

#include // cout, boolalpha

#include // std::logical_not

#include // std::transform

using namespace std;

inline void Print(bool a){

cout << a << endl;

}

int main () {

bool values1[] = {true,false,true,false};

bool values2[] = {false,true,false,true};

bool result[4];

transform(values1, values1+4,values2, result, logical_and());

cout.flags(ios::boolalpha);

for_each(result,result+4,Print);

return 0;

}

Boost lambda表达式

transform(values1, values1+4,values2, result, _1 and _2);