• <ins id="pjuwb"></ins>
    <blockquote id="pjuwb"><pre id="pjuwb"></pre></blockquote>
    <noscript id="pjuwb"></noscript>
          <sup id="pjuwb"><pre id="pjuwb"></pre></sup>
            <dd id="pjuwb"></dd>
            <abbr id="pjuwb"></abbr>

               C++ 技術(shù)中心

               :: 首頁 :: 聯(lián)系 ::  :: 管理
              160 Posts :: 0 Stories :: 87 Comments :: 0 Trackbacks

            公告

            鄭重聲明:本BLOG所發(fā)表的原創(chuàng)文章,作者保留一切權(quán)利。必須經(jīng)過作者本人同意后方可轉(zhuǎn)載,并注名作者(天空)和出處(CppBlog.com)。作者Email:coder@luckcoder.com

            留言簿(27)

            搜索

            •  

            最新隨筆

            最新評論

            評論排行榜

            /* 
             * File:   main.cpp
             * Author: Vicky.H
             * Email:  eclipser@163.com
             
            */
            #include <iostream>
            #include <functional>
            #include <typeinfo>
            #include <string.h>

            int add1(int i, int j, int k) {
                return i + j + k;
            }


            class Utils {
            public:
                Utils(const char* name) {
                    strcpy(_name, name);
                }
                
                void sayHello(const char* name) const {
                    std::cout << _name << " say: hello " << name << std::endl;
                }
                
                static int getId() {
                    return 10001;
                } 
                
                int operator()(int i, int j, int k) const {
                    return i + j + k;
                }
                
            private:
                char _name[32];
            };


            /*
             * 
             
            */
            int main(void) {
                
                // 綁定全局函數(shù)
                auto add2 = std::bind(add1, std::placeholders::_1, std::placeholders::_2, 10);
                // 函數(shù)add2 = 綁定add1函數(shù),參數(shù)1不變,參數(shù)2不變,參數(shù)3固定為10.
                std::cout << typeid(add2).name() << std::endl;
                std::cout << "add2(1,2) = " << add2(1, 2) << std::endl;
                
                std::cout << "\n---------------------------" << std::endl;
                
                // 綁定成員函數(shù)
                Utils utils("Vicky");
                auto sayHello = std::bind(&Utils::sayHello, utils/*調(diào)用者*/, std::placeholders::_1/*參數(shù)1*/);
                sayHello("Jack");
                
                auto sayHelloToLucy = std::bind(&Utils::sayHello, utils/*調(diào)用者*/, "Lucy"/*固定參數(shù)1*/);
                sayHelloToLucy();
                
                // 綁定靜態(tài)成員函數(shù)
                auto getId = std::bind(&Utils::getId);
                std::cout << getId() << std::endl;
                
                std::cout << "\n---------------------------" << std::endl;
                
                // 綁定operator函數(shù)
                auto add100 = std::bind(&Utils::operator (), utils, std::placeholders::_1, std::placeholders::_2, 100);
                std::cout << "add100(1, 2) = " << add100(1, 2) << std::endl;
                
                // 注意:無法使用std::bind()綁定一個(gè)重載函數(shù)
                
                return 0;
            }

            /* 
             * File:   main2.cpp
             * Author: Vicky.H
             * Email:  eclipser@163.com
             
            */
            #include <iostream>
            #include <typeinfo>


            void sayHello() {
                std::cout << "Hello world !" << std::endl;
            }

            int sum(int i, int j, int k) {
                return i + j + k;
            }

            template <typename T>
            class Func {
            public:

                Func(T fun) {
                    if (!fun) {
                        throw "fun nullptr";
                    }
                    _fun = fun;
                }

                template<typename R, typename A1, typename A2, typename A3, typename A4, typename A5>
                R Call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
                    return _fun(a1, a2, a3, a4, a5);
                }

                template<typename R, typename A1, typename A2, typename A3, typename A4>
                R Call(A1 a1, A2 a2, A3 a3, A4 a4) {
                    return _fun(a1, a2, a3, a4);
                }

                template<typename R, typename A1, typename A2, typename A3>
                R Call(A1 a1, A2 a2, A3 a3) {
                    return _fun(a1, a2, a3);
                }

                template<typename R, typename A1, typename A2>
                R Call(A1 a1, A2 a2) {
                    return _fun(a1, a2);
                }

                template<typename R, typename A1>
                R Call(A1 a1) {
                    return _fun(a1);
                }

                template<typename R>
                R Call() {
                    return _fun();
                }

                void Call() {
                    _fun();
                }

            private:
                T _fun;
            };

            #include <functional>

            template<typename R = void, typename Args>
            class Fn {
            public:
                Fn(std::function<R(Args)> fun) : _fun(fun) {
                }
                
                R operator()(Args args) {
                    return _fun(args);
                }
            private:
                std::function<R(Args) > _fun;
            };

            /*
             * 將函數(shù)注冊到對象中,通過對象直接調(diào)用
             
            */
            int main(void) {


                Func<void(*)() > sayHelloFunc(sayHello);
                sayHelloFunc.Call();


                Func<int (*)(intintint) > sumFunc(sum);
                std::cout << "sumFunc.Call<int>(1, 2, 3) : " << sumFunc.Call<int>(1, 2, 3) << std::endl;


                std::cout << "\n---------------------------" << std::endl;

                Fn<> sayHelloFn(sayHello);
                sayHelloFn();
                
                Fn<intintintint> sumFn(sum);
                std::cout << "sumFn(1, 2, 3) : " << sumFn(1, 2, 3) << std::endl;

                std::cout << "\n---------------------------" << std::endl;

                return 0;
            }

            Hello world !
            sumFunc.Call<int>(1, 2, 3) : 6


            ---------------------------
            Hello world !
            sumFn(1, 2, 3) : 6


            ---------------------------

            上面的例子非常有趣,使用了2種方案,將一個(gè)函數(shù),注冊到一個(gè)對象/仿函數(shù)中,并且通過一個(gè)對象/仿函數(shù)來直接調(diào)用調(diào)用。
            例子顯而易見的,第2種方案更佳簡潔,并且對傳遞參數(shù)有明確的判斷,當(dāng)參數(shù)類型或數(shù)量不正確的時(shí)候,編譯器將導(dǎo)致失敗。
            這種方案,可以將類的成員變量直接作為函數(shù)的參數(shù)使用,或者,如我:
            http://blog.csdn.net/eclipser1987/article/details/23926395
            這篇文章中,無法直接調(diào)用腳本函數(shù)類,有了好的解決辦法。這個(gè)我將隨后補(bǔ)充。

            #include <list>
            #include <functional>

            template<typename Args>
            class Fns
            {
            private:

                std::list<std::function<void(Args)> > _calls;

            public:

                virtual ~Fns()
                {
                    _calls.clear();
                }

                void connect(std::function<void(Args)> fct)
                {
                    _calls.push_back(fct);
                }

                template<typename Object>
                void connect(Object* objectvoid (Object::*method)(Args))
                {
                    _calls.push_back([object,method](Args args){(*object.*method)(args);});
                }

                template<typename Object>
                void connect(Object* objectvoid (Object::*method)(Argsconst)
                {
                    _calls.push_back([object,method](Args args){(*object.*method)(args);});
                }

                template<typename Object>
                void connect(const Object* objectvoid (Object::*method)(Argsconst)
                {
                    _calls.push_back([object,method](Args args){(*object.*method)(args);});
                }

                void emit(Args args)
                {
                    for(auto call : _calls)
                        call(args);
                }
            };

            #include <cstdio>
            #include "Signal.hpp"

            class Foo
            {
            public:

                void bar(int x, int y)
                {
                    printf("Foo::bar(%d, %d)\n", x, y);
                }
            };

            void foobar(int x, int y)
            {
                printf("foobar(%d, %d)\n", x, y);
            }

            int main(void)
            {
                Foo foo;
                Fns<intint> s;

                // Connect a function
                s.connect(foobar);
                // Connect a class method
                s.connect(&foo, &Foo::bar);
                // Create and connect some lambda expression
                s.connect([&foo](int x, int y){ 
                    printf("lambda::"); foo.bar(x, y); 
                });
                // Emit the signal !
                s.emit(4, 2);
                getchar();
                return 0;
            }

            foobar(4, 2)
            Foo::bar(4, 2)
            lambda::Foo::bar(4, 2)
            posted on 2016-06-13 15:39 C++技術(shù)中心 閱讀(1426) 評論(0)  編輯 收藏 引用 所屬分類: C++ 基礎(chǔ)
            91麻豆国产精品91久久久| 久久久国产亚洲精品| 久久综合中文字幕| 精品久久久久久国产免费了| 99久久综合国产精品免费| 久久久久国产精品熟女影院 | 久久66热人妻偷产精品9| 久久综合综合久久狠狠狠97色88| 久久本道综合久久伊人| 久久精品无码专区免费东京热| 伊人久久综在合线亚洲2019 | 狠狠色丁香久久婷婷综合_中| www性久久久com| 精品国产乱码久久久久久呢| 中文精品久久久久国产网址 | 久久久九九有精品国产| 日韩欧美亚洲综合久久影院Ds | 久久综合一区二区无码| 国产99精品久久| 色婷婷综合久久久久中文一区二区 | 久久久久高潮毛片免费全部播放| 久久亚洲国产精品123区| 99久久亚洲综合精品网站| 热re99久久6国产精品免费| 久久久久亚洲AV无码专区桃色| 99精品国产在热久久| 国产精品久久久久AV福利动漫| 久久精品人妻中文系列| 伊人精品久久久久7777| 国产亚洲美女精品久久久| 777久久精品一区二区三区无码| 久久精品成人免费网站| 无遮挡粉嫩小泬久久久久久久| 尹人香蕉久久99天天拍| 久久国产V一级毛多内射| 国内精品久久久久久久久| 91麻豆精品国产91久久久久久| 久久亚洲高清观看| 国产精品久久久久一区二区三区| 9191精品国产免费久久| 色偷偷91久久综合噜噜噜噜|