15). 回调模板函数/回调模板成员函数，回调参数个数和类型不固定，消除类似代码

最新推荐文章于 2023-01-18 11:19:54 发布
置顶 最新推荐文章于 2023-01-18 11:19:54 发布
阅读量1.3k 收藏
点赞数 1
文章标签： C++ 泛型 源代码 泛型编程　算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Tonny0832/article/details/41621173
版权

完整的源代码及用法测试代码可以在我的资源中去下载.


C++语法不支持模板函数/模板成员函数作为回调函数，同时把运行期代码向编译期代码转换也只有switch...case或者if..else能够实现。

如果case比较多的时候，代码非常臃肿，而且类似的大片代码中，往往只有一个参数的不同，其它都是相同的。这对于用户来说，都是一个大量的重复性的hard-code性的负担，而且也容易导致出错。


本库采用了封装，可以把运行性的switch...case/if..else分支选择转换为编译期的代码，支持模板函数的回调，并且支持最多6个可变参数（可以简易扩充参数个数），从而可以大幅度地减少代码量，(代码量可以减少到原代码的1/N，N为case数目)。并且由于是编译期代码，从而保证不会出错(出错将导致编译失败)。


并且附带提供了CEnumRange，可以检测一个枚举值是否在枚举范围内。


namespace UnitTest
{
    template<SeqEunm TVal>
    bool globalEnumFunc(int a,char* pStr)
    {
        printf("globalEnumFunc [%d],param=%d,%s",TVal+1,a,pStr?pStr:"NULL");
        return true;
    }
    Declare_Template_Global_CallBack(globalEnumFunc,globalEnumFunc);


    struct CNonSeqEunmInterface_1
    {
        CNonSeqEunmInterface_1(int p) : m_bResult(false),m_param(p){};


        template<NonSeqEunm TVal>
        void execute()
        {
            dbgOutput(TXT("\n\n[NonSeqEunm]Enum value is %d."),TVal);
            dbgOutput(TXT("\n[CEnumInterface_1::execute] %d\n"),TVal);
            m_bResult = (TVal+m_param) > NS_Val_Max;
        }


        bool m_bResult;
        int m_param;
    };
    Declare_Template_Global_CallBack(CNonSeqEunmInterface_1,::UnitTest::CNonSeqEunmInterface_1::execute);


    struct CNonSeqEunmInterface_2
    {
        CNonSeqEunmInterface_2(VCHAR* pStr) : m_bResult(false),m_pStr(pStr){};


        template<NonSeqEunm TVal>
        void execute()
        {
            dbgOutput(TXT("\n\n[NonSeqEunm]Enum value is %d."),TVal);
            dbgOutput(TXT("\n[CEnumInterface_2::execute] %s %d\n"),m_pStr,TVal);
            m_bResult = (TVal+2) > NS_Val_Max;
        }


        bool m_bResult;
        VCHAR* m_pStr;
    };
    Declare_Template_Global_CallBack(CNonSeqEunmInterface_2,::UnitTest::CNonSeqEunmInterface_2::execute);


    struct CSeqEunmInterface_1
    {
        CSeqEunmInterface_1(int p) : m_bResult(false),m_param(p){};


        template<SeqEunm TVal>
        void execute()
        {
            dbgOutput(TXT("\n\n[SeqEunm]Enum value is %d."),TVal);
            dbgOutput(TXT("\n[CSeqEunmInterface_1::execute] %d\n"),TVal);
            m_bResult = (TVal+m_param) > NS_Val_Max;
        }


        bool m_bResult;
        int m_param;
    };
    Declare_Template_Global_CallBack(CSeqEunmInterface_1,::UnitTest::CSeqEunmInterface_1::execute);


    struct CSeqEunmInterface_2
    {
        CSeqEunmInterface_2(VCHAR* pStr) : m_bResult(false),m_pStr(pStr){};


        template<SeqEunm TVal>
        void execute()
        {
            dbgOutput(TXT("\n\n[SeqEunm]Enum value is %d."),TVal);
            dbgOutput(TXT("\n[CSeqEunmInterface_2::execute] %s %d\n"),m_pStr,TVal);
            m_bResult = (TVal+2) > NS_Val_Max;
        }


        bool m_bResult;
        VCHAR* m_pStr;
    };
    Declare_Template_Global_CallBack(CSeqEunmInterface_2,::UnitTest::CSeqEunmInterface_2::execute);


    class CTestEnumSuite
    {


    public:
        template<NonSeqEunm TVal>
        bool printEnum()
        {
            outputTxt((TXT("CTestEnumSuite::printEnum [%d]\n"),TVal));
            return true;
        }


        template<SeqEunm TVal>
        bool printNext()
        {
            outputTxt((TXT("CTestEnumSuite::printNext [%d]\n"),TVal+1));
            return true;
        }


        template<SeqEunm TVal>
        void inOutParam(char p1,int& outParam)
        {
            outputTxt((TXT("CTestEnumSuite::inOutParam [%d]\n"),TVal+1));
            outParam = p1+2;
        }


        template<SeqEunm TVal>
        int getReturnValue(char p1,int outParam)
        {
            outputTxt((TXT("CTestEnumSuite::inOutParam [%d]\n"),TVal+1));
            return outParam+p1+TVal+4;
        }


        template<SeqEunm TVal>
        bool print2Param(int a,char* pStr)
        {
            printf("CTestEnumSuite::print2Param [%d],param=%d,%s\n",TVal+1,a,pStr?pStr:"NULL");
            return true;
        }


        Declare_Template_Global_CallBack(printEnum,::UnitTest::CTestEnumSuite::printEnum );
        Declare_Template_Global_CallBack(printNext,::UnitTest::CTestEnumSuite::printNext );
        Declare_Template_Global_CallBack(print2Param,::UnitTest::CTestEnumSuite::print2Param );
        Declare_Template_Global_CallBack(inOutParam,::UnitTest::CTestEnumSuite::inOutParam );
        Declare_Template_Global_CallBack(getReturnValue,::UnitTest::CTestEnumSuite::getReturnValue );


        void testEntry()
        {
            int a = 5;
            char* pStr = "in testEntry";
            srand( (unsigned)time( NULL ) );            


            typedef CTraverseTypeSet<SeqEnumRange,false>       SeqEnumRange0;
            typedef CTraverseTypeSet<SeqEnumRange,true>        SeqEnumRange1;
            typedef CTraverseTypeSet<NonSeqEnumRange,false>    NonSeqEnumRange0;
            typedef CTraverseTypeSet<NonSeqEnumRange,true>     NonSeqEnumRange1;




            //test member function
            typedef bool (CTestEnumSuite::*pNoParam)();
            typedef bool (CTestEnumSuite::*pMemParam2)(int,char*);


            ASSERT_AND_LOG((NonSeqEnumRange0::applyTester<>::execute<Callback_printEnum<pNoParam> >(NS_Val_5,makeParamPackage_Ref(*this))));
            ASSERT_AND_LOG((NonSeqEnumRange1::applyTester<>::execute<Callback_printEnum<pNoParam> >(NS_Val_5,makeParamPackage_Ref(*this))));
            ASSERT_AND_LOG((SeqEnumRange0::applyTester<>::execute<Callback_printNext<pNoParam> >(S_Val_3,makeParamPackage_Ref(*this))));


            ParmPackage<CTestEnumSuite&,int,char*>  params_print2Param(*this,a,pStr);
            ASSERT_AND_LOG((SeqEnumRange1::applyTester<>::execute<Callback_print2Param<pMemParam2> >(S_Val_6,params_print2Param)));


            //test foreach
            SeqEnumRange1::forEach<Callback_print2Param<pMemParam2> >(params_print2Param);


            //test in-out parameter            
            char p1 = 3;
            int outP = 6;
            typedef void (CTestEnumSuite::*pParam2ci)(char,int&);
            ParmPackage<CTestEnumSuite&,char,int&>  params_inOutParam(*this,p1,outP);
            ASSERT_AND_LOG((SeqEnumRange0::applyTester<>::execute<Callback_inOutParam<pParam2ci> >(S_Val_5,params_inOutParam)));
            ASSERT_AND_LOG((p1+2)==outP);
            ASSERT_AND_LOG(SeqEnumRange1::applyTester<>::execute<Callback_inOutParam<pParam2ci> >(S_Val_5,makeParamPackage_Ref(*this,p1,outP)));
            ASSERT_AND_LOG((p1+2)==outP);


            typedef int (CTestEnumSuite::*pGetRetVal)(char,int);
            ASSERT_AND_LOG((p1+outP+S_Val_5+4)==SeqEnumRange1::applyTester<>::execute<Callback_getReturnValue<pGetRetVal> >(S_Val_5,params_inOutParam,-1));


            pGetRetVal pf=SeqEnumRange1::applyTester<>::getFuncAddr<Callback_getReturnValue<pGetRetVal> >(S_Val_5);
            ASSERT_AND_LOG(pf);
            pf=SeqEnumRange1::applyTester<>::getFuncAddr<Callback_getReturnValue<pGetRetVal> >(S_Val_4);
            ASSERT_AND_LOG(!pf);   //S_Val_4 is skipped


            stlMap<NonSeqEunm,pNoParam> rMap10;
            ASSERT_AND_LOG((NonSeqEnumRange0::applyFuncIdGenerator<>::getAllFuncAddr<Callback_printEnum<pNoParam> >(rMap10)));
            ASSERT_AND_LOG(CGetEnumRangeSize<NonSeqEnumRange>::value==rMap10.size());


            stlMap<NonSeqEunm,pNoParam> rMap11;
            ASSERT_AND_LOG((NonSeqEnumRange1::applyFuncIdGenerator<>::getAllFuncAddr<Callback_printEnum<pNoParam> >(rMap11)));
            ASSERT_AND_LOG(rMap10 ==rMap11 );


            stlMap<SeqEunm,pParam2ci> rMap20;
            ASSERT_AND_LOG((SeqEnumRange0::applyFuncIdGenerator<>::getAllFuncAddr<Callback_inOutParam<pParam2ci> >(rMap20)));


            stlMap<SeqEunm,pParam2ci> rMap21;
            ASSERT_AND_LOG((SeqEnumRange1::applyFuncIdGenerator<>::getAllFuncAddr<Callback_inOutParam<pParam2ci> >(rMap21)));
            ASSERT_AND_LOG(rMap20 ==rMap21 );


            stlMap<SeqEunm,pParam2ci> rMap21New;
            ASSERT_AND_LOG((SeqEnumRange1::applyFuncIdGenerator<>::getAllFuncAddr<Callback_inOutParam<pParam2ci> >(rMap21New)));
            ASSERT_AND_LOG(rMap20 ==rMap21New );


            ASSERT_AND_LOG((NonSeqEnumRange0::applyTester<>::execute<Callback_printEnum<pNoParam> >(NS_Val_5,makeParamPackage_Ref(*this))));
            ASSERT_AND_LOG((NonSeqEnumRange1::applyTester<>::execute<Callback_printEnum<pNoParam> >(NS_Val_5,makeParamPackage_Ref(*this))));


            //test global function
            typedef bool (*pGlobalParam2)(int,char*);
            ParmPackage<int,char*>  params_globalEnumFunc(a,pStr);
            ASSERT_AND_LOG((SeqEnumRange0::applyTester<>::execute<Callback_globalEnumFunc<pGlobalParam2> >(S_Val_Min,params_globalEnumFunc)));
            ASSERT_AND_LOG((SeqEnumRange1::applyTester<>::execute<Callback_globalEnumFunc<pGlobalParam2> >(S_Val_Max,makeParamPackage_Ref(a,pStr))));
            ASSERT_AND_LOG(!(SeqEnumRange0::applyTester<>::execute<Callback_globalEnumFunc<pGlobalParam2> >(SeqEunm(S_Val_Max+1),params_globalEnumFunc)));
        }
    };


    //
    inline void TestCase_traverseTypeSet()
    {
        PrintTestcase();


        CNonSeqEunmInterface_1 nsCallObj_1(rand()%NS_Val_Max);
        CNonSeqEunmInterface_2 nsCallObj_2(TXT("I am CEnumInterface_2 :"));
        CSeqEunmInterface_1 sCallObj_1(rand()%S_Val_Max);
        CSeqEunmInterface_2 sCallObj_2(TXT("I am CSeqEunmInterface_2 :"));


        CTestEnumSuite testObj;
        testObj.testEntry();


        typedef CTraverseTypeSet<SeqEnumRange,false>       SeqEnumRange0;
        typedef CTraverseTypeSet<SeqEnumRange,true>        SeqEnumRange1;
        typedef CTraverseTypeSet<NonSeqEnumRange,false>    NonSeqEnumRange0;
        typedef CTraverseTypeSet<NonSeqEnumRange,true>     NonSeqEnumRange1;


        outputTxt(( SeqEnumRange0::dump().c_str() ));
        outputTxt(( SeqEnumRange1::dump().c_str() ));
        outputTxt(( NonSeqEnumRange0::dump().c_str() ));
        outputTxt(( NonSeqEnumRange1::dump().c_str() ));
        outputTxt(( CTraverseTypeSet<SeqEnumSkipOneRange,true>::dump().c_str() ));
        outputTxt(( CTraverseTypeSet<SeqEnumSkipOneRange,false>::dump().c_str() ));


        //test MiniMPL.CTraverseEnum.execute
        typedef void (CNonSeqEunmInterface_1::*pNoParamN11)();
        typedef void (CSeqEunmInterface_1::*pNoParamS11)();


        pNoParamS11 pf = SeqEnumRange1::applyTester<>::getFuncAddr<Callback_CSeqEunmInterface_1<pNoParamS11> >(S_Val_5);
        ASSERT_AND_LOG( &CSeqEunmInterface_1::execute<S_Val_5> == SeqEnumRange1::applyTester<>::getFuncAddr<Callback_CSeqEunmInterface_1<pNoParamS11> >(S_Val_5));
        ASSERT_AND_LOG( &CSeqEunmInterface_1::execute<S_Val_3> != SeqEnumRange1::applyTester<>::getFuncAddr<Callback_CSeqEunmInterface_1<pNoParamS11> >(S_Val_5));


        ASSERT_AND_LOG((NonSeqEnumRange1::applyTester<>::execute<Callback_CNonSeqEunmInterface_1<pNoParamN11> >(NS_Val_5,makeParamPackage_Ref(nsCallObj_1))));                    //test OK case
        ASSERT_AND_LOG((NonSeqEnumRange0::applyTester<>::execute<Callback_CNonSeqEunmInterface_1<pNoParamN11> >(NS_Val_5,makeParamPackage_Ref(nsCallObj_1))));                   //test OK case
        ASSERT_AND_LOG((SeqEnumRange1::applyTester<>::execute<Callback_CSeqEunmInterface_1<pNoParamS11> >(S_Val_5,makeParamPackage_Ref(sCallObj_1))));                               //test OK case
        ASSERT_AND_LOG((SeqEnumRange0::applyTester<>::execute<Callback_CSeqEunmInterface_1<pNoParamS11> >(S_Val_5,makeParamPackage_Ref(sCallObj_1))));                               //test OK case


        //test MiniMPL.CTraverseEnum.executeFrom 
        typedef void (CNonSeqEunmInterface_2::*pNoParamN21)();
        typedef void (CSeqEunmInterface_2::*pNoParamS21)();


        ASSERT_AND_LOG((NonSeqEnumRange1::applyTester<>::executeFrom<NonSeqEunm,NS_Val_1,Callback_CNonSeqEunmInterface_2<pNoParamN21> >(NS_Val_3,makeParamPackage_Ref(nsCallObj_2))));      //test OK case
        ASSERT_AND_LOG((NonSeqEnumRange0::applyTester<>::executeFrom<NonSeqEunm,NS_Val_5,Callback_CNonSeqEunmInterface_2<pNoParamN21> >(NS_Val_3,makeParamPackage_Ref(nsCallObj_2))));     //test OK case
        ASSERT_AND_LOG((SeqEnumRange1::applyTester<>::executeFrom<SeqEunm,S_Val_1,Callback_CSeqEunmInterface_2<pNoParamS21> >(S_Val_3,makeParamPackage_Ref(sCallObj_2))));                  //test OK case
        ASSERT_AND_LOG((SeqEnumRange0::applyTester<>::executeFrom<SeqEunm,S_Val_5,Callback_CSeqEunmInterface_2<pNoParamS21> >(S_Val_3,makeParamPackage_Ref(sCallObj_2))));                 //test OK case


        #if defined(_MSC_VER) && (WINVER >= 0x0500)
            #pragma push_macro("Assert_Trigger")
            #pragma push_macro("ChkExceptionThrow")
            #undef Assert_Trigger
            #define Assert_Trigger()          0
            #undef ChkExceptionThrow
            #define ChkExceptionThrow()       0
        #endif //end defined(_MSC_VER)


        ASSERT_AND_LOG((NonSeqEnumRange1::applyTester<>::execute<Callback_CNonSeqEunmInterface_1<pNoParamN11> >(NonSeqEunm(NS_Val_Max+2),makeParamPackage_Ref(nsCallObj_1))));   //test Failure case because DemoEunm(NS_Val_Max+2) is not in range
        ASSERT_AND_LOG((NonSeqEnumRange0::applyTester<>::execute<Callback_CNonSeqEunmInterface_1<pNoParamN11> >(NonSeqEunm(NS_Val_Min-2),makeParamPackage_Ref(nsCallObj_1))));  //test Failure case because DemoEunm(NS_Val_Min-2) is not in range
        ASSERT_AND_LOG((SeqEnumRange1::applyTester<>::execute<Callback_CSeqEunmInterface_1<pNoParamS11> >(SeqEunm(S_Val_Max+2),makeParamPackage_Ref(sCallObj_1))));                  //test Failure case because DemoEunm(S_Val_Max+2) is not in range
        ASSERT_AND_LOG((SeqEnumRange0::applyTester<>::execute<Callback_CSeqEunmInterface_1<pNoParamS11> >(SeqEunm(S_Val_Min-2),makeParamPackage_Ref(sCallObj_1))));                 //test Failure case because DemoEunm(S_Val_Min-2) is not in range


        ASSERT_AND_LOG((NonSeqEnumRange1::applyTester<>::executeFrom<NonSeqEunm,NS_Val_5,Callback_CNonSeqEunmInterface_2<pNoParamN21> >(NS_Val_3,makeParamPackage_Ref(nsCallObj_2))));      //test Failure case because traverse from NS_Val_5. (NS_Val_3 < NS_Val_5)
        ASSERT_AND_LOG((NonSeqEnumRange0::applyTester<>::executeFrom<NonSeqEunm,NS_Val_1,Callback_CNonSeqEunmInterface_2<pNoParamN21> >(NS_Val_3,makeParamPackage_Ref(nsCallObj_2))));     //test Failure case because reversed traverse from NS_Val_1. (NS_Val_1 < NS_Val_3)
        ASSERT_AND_LOG((SeqEnumRange1::applyTester<>::executeFrom<SeqEunm,S_Val_5,Callback_CSeqEunmInterface_2<pNoParamS21> >(S_Val_3,makeParamPackage_Ref(sCallObj_2))));                  //test Failure case because traverse from S_Val_5. (S_Val_3 < S_Val_5)
        ASSERT_AND_LOG((SeqEnumRange0::applyTester<>::executeFrom<SeqEunm,S_Val_1,Callback_CSeqEunmInterface_2<pNoParamS21> >(S_Val_3,makeParamPackage_Ref(sCallObj_2))));                 //test Failure case because reversed traverse from S_Val_1. (S_Val_1 < S_Val_3)


        #if defined(_MSC_VER) && (WINVER >= 0x0500)
            #pragma pop_macro("Assert_Trigger")
            #pragma pop_macro("ChkExceptionThrow")
        #endif //end defined(_MSC_VER)
    }


#ifdef RUN_EXAMPLE_TRAVERSEENUM
    InitRunFunc(showUsage_traverseEnum);
#endif  //RUN_EXAMPLE_TRAVERSEENUM
}


#endif // COMPILE_EXAMPLE_TRAVERSEENUM


#endif // __test_TRAVERSEENUM_h_

shenxiaolong1976
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++回调函数的2个DEMO程序，整理修改by唐太咸
09-22
这里面有两个运用回调函数的DEMO程序 1.其中tcCallBack的作用是希望通过将Receiver类的成员函数注册到Call中， Call类的对象在合适的时候调用该回调函数实现运算或者传值。需要注意的是本DEMO需要提前在Call中声明回调函数的指针，返回值，参数以及它们的类型 2.另外一个tcFunctionTemplate是使用std::function模板和std::bind，支持全局和类成员函数作为回调函数，我在VS2010下编译通过
BCB线程中调用主界面的回调函数
09-13
网上的回调函数都是API例子，学习函数指针倒是不错，可是很难让初学者立即应用。常见的情况是辅线程完成某事件后需要“通知”主界面，比如常见的进度条——线程中完成一定的进度后即通知主界面显示到一定的刻度。本程序解决了bcb中回调函数的实用问题，可以当模板套用。代码有一定的注释，简单易懂，至少对于学BCB的人来说，是网上找不到的例子！ Form1->ProgressBar1->Position=0; pMyCallback=new callthread(false); //开启线程 pMyCallback->RegisterDataCallBackFun(Progress); //注册回调函数接口 ......
【C++基础之八】函数指针和回调函数
热门推荐
偶尔e网事
09-16 3万+
C++很多类库都喜欢用回调函数，MFC中的定时器，消息机制，hook机制等待，包括现在在研究的cocos2d-x中也有很多的回调函数。 1.回调函数 什么是回调函数呢？回调函数其实就是一个通过函数指针调用的函数！假如你把A函数的指针当作参数传给B函数，然后在B函数中通过A函数传进来的这个指针调用A函数，那么这就是回调机制。B函数就是回调函数，而通常情况下，A函数是系统在符合你设定条件的情况下会
C++中回调函数使用详解（普通函数作为回调函数以及类的成员函数作为回调函数）
xhj_enen的博客
11-06 3593
引言： 在C++编程，尤其时写Qt程序时，需要大量使用回调函数，在网上也有很多大牛对回调函数的使用进行了讲解，但是很多都是针对某一个或者两个特定的类型的。我在这篇文章中对网上关于回调函数的使用进行了归纳总结，并且对每一种类型的回调函数都写了一个简单的例子来实现，每个例子都可以在vs2015中编译通过。其中需要用到 bind和function的代码，由于使用了C++11的新标准，所以在vc6.0中...
C/C++ 不带参数的回调函数 与 带参数的回调函数 函数指针数组 例子
Hello Captain
10-13 5324
先来不带参数的回调函数例子 #include #include void printFunc() { std::cout<<"printFunc"<<std::endl; } void CallFunc(void (*FuncPoint)()) { FuncPoint(); } int main(int argc,char* argv[]) { CallFunc(pr
C++11的无固定形参的回调
qq_28107929的博客
04-29 238
//任务回调函数定义 typedef std::function< void() > ACTask; void ACBusinessManager::AddChildThreadTask(ACTask task) { if (task) { m_taskManager->AddTask(task); } } //调用过程： [ = ] ：为传值调用！！ [ & ]...
C++ Template非类型的类模板参数（4.1节）
chenyijun的专栏
07-07 646
对于函数模板和类模板，模板参数并不局限于类型，普通值也可以作为模板参数。在基于类型参数的模板中，定义一些具体细节未加确定的代码，直到代码被调用时这些细节才被真正确定。然而，在这里，我们面对的这些细节是值(value)，而不是类型。当要使用基于值的模板时，你必须显式地指定这些值，才能够对模板进行实例化，并获得最终代码。 较之前的Stack例子的实现，可以使用元素数目固定的数组来实现Stack。这个方法（用固定大小的数组）的优点是：无论是由你来亲自管理内存，还是由标准容器来管理内存都可以避免内...
回调函数和模板的结合使用（自我小结）
CodeWorld1999的博客
01-18 127
回调函数和模板的结合
模板方法与回调函数
ab1024249403的博客
03-20 336
模板方法模式在一个方法中定义一个算法骨架，并将某些步骤推迟到子类中实现。模板方法模式可以让子类在不改变算法整体结构的情况下，重新定义算法中的某些步骤。这里的“算法”，我们可以理解为广义上的“业务逻辑”，并不特指数据结构和算法中的“算法”。这里的算法骨架就是“模板”，包含算法骨架的方法就是“模板方法”。
模板方法模式与回调函数
蜗牛
04-25 907
一 模板方法模式 模板方法模式（Template Method Pattern）是设计模式中比较简单的一种，但在工作中使用的场景却比较多，面试时也会被经常被问到，其基本定义如下： Define the skeleton of an algorithm in an operation,deferring some steps tosubclasses.Template Method lets su...
C++回调模板类的例子
08-26
C++回调模板类的例子，利用模板和类的多态性来实现
适用于参数传递和回调的C++模板类
03-19
自己的写类，感觉应该可以在大部分项目中通用
回调成员函数，正则表达式，交互式调试模块
05-14
模板类实现普通成员函数作为回调函数，deelx正则表达式库的使用示例，交互式控制台调试模块以及磁盘检测模块的封装类。转载请保留版权。
APIHook、InlineHook库，使用C++11编写，可将回调函数绑定到类成员函数
11-29
APIHook、InlineHook库，使用C++11编写，可将回调函数绑定到类成员函数。代码风格良好，适合学习。
[原创]自己工作中常用的模板库，简化你的工作
10-12
★ C++语法不支持模板函数/模板成员函数作为回调函数。本库采用了封装，可以支持模板函数的回调，并且支持最多7个可变参数（可以简易扩充参数个数）。 可以遍历一个TypeList或者枚举值范围CEnumRange，然后以满足...
springboot(酒店管理系统)
04-25
开发语言：Java JDK版本：JDK1.8（或11） 服务器：tomcat 数据库：mysql 5.6/5.7（或8.0） 数据库工具：Navicat 开发软件：idea 依赖管理包：Maven 代码+数据库保证完整可用，可提供远程调试并指导运行服务（额外付费）～ 如果对系统的中的某些部分感到不合适可提供修改服务，比如题目、界面、功能等等... 声明： 1.项目已经调试过，完美运行 2.需要远程帮忙部署项目，需要额外付费 3.本项目有演示视频，如果需要观看，请联系我 4.调试过程中可帮忙安装IDEA，eclipse，MySQL，JDK，Tomcat等软件 重点： 需要其他Java源码联系我，更多源码任你选，你想要的源码我都有！ 需要加v19306446185
BP神经网络matlab实例.doc
最新发布
04-25
数学模型算法
设计.zip
04-25
设计.zip
基于 Spring Cloud 组件构建的分布式服务架构
04-25
Java SSM项目是一种使用Java语言和SSM框架（Spring + Spring MVC + MyBatis）开发的Web应用程序。SSM是一种常用的Java开发框架组合，它结合了Spring框架、Spring MVC框架和MyBatis框架的优点，能够快速构建可靠、高效的企业级应用。 1. Spring框架：Spring是一个轻量级的Java开发框架，提供了丰富的功能和模块，用于开发企业级应用。它包括IoC（Inverse of Control，控制反转）容器、AOP（Aspect-Oriented Programming，面向切面编程）等特性，可以简化开发过程、提高代码的可维护性和可测试性。 2. Spring MVC框架：Spring MVC是基于Spring框架的Web框架，用于开发Web应用程序。它采用MVC（Model-View-Controller，模型-视图-控制器）的架构模式，将应用程序分为模型层、视图层和控制器层，提供了处理请求、渲染视图和管理流程的功能。 3. MyBatis框架：MyBatis是一个持久层框架，用于与数据库进行交互。它提供了一种将数据库操作与Java对象映射起来的方式，避免了手动编写繁琐的SQL语句，并提供了事务管理和缓存等功能，简化了数据库访问的过程
c++回调函数内如何传值到回调函数 示例
09-09
3. 使用函数指针和主对象里的用户指针：如果回调函数是作为一个类的成员函数，可以通过将该类的实例指针作为用户指针传递给回调函数，从而在回调函数内部访问该类的成员变量和成员函数。 4. 使用std::function：C++...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值