函数指针与仿函数

/* 
 * File:   main.cpp
 * Author: Vicky.H
 *
 */
#include <cstdlib>
#include <iostream>

int cmp(const void* e1, const void* e2) {
    const int* i1 = (const int*) e1;
    const int* i2 = (const int*) e2;
    if (*i1 < *i2) {
        return -1;
    } else if (*i1 > *i2) {
        return 1;
    } else {
        return 0;
    }
}

template <typename T>
class Max {
public:
    T operator()(const T& e1, const T& e2) {
        i++;
        if (e1 > e2) {
            return e1;
        } else if (e1 < e2) {
            return e2;
        }
        return e1;
    }
    int i; /**仿函数对象中的局部状态!!!这是仿函数强大与函数指针的地方!!!*/
};

/*
 * 
 */
int main(void) {


    std::cout << "函数指针" << std::endl;

    int arr_i[] = {32, 44, 11, 23, 45, 64, 32, 12, 3, 6, 0};
    qsort(arr_i, sizeof (arr_i) / sizeof (int), sizeof (int), cmp);

    for (int i = 0; i < sizeof (arr_i) / sizeof (int); i++) {
        std::cout << arr_i[i] << std::endl;
    }

    std::cout << "---------------------------" << std::endl;


    std::cout << "仿函数" << std::endl;

    struct Add {
    public:

        Add() {
            i = 0; /**仿函数对象中的局部状态!!!*/
        }

        int operator() (const int& e1, const int& e2) {
            i++;
            return e1 + e2;
        }
        int i;
    };

    struct Del {
    public:

        Del() {
            i = 0; /**仿函数对象中的局部状态!!!*/
        }

        int operator() (const int& e1, const int& e2) {
            i--;
            return e1 - e2;
        }
        int i;
    };

    Add add; /**创建仿函数对象*/
    std::cout << add(2, 1) << std::endl;
    std::cout << add(7, 3) << std::endl;
    std::cout << "add.i = " << add.i << std::endl;

    Del del; /**创建仿函数对象*/
    std::cout << del(2, 1) << std::endl;
    std::cout << del(7, 3) << std::endl;
    std::cout << "del.i = " << del.i << std::endl;

    Del del2;
    std::cout << del2(100, 1) << std::endl;
    std::cout << "del2.i = " << del2.i << std::endl;

    std::cout << "---------------------------" << std::endl;
    std::cout << "模版仿函数" << std::endl;

    Max<int> max_int;
    std::cout << max_int(1,2) << std::endl;
    std::cout << max_int(3,2) << std::endl;

    Max<char> max_char;
    std::cout << max_char('a','b') << std::endl;
    std::cout << max_char('c','b') << std::endl;
    
    std::cout << Max<char>()('c','b') << std::endl;
    return 0;
}

函数指针
0
3
6
11
12
23
32
32
44
45
64
---------------------------
仿函数
3
10
add.i = 2
1
4
del.i = -2
99
del2.i = -1
---------------------------
模版仿函数
2
3
b
c
c

/* 
 * File:   main.cpp
 * Author: Vicky.H
 * Email:  eclipser@163.com
 */
#include <iostream>
#include <functional>
#include <algorithm>

template<typename Function, typename T>
typename Function::result_type f(Function functor, T o) { //  当然,正常情况下不会这样使用,这里仅仅表示使用使用反函数定义函数返回类型
    return functor(o);
}

struct cn_vicky_functor : public std::unary_function<int, int> {

    int operator()(int i) {
        return i + 100;
    }
};

bool less_than_7(int i) {
    return i < 7;
}

/*
 * 
 */
int main(void) {
    std::cout << f(cn_vicky_functor(), 1) << std::endl;

    std::cout << "---------------------------" << std::endl;

    int ia[] = {9, 8, 7, 6, 5, 4, 3, 2, 1};
    int* finded;
    finded = std::find_if(ia, ia + sizeof (ia) / sizeof (int), less_than_7);
    std::cout << *finded << std::endl;
    // 这种写法相对于less_than_7在时间和空间上效率更高,也更容易实现线化
    finded = std::find_if(ia, ia + sizeof (ia) / sizeof (int), std::bind2nd(std::less<int>(), 7));
    std::cout << *finded << std::endl;


    return 0;
}

请注意,这可能与正常的理解差异很大,简单的说,less_than_7函数似乎更简单,为什么比std::bind2nd(std::less<int>(), 7)在效率上更低???更多内容,可以参见<<C++程序设计语言>>(十周年纪念版) p.455以及 p.460