函數對象（c++11 ）

聲明：

本文 - 禁止轉載 - 

本文所有觀點和概念都系個人總結，難免存在疏漏之處，為不至于誘導初學者誤入歧途，望各位以自己實踐為準，特此聲明。

如有錯誤請告知

概念

任何定義了函數調用操作符的對象都是函數對象

對象

作用于可調用對象和lambda表達式

● 可調用對象（callable object，是一個概念名詞）

    → 函數指針

    分為普通函數指針和類函數指針，特别是需要說明是類函數指針，直接舉例如下：

#include <functional>
#include <iostream>

class TestFuncPtr
{
public:
int print(int i)
{
	std::cout<<"func ptr "<<i<<std::endl;
	return i+1;
}
};

int main()
{
	// 定義類函數指針
   	int (TestFuncPtr::*func_ptr)(int) = &TestFuncPtr::print;
	TestFuncPtr cPtr;
	std::cout<<(cPtr.*func_ptr)(1)<<std::endl;
}
           

    總結就是在普通函數成員前加上“類名::”定義，然後通過“對象.*[類函數指針]”調用。

    → 仿函數

    指重載operate()操作符的類。

    → 可轉換為函數指針的對象。

    指重載轉換為某個函數指針類型操作符的類。

struct Bar
{
	using fr_t = void(*)(void);
	
	static void func(void)
	{
		//...
	}
	operator fr_t(void)
	{
		return func;
	}
};

int main(void)
{
	Bar bar;
	bar();
}
           

    總結就是跟仿函數類似，不同的是這種方式是先将對象轉換成函數指針，然後執行。

    PS：指向資料成員指針也是可調用對象

● lambda表達式

    連結博文

封裝器 std::function

先上例子，來個直覺感受

#include <functional>
#include <iostream>
 
struct Foo {
    Foo(int num) : num_(num) {}
    void print_add(int i) const { std::cout << num_+i << '\n'; }
    int num_;
};
 
void print_num(int i)
{
    std::cout << i << '\n';
}
 
struct PrintNum {
    void operator()(int i) const
    {
        std::cout << i << '\n';
    }
};
 
int main()
{
    // 存儲自由函數
    std::function<void(int)> f_display = print_num;
    f_display(-9);
 
    // 存儲 lambda
    std::function<void()> f_display_42 = []() { print_num(42); };
    f_display_42();
 
    // 存儲到 std::bind 調用的結果
    std::function<void()> f_display_31337 = std::bind(print_num, 31337);
    f_display_31337();
 
    // 存儲到成員函數的調用
    std::function<void(const Foo&, int)> f_add_display = &Foo::print_add;
    const Foo foo(314159);
    f_add_display(foo, 1);
    f_add_display(314159, 1);
 
    // 存儲到資料成員通路器的調用
    std::function<int(Foo const&)> f_num = &Foo::num_;
    std::cout << "num_: " << f_num(foo) << '\n';
 
    // 存儲到成員函數及對象的調用
    using std::placeholders::_1;
    std::function<void(int)> f_add_display2 = std::bind( &Foo::print_add, foo, _1 );
    f_add_display2(2);
 
    // 存儲到成員函數和對象指針的調用
    std::function<void(int)> f_add_display3 = std::bind( &Foo::print_add, &foo, _1 );
    f_add_display3(3);
 
    // 存儲到函數對象的調用
    std::function<void(int)> f_display_obj = PrintNum();
    f_display_obj(18);
}
           

其中将類方法直接指派給外部标準函數對象，請慎用，gcc下沒問題，但是同樣支援c++11标準的Visual Studio 2013卻會報錯

● 例子

    它是一個類模闆，用時需指定函數類型；

    它存儲的可調用對象或者lambda表達式，稱之為目标；

    它重載bool轉換類型操作符，通過判斷可知是否包含有效目标。

綁定器 std::bind

将可調用對象和參數綁定，并用std::function或者auto儲存

● 例子

auto lessfunc = std::bind(less<int>(), 10, std::placeholders::_1);
if (lessfunc(12))
{
    // 大于10
}
           

● 作用

    1. 降元可調用對象；

    2. 調序可調用對象。

#include <functional>
#include <algorithm>
#include <iostream>

int main()
{
    auto modulus_before = std::modulus<int>();
    auto modulus_after1 = std::bind(std::modulus<int>(), std::placeholders::_1, 3);                        // 降元
    auto modulus_after2 = std::bind(std::modulus<int>(), std::placeholders::_2, std::placeholders::_1);    // 調序
    std::cout<<modulus_before(8,3)<<modulus_after1(8)<<modulus_after2(3,8)<<std::endl;
    return 0;
}
           

    結果：222

PS：綁定參數時，用std::placeholders來決定空位參數将會屬于調用發生時的第幾個參數

bind實際應用執行個體

☀ 組合多個函數

#include <functional>
#include <algorithm>
#include <iostream>

using std::placeholders::_1;

int main()
{
    auto func = std::bind(std::logical_and<bool>(),
                          std::bind(std::greater<int>(), _1, 5),
                          std::bind(std::less<int>(), _1, 10));
    std::cout<<func(3)<<" "<<func(6)<<std::endl;
	
    return 0;
}
           

結果：（Visual Studio 2013下）

0 1

☀ 映射多個函數

#include <functional>
#include <algorithm>
#include <iostream>
#include <map>
#include <string>

// ...
using std::string;
using std::placeholders::_1;

// ...
typedef 	std::function<int(string)>	MsgHandleFuncType;

// 消息映射類
class CMsgMap
{
public:
	CMsgMap()
	{
		m_stlMsgHandleMap[1] = std::bind(&CMsgMap::HandleMsg1, this, _1);
		m_stlMsgHandleMap[2] = std::bind(&CMsgMap::HandleMsg2, this, _1);
	}
	int HandleMsg(int iMsgId, string szMsgBody)
	{
		int iRet = 0;
		
		if(m_stlMsgHandleMap.count(iMsgId))
		{
			iRet = m_stlMsgHandleMap[iMsgId](szMsgBody);
		}
		
		return iRet;
	}
	
protected:
	int HandleMsg1(string szMsgBody)
	{
		std::cout<<"Msg1: "<<szMsgBody<<std::endl;
		return 0;
	}
	int HandleMsg2(string szMsgBody)
	{
		std::cout<<"Msg2: "<<szMsgBody<<std::endl;
		return 0;
	}
	
private:
	std::map<int,MsgHandleFuncType>		m_stlMsgHandleMap;
};

// 
int main()
{
	CMsgMap msgMap;
	msgMap.HandleMsg(1,"Message 1 comes .");
	msgMap.HandleMsg(2,"Message 2 comes .");
	
	return 0;
}
           

結果：（Visual Studio 2013下）

Msg1: Message 1 comes .

Msg2: Message 2 comes .

封裝器std::mem_fn

特指指向成員指針函數對象，例如：

#include <functional>
#include <iostream>
 
struct CTestFn 
{
    void Fn() 
	{
        std::cout << "Hello, world.\n";
    }
};
 
int main() 
{
    CTestFn obj;
    auto func = std::mem_fn(&CTestFn::Fn);
    func(obj);
}
           

結果：Hello, world.

● 特點

    1.隻能用于類函數指針；

    2.無需指定函數類型。（使用它的唯一 理由）

标準函數對象

    std::plus

    std::greater

    std::less

    std::logical_and

    std::bit_and