0801-----C++Primer听课笔记----------C++11新特性 function 和 bind 的简单使用

1.function 和 函数指针

  1.1 function有函数指针的功能,但是使用起来明显比函数指针更加灵活和方便。

  1.2 函数指针和function的用法实例。

    1.2.1 函数指针首先要清楚函数指针的类型,如void (*)(int, char)等,然后声明一函数指针变量直接调用即可。

#include <iostream>
using namespace std;
/*
 * 函数指针的用法
 */

void test(int i,double j){
    cout << i << " " << j << endl;
}

int main(int argc, const char *argv[])
{
    void (*fp)(int, double);
    fp = test;
    fp(3, 2.3);

    1.2.2 function 和函数指针类型,需要函数的类型,定义一个该类的对象,用法和函数指针相同。

#include <iostream>
#include <functional>
using namespace std;
/*
 * c++11 function
 *
 */

void test(int i,double j){
    cout << i << " " << j << endl;
}

int main(int argc, const char *argv[])
{
    function<void (int, double)> fp;
    fp = test;
    fp(3, 2.3);
    return 0;
}

2.function 和 bind 的简单使用

  2.1 bind函数用来将一个function对象和一个函数实现绑定,这里使用了占位符,这里占位符所占的位置是调用的时候的位置。

  2.2 程序示例。

#include <iostream>
#include <string>
#include <functional>
using namespace std;

/*
 * bind 实现function的任意绑定
 *
 */

void test(int i, double d, const string &s){
    cout << "i = " << i << " d = " << d << " s = " << s << endl;
}

int main(int argc, const char *argv[])
{
    //1.void(*)(int, double)
    function <void (int, double)> fp;
    string s = "fp...";
    fp = bind(&test, std::placeholders::_1, std::placeholders::_2, s);
    fp(1, 1.1);

    //2. void(*)(double, int, const string &)
    function <void (double, int, const string &)> fp2;
    fp2 = bind(&test, std::placeholders::_2, std::placeholders::_1, std::placeho                                lders::_3);
    fp2(2.2, 2, "fp2...");

    //3. void(*)(const string &, int)
    function <void (const string &)> fp3;
    fp3 = bind(&test, 3, 3.3, std::placeholders::_1);
    fp3("fp3...");

    //4. void(*)(const string &, int , double)
    function <void (const string &, int, double)> fp4;
    fp4 = bind(&test, std::placeholders::_2, std::placeholders::_3, std::placeho                                lders::_1);
    fp4("fp4...", 4, 4.4);

    //5. void(*)(int)
    function <void (int)> fp5;
    fp5 = bind(&test, std::placeholders::_1, 5.5, "fp5...");
    fp5(5);

    //6. void(*)(const string &)
    function <void (const string &)> fp6;
    fp6 = bind(&test, 6, 6.6, std::placeholders::_1);
    fp6("fp6...");

    //7. void(*)()
    function <void ()> fp7;
    fp7 = bind(&test, 7, 7.7, "fp7...");
    fp7();

    return 0;
}

  2.3 function和bind的使用示例。

#include <iostream>
#include <string>
#include <vector>
#include <functional>
using namespace std;
/*
 * c++11 function
 *
 */

// void (*)()
void test(){
    cout << "test... " << endl;
}

class Test{
    public:

        //void (*)()
        static void test_static(){
            cout << "test static ..." << endl;
        }

        //void (Test::*)() //含有隐式参数 Test *
        void test2(){
            cout << "test2... In Test" << endl;
        }

        //void (Test::*)(int)
        void test3(int i){
            cout << i << " test3 ... In Test" << endl;
        }
};
int main(int argc, const char *argv[])
{
    function<void ()> fp;
    fp = test;
    fp();

    fp = Test::test_static; // static 函数名包含类名
    fp();

    Test t;
    fp = bind(&Test::test2, &t); //绑定一个对象的指针
    fp();

    fp = bind(&Test::test3, &t, 3);
    fp();

    // test3  转换成 void (*)(int)类型的
    function<void (int)> fp2;
    fp2 = bind(&Test::test3, &t, std::placeholders::_1);
    fp2(2000);

    return 0;
}

  

0801-----C++Primer听课笔记----------C++11新特性 function 和 bind 的简单使用,布布扣,bubuko.com

时间: 07-31

0801-----C++Primer听课笔记----------C++11新特性 function 和 bind 的简单使用的相关文章

0722-----C++Primer听课笔记----------句柄类和智能指针

1.再说智能指针 1.1  为什么要用智能指针?对于一个指针,它指向一个动态分配内存的对象,若同时有多个指针指向该对象,那么当我们delete的时候,就会出现delete 一个无效内存的错误,因为该对象已经被delete过了,所以这就造成了错误.针对这一情况,我们想到,new 和 delete 必须是成对出现的,那么联想到类里面,很容易想到这个构造函数和析构函数也是成对出现的,对于每一个对象,初始化的时候会调用构造函数,而销毁的时候必然要调用析构函数.因此我们就可以对 指针 进行封装,将该指针的

0717-----C++Primer听课笔记----------STL之关联容器

1.Map 1.1 map<K, V>是一种pair的容器,pair的种类是pair<K, V>.map采用下标访问一个已存在的key, 会更新value,访问map中不存在的元素时,会增加一个新的键值对.map中的元素按照key进行从小到大排列.map的底层实现是采用二叉树,一般是使用红黑树. #include <iostream> #include <string> #include <map> using namespace std; /*

0715-----C++Primer听课笔记----------疯狂封装之生产者与消费者

1.程序框架分析: a)首先将mutex, condition, queue 封装成各自的类,方便对外提供接口函数,这里要注意 condition的封装,一个条件变量和一把锁是一起用的,因此在初始化 condition 对象的时候要用一个 mutex 对象去初始化,在pthread_cond_wait函数中还要用到互斥锁中的指针,因此在mutex 类中要封装一个返回相应类型的函数.此外多个条件变量一般是和同一互斥锁进行交互,因此要在condition 中的  mutex对象设为引用,这里可以这样

0722-----C++Primer听课笔记----------虚函数和模板

1.虚指针和虚函数表 1.1 不含有任何数据成员或者虚函数的class或者struct大小为1,含有虚函数的对象在基地址部分有一个vptr,指向虚函数表,因此大小为4个字节. 1.2 动态绑定的原理:假设派生类和基类存在覆盖的关系(基类中定义了虚函数),那么派生类在虚函数表中,会覆盖掉基类相应的虚函数.当程序执行的时候,根据基类指针找到vptr,根据vptr找到vtable,然后找到相应的版本去执行.所以执行的是覆盖的版本,而具体被哪个版本覆盖是由具体的对象类型所决定的,所以才实现了根据对象的具

C++ 11新特性解析——《深入理解C++ 11:C++11新特性解析和应用》读书笔记

因为偶然的机会,在图书馆看到<深入理解C++ 11:C++11新特性解析和应用>这本书,大致扫下,受益匪浅,就果断借出来,对于其中的部分内容进行详读并亲自编程测试相关代码,也就有了整理写出这篇读书笔记的基础.C++作为踏入编程的最初语言,一直充满感情,而C++11作为新标准虽然推出一段时间了,却因为总总原因直到现在才去开始真正了解,不过一句话回荡在脑中:当你认为为时已晚的时候,恰恰是最早的时候!从C++98到C++11, C++11标准经历了10几年的沉淀,以全新的姿态迎接新的挑战,长话短说,

0718-----C++Primer听课笔记----------运算符重载

0.两个要点 a) 一个空类,编译器自动合成默认无参构造函数.析构函数.拷贝构造函数.赋值运算符. b) 在编写类的时候,必须严格区分对象是否可复制. 1.运算符重载之 string类 1.1 运算符重载的几个要点: a) 运算符重载可以有成员函数和友元函数的形式,后者比前者多一个参数. b) =和+=必须重载为成员函数的形式(不太理解原因). c) 输入和输出必须为友元函数的形式.而且输入操作符要考虑输入失败的情况. d) 运算符重载为成员函数的形式,那么该操作符的第一个操作数必然为该类的对象

0716-----C++Primer听课笔记----------STL之顺序容器、迭代器

1. 顺序容器的初始化操作 1.1 顺序容器(vector,list,deque)的五种初始化方法,以 vector 为例. #include <iostream> #include <string> #include <vector> using namespace std; int main(int argc, const char *argv[]) { //1.定义空数组 然后后面追加 vector<string> vec1; vec1.push_ba

0713-----C++Primer听课笔记----------类和对象

1.要求:将一篇文章录入,然后实现查询: a)查询可以输入字符或者字符串 b)将包含它们的单词输出 c)允许重复 d)如果输入查询有空格,当多个处理 Ex: 输入ro,应该打印出“microsift” 输入”he wr”,则查询两次 1.1  不用类实现 #include <iostream> #include <string> #include <vector> #include <fstream> #include <stdexcept> u

0715-----C++Primer听课笔记-----------函数指针 、单例模式

1.函数指针 1.1 普通成员函数指针包含类名信息以及const属性,指向具体函数是必须加上&符号. #include <iostream> using namespace std; class Test{ public: void setValue(const string &s, int a){ s_ = s; a_ = a; } void print() const{ cout << s_ << endl << a_ <<