2. 程式人生 > >C++函數委托

C++函數委托

阿新 • • 發佈：2019-05-01
display bject int example -c 需要 sin 就是 調用函數

環境：

　　win7_x64旗艦版、VS2015企業版

場景：

　　C++標準庫提供std::function類來將一個對象的調用操作封裝在一個對象內部，然後可以委托調用，但是有一些弊端，例如下面的需求：

　　　　我們需要將調用操作封裝存儲到一個map中，來實現觀察者模式或信號槽，由於std::function是在編譯期確定類型，導致你無法將不同類型的std::function（例如std::function<void()>和std::function<void(int)>）放入同一個map中。

　　function_delegate裏就是為了解決上面的問題而寫的。

實現代碼：

function_delegate.h

技術分享圖片 
/**
* @file    function_delegate.h
* @brief   函數委托
* @author  DC
* @date    2019-04-16
* @note
* @example
*          class my_class
*          {
*          public:
*              void test(int a, double b)
*              {
*              }
*          };
*
*          my_class my;
*          function_delegate<> delegate(&my, &my_class::test);
*          delegate(1, 2.0);
*

 
*/

#ifndef FUNCTION_DELEGATE_H_
#define FUNCTION_DELEGATE_H_

namespace function_delegate_pri
{
    ///< 對象成員函數指針
    class member_ptr
    {
    public:
        ///< 哈希函數
        typedef std::_Bitwise_hash<member_ptr> hash;
        ///< 構造函數
        template<class T, class Func>
 

        member_ptr(T* obj, Func func)
        {
            obj_ = obj;
            *(Func*)&func_ = func;
        }
        ///< 小於函數
        bool operator <(const member_ptr& ptr) const
        {
            if (func_[0] != ptr.func_[0]) {
                return func_[0] < ptr.func_[0];
            }
            if (func_[1] != ptr.func_[1]) {
                return func_[1] < ptr.func_[1];
            }
            return obj_ < ptr.obj_;
        }
        ///< 相等函數
        bool operator ==(const member_ptr& ptr) const
        {
            if (func_[0] != ptr.func_[0]) {
                return false;
            }
            if (func_[1] != ptr.func_[1]) {
                return false;
            }
            return obj_ == ptr.obj_;
        }
        ///< 調用函數
        template
        <
            typename T,
            typename U,
            typename Result,
            typename ... Args
        >
        Result invoke(Args... args)
        {
            typedef Result(U::*Call)(Args...);
            Call call = *(Call*)&func_;
            return (((T*)obj_)->*call)(args...);
        }

        void* obj_{nullptr};     ///< 對象指針
        ///< 對象成員函數需要使用三個指針，C++多重虛擬繼承導致
        void* func_[3]{nullptr}; ///< 類成員函數指針
    };

    ///< 函數委托
    template<class Strategy = void>
    class delegate_impl
    {
    public:
        ///< 設置對象和成員函數
        template
        <
            typename T,
            typename U,
            typename Result,
            typename ... Args
        >
        delegate_impl(T* ptr, Result(U::*fn)(Args...)) : refcnt_(ptr), ptr_(ptr, fn)
        {
            typedef Result(*Invoke)(member_ptr*, Args...);
            Invoke call = &delegate_impl::invoke<T, U, Result, Args...>;
            invoke_ = call;
        }

        bool operator <(const delegate_impl& func) const
        {
            if (invoke_ != func.invoke_) {
                return invoke_ < func.invoke_;
            }
            return ptr_ < func.ptr_;
        }

        ///< 調用成員函數
        template
        <
            typename Result = void,
            typename ... Args
        >
        Result operator()(Args... args) const
        {
            typedef Result(*Invoke)(member_ptr*, Args...);
            Invoke call = (Invoke)invoke_;
            return call((member_ptr*)&ptr_, args...);
        }

        Strategy* object() const { return refcnt_; }

    private:
        template
        <
            typename T,
            typename U,
            typename Result,
            typename ... Args
        >
        static Result invoke(member_ptr* ptr, Args... args)
        {
            return ptr->invoke<T, U, Result>(args...);
        }

        Strategy*       refcnt_{ nullptr };   ///< 
        member_ptr    ptr_;                 ///< 成員函數指針
        void*           invoke_{ nullptr };   ///< invoke函數地址
    };

    template<>
    class delegate_impl<void>
    {
    public:
        ///< 設置對象和成員函數
        template
        <
            typename T,
            typename U,
            typename Result,
            typename ... Args
        >
        delegate_impl(T* ptr, Result(U::*fn)(Args...)) : ptr_(ptr, fn)
        {
            typedef Result(*Invoke)(member_ptr*, Args...);
            Invoke call = &delegate_impl::invoke<T, U, Result, Args...>;
            invoke_ = call;
        }

        bool operator <(const delegate_impl& func) const
        {
            if (invoke_ != func.invoke_) {
                return invoke_ < func.invoke_;
            }
            return ptr_ < func.ptr_;
        }

        ///< 調用成員函數
        template
        <
            typename Result = void,
            typename ... Args
        >
        Result operator()(Args... args) const
        {
            typedef Result(*Invoke)(member_ptr*, Args...);
            Invoke call = (Invoke)invoke_;
            return call((member_ptr*)&ptr_, args...);
        }

    private:
        template
        <
            typename T,
            typename U,
            typename Result,
            typename ... Args
        >
        static Result invoke(member_ptr* ptr, Args... args)
        {
            return ptr->invoke<T, U, Result>(args...);
        }

        member_ptr    ptr_;                 ///< 成員函數指針
        void*         invoke_{ nullptr };   ///< invoke函數地址
    };
}

using function_ptr = function_delegate_pri::member_ptr;
template<class Strategy = void>
using function_delegate = function_delegate_pri::delegate_impl<Strategy>;

#endif ///< !FUNCTION_DELEGATE_H_
View Code

測試代碼：

function_delegate_test.h

技術分享圖片 
#include <iostream>
#include <vector>
#include <functional>
#include "time_stamp.h"
#include "function_delegate.h"

namespace function_delegate_unit_test 
{
    class testa
    {
    public:
        virtual int testa1(int n)
        {
            std::cout << "testa::testa1\tparam:" << n << ", data:";
            for (int v : avec_) {
                std::cout << v << ",";
            }
            std::cout << std::endl;
            return n;
        }
        int testa2(int n)
        {
            std::cout << "testa::testa2\tparam:" << n << ", data:";
            for (int v : avec_) {
                std::cout << v << ",";
            }
            std::cout << std::endl;
            return n;
        }

    protected:
        std::vector<int> avec_{ 1, 2, 3 };
    };

    class testb
    {
    public:
        virtual int testb1(int n)
        {
            std::cout << "testb::testb1\tparam:" << n << ", data:";
            for (int v : bvec_) {
                std::cout << v << ",";
            }
            std::cout << std::endl;
            return n;
        }
        int testb2(int n)
        {
            std::cout << "testb::testb2\tparam:" << n << ", data:";
            for (int v : bvec_) {
                std::cout << v << ",";
            }
            std::cout << std::endl;
            return n;
        }

    protected:
        std::vector<int> bvec_{ 4, 5, 6 };
    };

    class testc : public testa, public testb
    {
    public:
        int testa1(int n) override
        {
            std::cout << "testc::testa1\tparam:" << n << ", data:";
            for (int v : bvec_) {
                std::cout << v << ",";
            }
            std::cout << std::endl;
            return testa::testa1(n);
        }

        int testb1(int n) override
        {
            std::cout << "testc::testb1\tparam:" << n << ", data:";
            for (int v : bvec_) {
                std::cout << v << ",";
            }
            std::cout << std::endl;
            return testb::testb1(n);
        }

        int test(int n)
        {
            std::cout << "testc::testb1\tparam:" << n << ", data:";
            for (int v : avec_) {
                std::cout << v << ",";
            }
            for (int v : bvec_) {
                std::cout << v << ",";
            }
            std::cout << std::endl;
            return n;
        }
    };

    class testd
    {
    public:
        virtual int test(int n)
        {
            std::cout << "testd::test\tparam:" << n << ", data:";
            for (int v : dvec_) {
                std::cout << v << ",";
            }
            std::cout << std::endl;
            return n;
        }
        int testd1(int n)
        {
            std::cout << "testd::testd1\tparam:" << n << ", data:";
            for (int v : dvec_) {
                std::cout << v << ",";
            }
            std::cout << std::endl;
            return n;
        }

    protected:
        std::vector<int> dvec_{ 1, 2, 3 };
    };

    class teste
    {
    public:
        virtual int test(int n)
        {
            std::cout << "teste::test\tparam:" << n << ", data:";
            for (int v : evec_) {
                std::cout << v << ",";
            }
            std::cout << std::endl;
            return n;
        }
        int teste1(int n)
        {
            std::cout << "teste::teste1\tparam:" << n << ", data:";
            for (int v : evec_) {
                std::cout << v << ",";
            }
            std::cout << std::endl;
            return n;
        }

    protected:
        std::vector<int> evec_{ 1, 2, 3 };
    };

    class testf : public virtual testd, public virtual teste
    {
    public:
        virtual int test(int n) override
        {
            std::cout << "teste::test\tparam:" << n << ", data:";
            for (int v : dvec_) {
                std::cout << v << ",";
            }
            for (int v : evec_) {
                std::cout << v << ",";
            }
            std::cout << std::endl;

            testd::test(n);
            teste::test(n);
            return n;
        }
        int testf1(int n)
        {
            std::cout << "testf::testf1\tparam:" << n << ", data:";
            for (int v : dvec_) {
                std::cout << v << ",";
            }
            for (int v : evec_) {
                std::cout << v << ",";
            }
            std::cout << std::endl;
            return n;
        }
    };

    class testg
    {
    public:
        int test(int n)
        {
            std::cout << "testg::test\tparam:" << n << ", data:";
            for (int v : gvec_) {
                std::cout << v << ",";
            }
            std::cout << std::endl;
            return n;
        }

    protected:
        std::vector<int> gvec_{ 1, 2, 3 };
    };

    ///< 單元測試
    void test()
    {
        std::cout << "function_delegate_unit_test start" << std::endl;
        ///< TEST testa
        testa a;
        {
            function_delegate<> delegate(&a, &testa::testa1);
            delegate(1000);
        }
        {
            function_delegate<> delegate(&a, &testa::testa2);
            delegate(1000);
        }

        ///< TEST testb
        testb b;
        {
            function_delegate<> delegate(&b, &testb::testb1);
            delegate(1000);
        }
        {
            function_delegate<> delegate(&b, &testb::testb2);
            delegate(1000);
        }

        ///< TEST testc
        testc c;
        {
            function_delegate<> delegate(&c, &testa::testa1);
            delegate(1000);
        }
        {
            function_delegate<> delegate(&c, &testa::testa2);
            delegate(1000);
        }
        {
            function_delegate<> delegate(&c, &testb::testb1);
            delegate(1000);
        }
        {
            function_delegate<> delegate(&c, &testb::testb2);
            delegate(1000);
        }
        {
            function_delegate<> delegate(&c, &testc::testa1);
            delegate(1000);
        }
        {
            function_delegate<> delegate(&c, &testc::testa2);
            delegate(1000);
        }
        {
            function_delegate<> delegate(&c, &testc::testb1);
            delegate(1000);
        }
        {
            function_delegate<> delegate(&c, &testc::testb2);
            delegate(1000);
        }
        {
            function_delegate<> delegate(&c, &testc::test);
            delegate(1000);
        }

        ///< TEST testd
        testd d;
        {
            function_delegate<> delegate(&d, &testd::testd1);
            delegate(1000);
        }
        {
            function_delegate<> delegate(&d, &testd::test);
            delegate(1000);
        }

        ///< TEST teste
        teste e;
        {
            function_delegate<> delegate(&e, &teste::teste1);
            delegate(1000);
        }
        {
            function_delegate<> delegate(&e, &teste::test);
            delegate(1000);
        }

        ///< TEST testf
        testf f;
        {
            function_delegate<> delegate(&f, &testd::testd1);
            delegate(1000);
        }
        {
            function_delegate<> delegate(&f, &testd::test);
            delegate(1000);
        }
        {
            function_delegate<> delegate(&f, &teste::teste1);
            delegate(1000);
        }
        {
            function_delegate<> delegate(&f, &teste::test);
            delegate(1000);
        }
        {
            function_delegate<> delegate(&f, &testf::testd1);
            delegate(1000);
        }
        {
            function_delegate<> delegate(&f, &testf::teste1);
            delegate(1000);
        }
        {
            function_delegate<> delegate(&f, &testf::test);
            delegate(1000);
        }

        ///< TEST testg
        testg g;
        {
            function_delegate<> delegate(&g, &testg::test);
            delegate(1000);
        }
        std::cout << "function_delegate_unit_test end" << std::endl;
    }
}

namespace function_delegate_efficiency_test
{
    class testa
    {
    public:
        int test(int n)
        {
            return n + 1;
        }
    };

    class testb
    {
    public:
        virtual int test(int n)
        {
            return n + 1;
        }
    };
    class testc : public testb
    {
    public:
        int test(int n) override
        {
            return n + 2;
        }
    };

    ///< 性能測試
    void test(int count)
    {
        std::cout << "function_delegate_efficiency_test start" << std::endl;
        testa a;
        {
            time_stamp ts;
            for (int i = 0; i < count; ++i) {
                a.test(i);
            }
            double tm = ts.milliseconds();
            std::cout << "count:" << count << "\tc++ object call:\t\t" << tm << "(ms)" << std::endl;
        }
        {
            time_stamp ts;
            std::function<int(int)> func = std::bind(&testa::test, &a, std::placeholders::_1);
            for (int i = 0; i < count; ++i) {
                func(i);
            }
            double tm = ts.milliseconds();
            std::cout << "count:" << count << "\tstd::function call:\t\t" << tm << "(ms)" << std::endl;
        }
        {
            time_stamp ts;
            function_delegate<> delegate(&a, &testa::test);
            for (int i = 0; i < count; ++i) {
                delegate(i);
            }
            double tm = ts.milliseconds();
            std::cout << "count:" << count << "\tdelegate call:\t\t\t" << tm << "(ms)" << std::endl;
        }

        testc c;
        testb* pb = &c;
        {
            time_stamp ts;
            for (int i = 0; i < count; ++i) {
                pb->test(i);
            }
            double tm = ts.milliseconds();
            std::cout << "count:" << count << "\tc++ pointer virtual call:\t" << tm << "(ms)" << std::endl;
        }
        {
            time_stamp ts;
            std::function<int(int)> func = std::bind(&testb::test, pb, std::placeholders::_1);
            for (int i = 0; i < count; ++i) {
                func(i);
            }
            double tm = ts.milliseconds();
            std::cout << "count:" << count << "\tstd::function virtual call:\t" << tm << "(ms)" << std::endl;
        }
        {
            time_stamp ts;
            function_delegate<> delegate(pb, &testb::test);
            for (int i = 0; i < count; ++i) {
                delegate(i);
            }
            double tm = ts.milliseconds();
            std::cout << "count:" << count << "\tdelegate virtual call:\t\t" << tm << "(ms)" << std::endl;
        }
        std::cout << "function_delegate_efficiency_test end" << std::endl;
    }
}
View Code

　　1）其中time_stamp.h包含一個計時類time_stamp的實現，這裏沒貼代碼，可以自己實現。

　　2）function_delegate類使用成員data_[0]、data_[1]和data_[2]存儲成員函數指針是為了處理被委托的類存在多重繼承的情況（用於動態調整this指針，編譯器自動調整），如果只使用一個void*存儲會發生崩潰。

　　註意：這裏有個奇怪的現象，對於使用虛擬繼承類成員函數，在我的臺式機上測試只需要使用data_[0]和data_[1]即可，而在我的筆記本上測試需要使用data_[0]、data_[1]和data_[2] ，所以我統一使用data_[3]存儲。

擴展：

　　1）function_delegate類可以用於實現觀察者模式和信號槽等，後面會有單獨的文章說明。

　　2）關於C++ 成員函數指針使用兩個void*存儲的原因：https://www.oschina.net/translate/wide-pointers?cmp

C++函數委托

相關推薦

C++函數委托

display bject int example -c 需要 sin 就是 調用函數 環境： 　　win7_x64旗艦版、VS2015企業版 場景： 　　C++標準庫提供std::function類來將一個對象的調用操作封裝在一個對象內部，然後可以委托調用，但是有一

C#調用C++函數,類型的已垃圾回收委托進行了回調

tar pri sys 編程 tac 丟失 delegate vda 數據 由於項目需要,C#需要調用C++的庫進行編程. 今天在調試的過程中,突然彈出 ....... 類型的已垃圾回收委托進行了回調。這可能會導致應用程序崩潰、損壞和數據丟失。向非托管代碼傳遞委托時，托

C#一個關於委托和事件通俗易懂的例子

args logs class [] 提示 delegate event lin spa 1 using System; 2 3 namespace Test 4 { 5 public class 室友 6 { 7 publ

C++函數的三種傳遞方式為：值傳遞、指針傳遞和引用傳遞

否則 方式 指針 指向 out 數據結構 logs 形參 使用 C++函數的三種傳遞方式為：值傳遞、指針傳遞和引用傳遞 值傳遞： void fun(int x){ x += 5; //修改的只是y在棧中copy x，x只是y的一個副本，在內存中重新開辟的一塊臨時空間把y

C++函數

int enter 值類型 nbsp 求和 div 方法 std 實現 C++函數 一、函數簡介 函數就是方法，就是為了實現具體功能的一段代碼 二、函數結構 返回值類型 函數名(參數列表){ 　　函數體　　 } //求和函數 int sum(int a,int b){

深刻理解：C#中的委托、事件

java 定義 ret 指定 and net 泛型 pan sub C#中的事件還真是有點繞啊，以前用JavaScript的我，理解起來還真是廢了好大勁！剛開始還真有點想不明白為什麽這麽繞，想想和JS的區別，最後終於恍然大悟！ C#中事件繞的根本原因： C#的方法，它不是

Python 調用C函數

程序 nand test 訪問 sam -s nan shel style /******************************************************************** * P

QML 調用 C++ 函數不生效問題

現在 情況 數據轉換 但是 類型 崩潰 被調用 生效 無法 　　在 QML 中，有時候會出現在調用 C++ 函數無法生效的問題，在 QML 的 JavaScript 代碼中已經運行了該段代碼，函數已經被調用，但是 C++ 函數沒反應，程序既不報錯也不崩潰的情況。這種時候可能

C++函數傳遞數組的兩種方式

mes 維數 二維 傳遞 獲得 arr [] 長度 clas 數組與指針。 傳首地址過去，然後通過地址輸出數組元素。 1、一維數組 #include<iostream> using namespace std; #include <cstring>

sqlserver 運行正則表達式，調用c# 函數、代碼

exp pan net hit ng- 創建 val put creat --1.新建SqlServerExt項目,編寫 C# 方法生成 SqlServerExt.dll 文件 using System; using System.Data; usin

讓我們把KBEngine玩壞吧！如何定制我們自己的C++函數（一）

data ase erro glob alt ins sin 程序 all 為什麽不更新kbe warring的代碼解讀了，因為在我看來那個demo講完了實體就沒東西可講了，如果專心的看官方文檔和PPT的話demo的代碼後面沒任何難點了已經，單純的復制黏貼代碼實在太過無聊。

在C 函數中保存狀態：registry、reference和upvalues

targe 閉包 一個 兩個 table chang detail chan 這樣的 在C函數中保存狀態：registry、reference和upvalues C函數能夠通過堆棧來和Lua交換數據，但有時候C函數須要在函數體的作用域之外保存某些Lua數

C#函數的使用方法

存在 步驟 例子 stat logs font 參數類型 color 及其 函數不管在哪個語言中都是及其重要的一環，無論是怎樣的程序都是由或多或少的函數組合起來的。一個函數的使用，分為聲明和調用兩個步驟。 函數的聲明 static 返回類型 函數名(參數列表) {

c++ 函數（1）

row 引用傳參 修飾 尋址 概念 pan 但是 clu 過去 函數中，數組如何傳參？ 整個數組傳過去是不可以的。自然聯想到指針和引用。 因為數組指針本質上就是多重指針，所以以下三種傳參方式都是可以的： void print(const int*); v

c++ 函數（3）函數的返回值

pty code else 傳參 man span 錯誤 turn nbsp 函數的返回和函數的傳參恰恰相反，它是通過返回值來初始化外層的臨時變量。 不要返回函數內部對象的引用或指針 const string &manip(){ string ret;

C++函數返回局部變量

接口 blog 數組名 結束 要求 地址 比較 一個 cde 函數不能返回指向棧內存的指針 原因：返回值是拷貝值，局部變量的作用域為函數內部，函數執行結束，棧上的局部變量會銷毀，內存釋放。 可返回的局部變量： 1. 返回局部變量本身 int sum(

Step By Step(Lua調用C函數)

extern lua環境 class 數量 lsp 相同 虛擬 c語言代碼 cti 原文: http://www.cnblogs.com/stephen-liu74/archive/2012/07/23/2469902.html Lua可以調用C函數的能力將極大的提高Lu

Lua 調用的 C 函數保存 state 的兩種方式: Storing State in C Functions 筆記

.com 包裝 ram targe cti gist 方式 機制 key http://yanbin.is-programmer.com/posts/94214.html Registery的Key 1. 整數Key用於Lua的引用機制，所以不要使用整數作為Key

N001-認知C#中的委托

.net ref 如何 相關 表達 參數類型 類型安全 一個 func 本章包含的如下認知內容： 委托概述 如何聲明委托？ 如何使用委托？

C++函數重載

c++函數重載1、函數重載：函數名相同、作用在同一作用域、參數可不相同。例子：#include <iostream> #include<stdlib.h> using namespace std; int getMax(int i,int j){ int max=0; if(i&g