Chinaunix首页 | 论坛 | 博客
  • 博客访问: 57943
  • 博文数量: 32
  • 博客积分: 0
  • 博客等级: 民兵
  • 技术积分: 255
  • 用 户 组: 普通用户
  • 注册时间: 2016-12-02 09:11
文章分类

全部博文(32)

文章存档

2017年(21)

2016年(11)

我的朋友

分类: C/C++

2017-01-13 15:42:27

转自:http://blog.csdn.net/u013696062/article/details/40891973
Tr1::function的介绍
它是一个类模板,类的成员变量是一个函数指针。可以把它看作一个智能函数指针(和shared_ptr智能指针对比着理解)。

一. 头文件
#include

二. 使用
  1. //t.cpp
  2. #include "stdafx.h"
  3. #include<iostream>
  4. #include<functional>
  5. using namespace std;
  6. void foo(int i){cout<<"aaa"<<endl;}
  7. void (*p)(int)=foo;
  8. int _tmain(int argc, _TCHAR* argv[])
  9. {
  10.        function<void (int)> fm;
  11.        fm=foo;
  12.        (*p)(2);
  13.        fm(2);
  14.        return 0;
  15. }
可以看出它和函数指针很像,但是它具有很多函数指针做不到的事情。下面慢慢说。

1. 定义一个function对象。
由于function是一个类模板,所以使用起来,首先定义一个类的对象。
Function fm;-----<>中第一个参数是要绑定函数的返回类型,第二个参数是要绑定的函数的参数列表。注意使用小括号括起来。

2. 像函数指针一样,这个指针需要指向某个函数。
fm=function(foo);

3. 由于类模板function重载了()符号。所以使用起来比函数指针更易用。
Fm(2);

三.下面说一下为什么要有tr1::function.也就是它相对于函数指针的优点:

1. 绑定的函数的类型
函数指针只能绑定普通的外部函数。而tr1::function可以绑定各种函数类型。
(1) 外部普通函数和类的static函数
  1. //t.cpp
  2. #include "stdafx.h"
  3. #include<iostream>
  4. #include<functional>
  5. using namespace std;
  6. class A{
  7. public:
  8. static void foo(inti){cout<<"aaa"<<endl;}
  9. };
  10. int _tmain(int argc, _TCHAR* argv[])
  11. {
  12.        function<void (int)>fm(A::foo);
  13.        //function<void (int)> fm;fm=function<void(int)>(A::foo); also OK
  14.        void (*p)(inti)=A::foo();//error
  15.        fm(2);
  16.        return 0;
  17. }
因为外部函数和类的static很相似,所以使用起来也很相似。
(2)类的非static成员函数。
  1. //t.cpp
  2. #include "stdafx.h"
  3. #include<iostream>
  4. #include<functional>
  5. using namespace std;
  6. class A{
  7. public:
  8. void foo(int i){cout<<"aaa"<<endl;}
  9. };
  10. int _tmain(int argc, _TCHAR* argv[])
  11. {
  12.        A b;
  13.        function<void (int)>fm=bind(&A::foo,b,tr1::placeholders::_1);//OK
  14.        //function<void (int)> fm=b.foo();//error
  15.        fm(2);
  16.        return 0;
  17. }
注意必须是&A::foo(),这个符号&不能少,这是由function决定的。这里bind中的foo只是接受一个参数,而实际上是需要两个参数,因为static函数是没有对象就存在的,而非static成员函数必须有对象之后才能存在,所以这个成员函数需要指明是哪个对象的成员函数。
(3) 绑定虚函数,呈现多态
  1. //t.cpp
  2. #include "stdafx.h"
  3. #include<iostream>
  4. #include<functional>
  5. using namespace std;
  6. class A{
  7. public:
  8.   virtual void foo(int i){cout<<"A"<<endl;}
  9.   void fun(){
  10.        function<void (int)>fm=bind(&A::foo,this,tr1::placeholders::_1);
  11.        fm(2);//这里和直接调用foo();效果是一样的。并没有改变它的多态性质
  12. }
  13. };
  14. class B:public A
  15. {
  16. public:void foo(inti){cout<<"B"<<endl;}
  17. };
  18. int _tmain(int argc, _TCHAR* argv[])
  19. {
  20.        B b;
  21.        b.fun();
  22.        return 0;
  23. }
其实这里并不是function的什么特殊性质,而只是function是一个普通的类而已,不是因为它而改变多态性质。这里和直接调用foo();的效果一样。

2. 构造函数中的参数
(1) 首先是函数名,这个上面已经讲过
(2) 可以是一个函数对象!(函数对象就是一个重载了操作符”()”的类,这样类的对象可以:a(…);使用起来很像函数,所以叫做函数对象)
  1. //t.cpp
  2. #include "stdafx.h"
  3. #include<iostream>
  4. #include<functional>
  5. using namespace std;
  6. class A{
  7. public:
  8.        void operator()(int i){cout<<"A"<<endl;
  9.        }
  10.        void foo(){}
  11. };
  12. int _tmain(int argc, _TCHAR* argv[])
  13. {
  14.        A a;
  15.        function<void (int)> fm(a);
  16.        fm(2);
  17.        return 0;
  18. }
注意这里,居然可以把一个类对象放到function里!这好像违反了function函数指针的原意。但是注意:由于function没有提供返回它拥有的东西的函数,所以这里只能fm(2);来调用类中的重载()函数。不能调用类中的其他函数。所以它还是一个函数指针,只是这个指针指向的函数是一个类中的重载()函数罢了。

3. function类模板的其他几个member函数
(1) assign函数,为这个函数指针分配一个函数实体。
(2) swap函数,交换两个函数指针拥有的东西
(3) target函数,测试本函数指针指向的函数类型是不是为指定类型
(4) target_type函数,获取函数指针指向的函数的类型信息
不常用,也不好用,所以了解即可。
    总结:其实function和函数指针很像,只是比函数指针能多指向一些特别的函数而已。
             普通函数指针只能指向普通的外部函数
             Function可以指向:外部函数,类的static函数,类的非static函数,类的virtual函数,类的对象(函数对象)。
阅读(832) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~