std::bind绑定器、std::function、extern C的使用

最新推荐文章于 2022-07-15 07:24:18 发布

井冈山市监人

最新推荐文章于 2022-07-15 07:24:18 发布

阅读量898

点赞数

分类专栏： C++

C++ 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

std::bind绑定器

将函数、成员函数和闭包转成function函数对象
将多元(n>1)函数转成一元函数或者(n-1)元函数。

bind()接受一个函数（或者函数对象，或者任何你可以通过"(...)"符号调用的事物），生成一个其有某一个或多个函数参数被“绑定”或重新组织的函数对象。（译注：顾名思义，bind()函数的意义就像它的函数名一样，是用来绑定函数调用的某些参数的。）例如：

1         int f(int, char, double);
2         auto ff = bind(f, _1, 'c', 1.2);    // 绑定f()函数调用的第二个和第三个参数，返回一个新的函数对象为ff，它只带有一个int类型的参数
3         int x = ff(7);                //  f(7, 'c', 1.2);

参数的绑定通常称为"Currying"（译注：Currying---“烹制咖喱烧菜”，此处意指对函数或函数对象进行加工修饰操作）, "_1"是一个占位符对象，用于表示当函数f通过函数ff进行调用时，函数ff的第一个参数在函数f的参数列表中的位置。第一个参数称为"_1", 第二个参数为"_2"，依此类推。例如：

1         int f(int, char, double);
2         auto frev = bind(f, _3, _2, _1);        // 翻转参数顺序
3         int x = frev(1.2, 'c', 7);            // f(7, 'c', 1.2);

此处，auto关键字节约了我们去推断bind返回的结果类型的工作。
我们无法使用bind()绑定一个重载函数的参数，我们必须显式地指出需要绑定的重载函数的版本：

1         int g(int);
2         double g(double);
3 
4         auto g1 = bind(g, _1);                // 错误：调用哪一个g() ?
5         auto g2 = bind( (double(*)(double))g, _1);    // 正确，但是相当丑陋

 1 void H(int a);
 2 //绑定全局函数
 3 auto f11 = std::bind(H, std::placeholders::_1);
 4 auto的类型实际上是std::function<void(int)>
 5 
 6 //绑定带参数的成员函数
 7 std::function<void (char*, int)> f = std::bind(&ReadHandler::ConnectPreProcess, this, std::placeholders::_1, std::placeholders::_1);
 8 
 9 //三元函数转换成一元函数
10 int f(int, char, double);
11 // 绑定f()函数调用的第二个和第三个参数，
12 // 返回一个新的函数对象为ff，它只带有一个int类型的参数
13 auto ff = bind(f, _1, ‘c’, 1.2);    
14 int x = ff(7);

自己写代码示例如下：

int Func(int x, int y);
auto bf1 = std::bind(Func, 10, std::placeholders::_1);
bf1(20); ///< same as Func(10, 20)

int HelloWorld::AddFunc( int a, int b )
{
    return a + b;
}

bool HelloWorld::init()
{

    auto bf2 = std::bind(&HelloWorld::AddFunc,this , std::placeholders::_1, std::placeholders::_2 );
    auto result1 = bf2(10, 20); ///< same as a.Func(10, 20)

    std::function< int(int)> bf3 = std::bind(&HelloWorld::AddFunc, this, std::placeholders::_1, 100);
    auto result2 = bf3(10); ///< same as a.Func(10, 100)

}

上面的例子中，bf1是把一个两个参数普通函数的第一个参数绑定为10，生成了一个新的一个参数的可调用实体体; bf2是把一个类成员函数绑定了类对象，生成了一个像普通函数一样的新的可调用实体; bf3是把类成员函数绑定了类对象和第二个参数，生成了一个新的std::function对象。看懂了上面的例子，下面我们来说说使用bind需要注意的一些事项：

（1）bind预先绑定的参数需要传具体的变量或值进去，对于预先绑定的参数，是pass-by-value的
（2）对于不事先绑定的参数，需要传std::placeholders进去，从_1开始，依次递增。placeholder是pass-by-reference的
（3）bind的返回值是可调用实体，可以直接赋给std::function对象
（4）对于绑定的指针、引用类型的参数，使用者需要保证在可调用实体调用之前，这些参数是可用的
（5）类的this可以通过对象或者指针来绑定

std::function

它是函数、函数对象、函数指针、和成员函数的包装器，可以容纳任何类型的函数对象，函数指针，引用函数，成员函数的指针。
以统一的方式处理函数、函数对象、函数指针、和成员函数。允许保存和延迟执行函数。

函数和成员函数作为function

function是一个拥有任何可以以"(...)"符号进行调用的值的类型。特别地，bind的返回结果可以赋值给function类型。function十分易于使用。（译注：更直观地，可以把function看成是一种表示函数的数据类型，就像函数对象一样。只不过普通的数据类型表示的是数据，function表示的是函数这个抽象概念。）例如：

 1 typedef std::function<float (int x, int y)> f ;// 构造一个函数对象，它能表示的是一个返回值为float，两个参数为int，int的函数  
 2 struct int_div {        // 构造一个可以使用"()"进行调用的函数对象类型  
 3     float operator() (int x, int y) const { return ((float)x)/y; };
 4 };
 5 
 6 void HelloWorld::testing()
 7 {
 8     f f1= int_div();                    // 赋值  
 9     auto result3 = f1( 10, 2);
10 }

成员函数可被看做是带有额外参数的自由函数：

 1 struct int_div {        // 构造一个可以使用"()"进行调用的函数对象类型  
 2     float operator() (int x, int y) const { return ((float)x)/y; };
 3     int int_div_fun( int x ){ return x; };
 4 };
 5 typedef std::function<int (int_div*, int)> f_2;
 6 
 7 bool HelloWorld::init()
 8 {
 9     f_2 f2 = std::mem_fn(&int_div::int_div_fun);            // 指向成员函数
10 
11     int_div int_div_object;
12     int v = f2(&int_div_object, 5);  // 在对象x上用参数5调用X::foo()
13     std::function<int (int)> ff = std::bind( f2, &int_div_object, std::placeholders::_1);    // f的第一个参数是&x
14     v = ff(5);                // 调用x.foo(5)
15 
16 
17 }

可以用function取代函数指针。因为它可以保存函数延迟执行，所以比较适合作为回调函数，也可以把它看做类似于c#中特殊的委托，只有一个成员的委托。

 1 struct int_div {        // 构造一个可以使用"()"进行调用的函数对象类型  
 2     float operator() (int x, int y) const { return ((float)x)/y; };
 3     int int_div_fun( int x ){ return x; };
 4 
 5     int_div( std::function<void()>& f ):m_callback(f){};
 6     void Notify()
 7     {
 8         m_callback();
 9     }
10     std::function<void()> m_callback;
11 };

function还可以作为函数入参，这样可以在函数外部控制函数的内部行为了，让我们的函数变得更加灵活。

void Foo(int x, std::function<void(int)>& f)
{
if(x%2==0)
f(x);
}

void G(int x)
{
cout<<x<<endl;
}

void H(int x)
{
cout<<x+2<<endl;
}

void TestFoo()
{
auto f = std::bind(G, std::placeholders::_1); 
Foo(4, f);

//在Foo函数外面更改f的行为
f = std::bind(H, std::placeholders::_1);
Foo(4, f);
}

extern C的使用

C++是一种面向对象的程序设计语言，为了支持函数的重载，C++对全局函数的处理方式与C有明显的不同，

问题：为什么标准头文件都有类似以下的结构？

#ifndef __INCvxWorksh

#define __INCvxWorksh #ifdef __cplusplus extern " C " { #endif /*...*/ #ifdef __cplusplus } #endif #endif /* __INCvxWorksh */

分析

显然，头文件中的编译宏#ifndef __INCvxWorksh、#define __INCvxWorksh、#endif的作用是防止该头文件被重复引用。那么

#ifdef __cplusplus

extern " C " { #endif #ifdef __cplusplus } #endif

的作用又是什么呢？我们将在下文一一道来。

1、extern "C" 包含双重含义，从字面上即可得到：首先，被它修饰的目标是“extern”的；

其次，被它修饰的目标是“C”的。让我们来详细解读这两重含义。

被extern "C"限定的函数或变量是extern类型的，extern是C/C++语言中表明函数和全局变量作用范围（可见性）的关键字，该关键字告诉编译器，其声明的函数和变量可以在本模块或其它模块中使用。记住，下列语句：

extern int a;

仅仅是一个变量的声明，其并不是在定义变量a，并未为a分配内存空间。变量a在所有模块中作为一种全局变量只能被定义一次，否则会出现连接错误。通常，在模块的头文件中对本模块提供给其它模块引用的函数和全局变量以关键字extern声明，例如：

如果模块B欲引用该模块A中定义的全局变量和函数时只需包含模块A的头文件即可。这样，模块B中调用模块A中的函数时，在编译阶段，模块B虽然找不到该函数，但是并不会报错；它会在连接阶段中从模块A编译生成的目标代码中找到此函数。

与extern对应的关键字是static，被它修饰的全局变量和函数只能在本模块中使用。因此，一个函数或变量只可能被本模块使用时，其不可能被extern “C”修饰。

被extern "C"修饰的变量和函数是按照C语言方式编译和连接的；

2、未加extern “C”声明时的编译方式

首先看看C++中对类似C的函数是怎样编译的。

例如，假设某个函数的原型为：

1 void foo( int x, int y );

该函数被C编译器编译后在符号库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字（不同的编译器可能生成的名字不同，但是都采用了相同的机制，生成的新名字称为“mangled name”），_foo_int_int这样的名字包含了函数名、函数参数数量及类型信息，C++就是靠这种机制来实现函数重载的。

在C++中，函数void foo( int x, int y )与void foo( int x, float y )编译生成的符号是不相同的，后者为_foo_int_float。

同样地，C++中的变量除支持局部变量外，还支持类成员变量和全局变量。用户所编写程序的类成员变量可能与全局变量同名，我们以"."来区分。而本质上，编译器在进行编译时，与函数的处理相似，也为类中的变量取了一个独一无二的名字，这个名字与用户程序中同名的全局变量名字不同。

3、未加extern "C"声明时的连接方式

假设在C++中，模块A的头文件如下：

// 模块A头文件　moduleA.h

#ifndef MODULE_A_H #define MODULE_A_H int foo( int x, int y ); #endif

在模块B中引用该函数：

#include "moduleA.h"

foo( 2, 3);

实际上，在连接阶段，连接器会从模块A生成的目标文件moduleA.obj中寻找_foo_int_int这样的符号！

4、加extern "C"声明后的编译和连接方式

加extern "C"声明后，模块A的头文件变为：

// 模块A头文件　moduleA.h

#ifndef MODULE_A_H #define MODULE_A_H extern " C " int foo( int x, int y ); #endif

在模块B的实现文件中仍然调用foo( 2,3 )，其结果是：

（1）模块A编译生成foo的目标代码时，没有对其名字进行特殊处理，采用了C语言的方式；

（2）连接器在为模块B的目标代码寻找foo(2,3)调用时，寻找的是未经修改的符号名_foo。

　　如果在模块A中函数声明了foo为extern "C"类型，而模块B中包含的是extern int foo( int x, int y ) ，则模块B找不到模块A中的函数；反之亦然

所以，可以用一句话概括extern “C”这个声明的真实目的（任何语言中的任何语法特性的诞生都不是随意而为的，来源于真实世界的需求驱动。我们在思考问题时，不能只停留在这个语言是怎么做的，还要问一问它为什么要这么做，动机是什么，这样我们可以更深入地理解许多问题）：实现C++与C及其它语言的混合编程。

5.extern "C"的惯用法

（1）在C++中引用C语言中的函数和变量，在包含C语言头文件（假设为cExample.h）时，需进行下列处理：

extern "C"

{ #include " cExample.h " }

而在C语言的头文件中，对其外部函数只能指定为extern类型，C语言中不支持extern "C"声明，在.c文件中包含了extern "C"时会出现编译语法错误。

笔者编写的C++引用C函数例子工程中包含的三个文件的源代码如下：

/* c语言头文件：cExample.h */

#ifndef C_EXAMPLE_H #define C_EXAMPLE_H extern int add( int x, int y); #endif /* c语言实现文件：cExample.c */ #include " cExample.h " int add( int x, int y ) { return x + y; }

// c++实现文件，调用add：cppFile.cpp

extern " C " { #include " cExample.h " } int main( int argc, char* argv[]) { add( 2, 3); return 0; }

如果C++调用一个C语言编写的.DLL时，当包括.DLL的头文件或声明接口函数时，应加

extern "C" {　}

（2）在C中引用C++语言中的函数和变量时，C++的头文件需添加extern "C"，但是在C语言中不能直接引用声明了extern "C"的该头文件，应该仅将C文件中将C++中定义的extern "C"函数声明为extern类型。

笔者编写的C引用C++函数例子工程中包含的三个文件的源代码如下：

//C++头文件 cppExample.h

#ifndef CPP_EXAMPLE_H #define CPP_EXAMPLE_H extern " C " int add( int x, int y ); #endif // C++实现文件 cppExample.cpp #include " cppExample.h " int add( int x, int y )

return x + y; }

/* C实现文件 cFile.c