第24课 可变参数模板（5）_DllHelper和lambda链式调用

#ifndef _DLL_H_
#define _DLL_H_

#ifdef BUILD_DLL /* DLL export */ 
#define EXPORT __declspec(dllexport) 
#else /* EXE import */ 
#define EXPORT __declspec(dllimport) 
#endif 

#ifdef __cplusplus
extern "C"{
#endif

//求最大值
EXPORT int Max(int a, int b);

//求和
EXPORT int Sum(int a, int b);

#ifdef __cplusplus
}
#endif

#endif

View Code

#include "dll.h"

//编译动态dll库：
//gcc -Wall -shared dll.c -o Mydll.dll
//或者
//gcc --share dll.c -o Mydll.dll
//调用dll库生成exe文件：
//gcc test.c Mydll.dll -o test
#define BUILD_DLL

//求最大值
EXPORT int Max(int a, int b)
{
    return a > b ? a : b;
}

//求和
EXPORT int Sum(int a, int b)
{
    return a + b;
}

View Code

#include <windows.h>
#include <string>
#include <functional>
#include <map>
#include  <exception>
using namespace std;

class DllHelper
{
private:
    HMODULE m_hMod;

    //FARPROC宏: typedef int (FAR WINAPI *FARPROC)();
    std::map<string, FARPROC> m_map; //将己加载的函数指针保存起来
public:
    DllHelper(): m_hMod(nullptr){}

    //封装GetProcAddress，将函数指针转为std::function对象
    template<typename T>  //T为要查找的函数类型
    std::function<T> GetFunction(const string& funcName)
    {
        auto it = m_map.find(funcName); //函数是否己被载入

        if(it == m_map.end()){
            auto addr = GetProcAddress(m_hMod, funcName.c_str()); //addr为FARPROC类型

            if(!addr)
                return nullptr;

            m_map.insert(std::make_pair(funcName, addr)); //保存addr地址（FARPROC类型）
            
            it = m_map.find(funcName); //取出addr（FARPROC类型）
        }

        return std::function<T>((T*)(it->second)); //将FARPROC类型的addr强转为T类型。
    }

    //调用函数
    template<typename T, typename...Args> //T为函数类型，Args为参数列表
    typename std::result_of<std::function<T>(Args...)>::type //原函数的返回类型
    ExecuteFunc(const string& funcName, Args&&...args)
    {
        auto f = GetFunction<T>(funcName);
        if(f == nullptr){
            string s = "Can not find this function " + funcName;
            throw std::exception(runtime_error(s.c_str()));
        }

        return f(std::forward<Args>(args)...);
    }

    bool Load(const string& path)
    {
        m_hMod = LoadLibraryA(path.data());
        if(nullptr == m_hMod)
        {
            cout <<"LoadLibrary failed!" << endl;
        }

        return (m_hMod != nullptr);
    }

    bool UnLoad()
    {
        bool ret = true;
        if(m_hMod != nullptr){
            ret = FreeLibrary(m_hMod); //返回非零表示成功，零表示失败

            if(ret)
               m_hMod = nullptr;
        }

        return ret;
    }

    ~DllHelper(){UnLoad();}
};

#include <iostream>
#include <windows.h>
#include "DllHelper.hpp"
using namespace std;

//传统方法
void testDll_1()
{
    typedef int(*PMax)(int, int);
    typedef int(*PSum)(int, int);
    HINSTANCE hDll=LoadLibrary("MyDll.dll");

    if(hDll == nullptr)
        return;

    PMax Max = (PMax)GetProcAddress(hDll,"Max");
    if(Max == nullptr)
        return;

    int ret = Max(5, 8);

    cout << ret << endl;

    PSum Sum = (PSum)GetProcAddress(hDll,"Sum");
    if(Sum == nullptr)
        return;

    ret = Sum(5, 8);

    cout << ret << endl;

    FreeLibrary(hDll);        
}

//2. 利用DLLHelper类来简化调用
void testDll_2()
{
    DllHelper dh;
    dh.Load("MyDll.dll");

    cout << dh.ExecuteFunc<int(int,int)>("Max", 5, 9) << endl; //9
    cout << dh.ExecuteFunc<int(int,int)>("Sum", 4, 8) << endl; //12
}

int main()
{
    testDll_1();
    testDll_2();
    return 0;
}

#include <functional>
#include <iostream>
#include <type_traits>
using namespace std;

template <typename T> class Task; //前向声明

template<typename R, typename...Args>
class Task<R(Args...)> //R为返回值类型，Args为参数类型
{
private:
    std::function<R(Args...)> m_fn;
public:
    Task(std::function<R(Args...)>&& f) : m_fn(std::move(f)) {}
    Task(std::function<R(Args...)>& f) : m_fn(f) {}

    R Run(Args&& ...args)
    {
        return m_fn(std::forward<Args>(args)...); //完美转发
    }

    //连续调用该函数，将生成一个个新的Task。相当于将函数不断地串联起来
    //Then函数的返回值为Task<R(Args...)>类型，注意R表示返回值类型
    template<typename F>
    auto Then(F&& f)-> Task<typename std::result_of<F(R)>::type(Args...)>
    {
        //result_of<F(R)>：表示求参数为R类型的F函数的返回值类型，
        //其中的R表示上一个函数输出类型作为本F函数的输入参数类型
        using ret_type = typename std::result_of<F(R)>::type; //获取F的返回值类型

        auto func = std::move(m_fn);

        //调用Task<ret_type(Args...)>()构造函数,并将新产生的lambda保存在新Task的m_fn中。
        return Task<ret_type(Args...)>([func, f](Args...args)
        {
            //注意，这里不是将args直接传给f，即f(args...），而是先由前一个func(args...)计算结果作为f的入参。
            return f(func(std::forward<Args>(args)...));//将前一个函数的输出作为后一个函数的输入
        });
    }
};

void TestTask()
{
    Task<int(int)> task([](int i) {return i; });
    auto ret = task.Then([](int i) {return i + 1; })  
                   .Then([](int i) {return i + 2; })
                   .Then([](int i) {return i + 3; }).Run(1);  //Run的延迟调用
    cout << ret << endl; //7
}

int main()
{
    TestTask();
    return 0;
}