C++函数委托

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了C++函数委托，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含12935字，纯文字阅读大概需要19分钟。

内容图文

环境：

　　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]) {
                returnfalse;
            }
            if (func_[1] != ptr.func_[1]) {
                returnfalse;
            }
            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;
        }

        booloperator <(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;
        }

        booloperator <(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:
        virtualint 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:
        virtualint 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:
        virtualint 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:
        virtualint 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 : publicvirtual testd, publicvirtual teste
    {
    public:
        virtualint 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:
        virtualint 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

原文：https://www.cnblogs.com/dongc/p/10693000.html

内容总结

以上是互联网集市为您收集整理的C++函数委托全部内容，希望文章能够帮你解决C++函数委托所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1291676.html

来源：【匿名】

【下一篇】c++有个库什么的吗?

更多 ►

【C++函数委托】教程文章相关的互联网学习教程文章

环境：　　win7_x64旗舰版、VS2015企业版场景：　　C++标准库提供std::function类来将一个对象的调用操作封装在一个对象内部，然后可以委托调用，但是有一些弊端，例如下面的需求：　　　　我们需要将调用操作封装存储到一个map中，来实现观察者模式或信号槽，由于std::function是在编译期确定类型，导致你无法将不同类型的std::function（例如std::function<void()>和std::function<void(int)>）放入同一个map中。　　function_de...

C++ 虚函数表解析

C++ 虚函数表解析<?xml:namespace prefix = o /> 陈皓http://blog.csdn.net/haoel 前言 C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这样的技术能够让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比方：模板技术，RTTI技术，虚函数技术，要么是试图做到在编...

【足迹C++primer】54、继承类的范围,构造函数和拷贝控制【图】

继承类的范围,构造函数和拷贝控制当用派生类执行函数的时候，首先会在当前的类里面找如果找不到就一级一级地往上找。Name Lookup Happens at Compile Timeclass Quote { public:Quote()=default;Quote(const string &book, double sales_price):bookNo(book), price(sales_price){cout<<"Quote gouzhao function"<<endl;}string isbn() const {return bookNo;}//返回指定数量的项目总销售价格//派生类将重写应用不同的折扣算法vir...

C++进制转换函数【代码】

一、指定格式输出1.在C中，按指定进制格式输出如下：printf("%05o\n",35); //按八进制格式输出，保留5位高位补零 printf("%03d\n",35); //按十进制格式输出，保留3位高位补零 printf("%05x\n",35); //按十六进制格式输出，保留5位高位补零 /* 00043 035 00035 */2.在C++中，按指定进制格式输出如下：#include <bitset> #include<iostream> usingnamespace std; int main() {cout << "35的8进制:" << std::oct << 35<< end...

C++学习笔记——虚函数【代码】【图】

基本概念虚函数是在某基类中声明为 virtual 并在一个或多个派生类中被重新定义的成员函数，用法格式为：virtual 函数返回类型函数名（参数表） {函数体}；C++中用它来实现多态性，通过指向派生类的基类指针或引用，访问派生类中同名覆盖成员函数。虚函数实现机制虚函数是如何做到因对象的不同而调用其相应的函数的呢？现在我们就来剖析虚函数。我们先定义两个类class A{//虚函数示例代码 public: virtual voidfun(){cout<<1<<endl...

函数（剩余）--C++复习（6）【代码】

一、return语句 1.返回非引用类型，则是复制返回值给表达式； 2.返回引用类型，则是返回对象本身； 3.不要返回局部变量的引用，因为函数退出局部变量会消失。二、静态（static）局部变量如果某个变量是静态局部变量，则一旦变量被初始化就一直存在，直到程序执行结束。三、内联函数* 调用函数比求解表达式要慢得多。那么对于较短的程序片段，就适合将其指定为内联函数；这样降低写成函数的额外开销...

c++ 基类已经存在virtual修饰的同名成员函数，派生类加不加无所谓，都是virtual的【代码】

1struct A2{3virtualvoid f() {tcout << _T("A::f()\n");}4};5 6struct B : public A7{8void f() {tcout << _T("B::f()\n");}9}; 1011struct C : public B 12{ 13void f() {tcout << _T("C::f()\n");} 14}; 1516struct D : public C 17{ 18void f() {tcout << _T("D::f()\n");} 19}; 202122int _tmain(int argc, TCHAR * argv[], TCHAR * envp[]) 23{ 24 A * pA = new D; 25 pA->f(); 2627return0; 28 }结果：D::f()原文：...

Windows客户端C/C++编程规范“建议”——函数【图】

1 函数1.1 代码行数控制在80行及以内等级：【要求】说明：每个函数的代码行数控制应该控制在80行以内。如果超过这个限制函数内部逻辑一般可以拆分。如果试图超过这个标准，请列出理由。但理由不包含如下：无法拆分。流程内部逻辑复杂，无需拆分，即使拆分了，拆分的函数也不会被其他地方用到。（解释：拆分可以减少代码行数，提炼后的函数可以方便读者快速理解函数逻辑并定位问题。）1.2 代码列数控制在100字符及以内等级：【要求...

C++构造函数和析构函数初步认识(2)【代码】【图】

构造函数的三个作用1.构造对象2.对象初始化3.类型转换 //Test1.h #include<iostream> using namespace std; //构造对象 //初始化对象 //类型装换 class ST { private:int a;long b; public:ST(int a=0);//缺省的构造函数只允许有一个ST(long b);ST(int a, long b);~ST(){cout<<"ST was Free. "<<this<<endl;}operator int();operator long();int Get_a();void fill(int a, long b); }; ST::ST(int a) {cout<<"ST was Built. "<<thi...

c++ 命名空间以及作用域函数参数面向对象实验报告【代码】

面向对象的分析与设计实验报告一一．变量的储存类别auto static register externauto变量函数中的局部变量，如不专门声明为static存储类别，都是动态地分配存储空间的，数据存储在动态存储区中。函数中的形参和在函数中定义的变量（包括在复合语句中定义的变量），都属此类，在调用该函数时系统会给它们分配存储空间，在函数调用结束时就自动释放这些存储空间。这类局部变量称为自动变量。自动变量用关键字auto作存储类别的声...

C++ 必知必会：条款16 指向成员函数的指针并非指针【代码】

这一点与指向成员的指针类似，其实现可能更加复杂，因为成员函数同时还存在虚拟函数，需要动态绑定执行动作。当然这种属性是属于函数本身的，此处表达的是指针不涉及函数的属性问题。 1: class shape 2: { 3: public: 4: // void moveTo(point newLocation); 5: bool validate(); 6: //… 7: } 8: 9: class circle:: public shape 10: { 11: public: 12: //… 13: bool draw() const; 14: ...

C++中的虚函数以及虚函数表【代码】【图】

一.虚函数的定义被virtual关键字修饰的成员函数，目的是为了实现多态ps：关于多态【接口和实现分离，父类指针指向子类的实例，然后通过父类指针调用子类的成员函数，这样可以让父类指针拥有多种形态，所以称之为多态】二.虚函数表该表为一个类的虚函数的地址表，用于解决继承和覆盖的问题1.拥有虚函数的类才有虚函数表2.虚函数表属于类，然后类的所有对象通过虚函数表指针共享类的虚函数表3.虚函数表的作用：当使用父类指针来操作子...

【C/C++学院】0816-引用包装器/仿函数/转义字符 R”()”/using别名/模板元编程比递归优化/智能指针/多线程/静态断言以及调试技能的要求 assert

引用包装器 std::ref(变量)#include<iostream>template<class T> void com(T arg)//模板函数，引用无效，引用包装器 {std::cout <<"com ="<< &arg << "\n";arg++; }void main() {int count = 10;int & rcount = count;com(count);std::cout << count << std::endl;//std::ref(变量) ，函数模板,引用包装器//com(std::ref(count));com(rcount);std::cout << "main=" << &rcount << "\n";std::cout << count << std::endl;std::cin...

c++ 用宏定义一个函数

#define MAX(a,b) ((a)>(b)?(a):(b))要点：变量都用括号括起来，防止出错，结尾不需要;。在实际编程中，不推荐把复杂的函数使用宏，不容易调试。多行用\#define CREATE_FUNC_TYPE(__TYPE__,__PARAM__) static __TYPE__* create(__PARAM__ para) { __TYPE__ *pRet = new(std::nothrow) __TYPE__(); if (pRet && pRet->init(para)) { pRet->autorelease(); return pRet; } else { delete pRet; pRet = NULL; return NULL; }...

C++中如何定义函数对象【代码】

尽管函数指针被广泛用于实现函数回调，但C++还提供了一个重要的实现回调函数的方法，那就是函数对象。函数对象（也称“算符”）是重载了“()”操作符的普通类对象。因此从语法上讲，函数对象与普通的函数行为类似。用函数对象代替函数指针有几个优点，首先，因为对象可以在内部修改而不用改动外部接口，因此设计更灵活，更富有弹性。函数对象也具备有存储先前调用结果的数据成员。在使用普通函数时需要将先前调用的结果存储在全程或...

C++ - 技术教程分类

C++ 教程 C++ 简介 C++ 基本语法 C++ 注释 C++ 数据类型 C++ 变量类型 C++ 变量作用域 C++ 常量 C++ 修饰符类型 C++ 存储类 C++ 运算符 C++ 循环 C++ 判断 C++ 函数 C++ 数字 C++ 数组 C++ 字符串 C++ 指针 C++ 引用 C++ 日期 & 时间 C++ 基本的输入输出 C++ 数据结构 C++ 类 & 对象 C++ 继承 C++ 重载运算符和重载函数 C++ 多态 C++ 数据抽象 C++ 数据封装 C++ 接口（抽象类） C++ 文件和流 C++ 异常处理 C++ 动态内存 C++ 命名空间 C++ 模板 C++ 预处理器 C++ 信号处理 C++ 多线程 C++ Web 编程 C++ 标准库 C++ 有用的资源 C++ 实例 c++ 全部

C++ - 最热教程

C++通过共享内存实现进程间通信（windo...C++基于EasyX制作贪吃蛇游戏（一）文档 C++中的分治算法及常见题目汇总【C++】stringstream的str() 和 string...c++中内置函数qsort（快速排序）和bsea...VS2019 C++创建一个简单项目demo [C++]VS2015用动态链接(MD/MDd)方式编译...C/C++编程学习 - 第15周 ⑥ 药房管理万维考试系统检测不到VC++ 6.0环境解决...C/C++ QT自定义对话框与MID窗体

首页 / C++ / C++函数委托

C++函数委托

内容导读

内容图文

环境：

场景：

实现代码：

测试代码：

扩展：

内容总结

内容备注

内容手机端

【C++函数委托】教程文章相关的互联网学习教程文章

C++函数委托【代码】

C++ 虚函数表解析

【足迹C++primer】54、继承类的范围,构造函数和拷贝控制【图】

C++进制转换函数【代码】

C++学习笔记——虚函数【代码】【图】

函数（剩余）--C++复习（6）【代码】

c++ 基类已经存在virtual修饰的同名成员函数，派生类加不加无所谓，都是virtual的【代码】

Windows客户端C/C++编程规范“建议”——函数【图】

C++构造函数和析构函数初步认识(2)【代码】【图】

c++ 命名空间以及作用域函数参数面向对象实验报告【代码】

C++ 必知必会：条款16 指向成员函数的指针并非指针【代码】

C++中的虚函数以及虚函数表【代码】【图】

【C/C++学院】0816-引用包装器/仿函数/转义字符 R”()”/using别名/模板元编程比递归优化/智能指针/多线程/静态断言以及调试技能的要求 assert

c++ 用宏定义一个函数

C++中如何定义函数对象【代码】

函数 - 相关标签

C++ - 技术教程分类

C++ - 最新教程

C++ - 最热教程