C++类型擦除与`std::function`性能探索

栏目: C++ · 发布时间: 5年前

内容简介:对于Python这种动态类型语言来说,是不存在“类型擦除”这个概念的。Python对象的行为并不由接口定义,而是由“当前方法和属性的集合”决定。所以,以下的代码是完全合法的:但是对于C++这种静态类型语言来讲,我们就不能使用这种语法:

什么是类型擦除

对于 Python 这种动态类型语言来说,是不存在“类型擦除”这个概念的。Python对象的行为并不由接口定义,而是由“当前方法和属性的集合”决定。

所以,以下的代码是完全合法的:

class Foo(object):
    def print(self):
        print 'foo'

class Bar(object):
    def print(self):
        print 'bar'

def do_print(obj):
    print obj.print()

do_print(Foo()) // print 'foo'
do_print(Bar()) // print 'bar'

但是对于C++这种静态类型语言来讲,我们就不能使用这种语法:

class Foo {
public:
    void print() { cout << "foo" << endl; }
};

class Bar {
public:
    void print() { cout << "bar" << endl; }
};

void do_print(??? obj) { // <--
    obj.print();
}

do_print(Foo());
do_print(Bar());

熟悉C++的同学们都知道,因为 FooBar 的类型不同,我们不能直接将不同类型的实例传入 do_print(obj) 函数。所以我们需要一种方法擦除类型信息,提供一种类型的抽象。使得实现不依赖于具体类型,而是依赖于类型抽象。

C++中类型擦除的实现

简单粗暴 - void*

写过 C语言 同学们一定非常熟悉 qsort 函数的写法:

// http://www.cplusplus.com/reference/cstdlib/qsort/
int compare (const void * a, const void * b) {
    return ( *(int*)a - *(int*)b );
}

int main () {
    int values[] = {1, 3, 5, 2, 4, 6};
    qsort (values, 6, sizeof(int), compare);
    for (int i=0; i<6; i++)
        printf ("%d ",values[n]);
  return 0;
}

这里的 compare(const void*, const void*) 函数就是C语言风格的类型擦除,可以支持不同类型的指针类型传入。但是缺陷是在函数中,我们仍然需要将已擦除的类型恢复,以读取其中的数据。

这种类型擦除方法,并不会带开额外的开销。但是这样的强制类型隐含着类型不匹配的风险,需要 程序员 格外注意。

面向对象的经典方法 - 虚函数(virtual function)

C++做为C语言的进化,引入了面向对象的理念。而多态,做为面向对象编程的一个重要特性,为我们的代码带来了更多的弹性。

对于上面的例子,我们可以使用以下的代码来实现:

class IPrintable {
public:
    virtual void print() = 0;
};

class Foo : public IPrintable {
public:
    virtual void print() { cout << "foo" << endl; }
};

class Bar : public IPrintable {
public:
    virtual void print() { cout << "bar" << endl; }
};

void do_print(IPrintable* obj) {
    obj->print();
}

int main() {
    do_print(new Foo());
    do_print(new Bar());
    return 0;
};

在这里,我们使用了一个 IPrintable 基类,擦除了子类 FooBar 的具体类型信息。也就是说,只要子类实现了基类的接口,就可以做为参数传入 do_print(obj) 中。这样的好处是我们只需要为继承同样接口的类型完成一套实现,提供了更好的封装与抽象。

但是,这种实现的问题在于虚函数的调用是有额外的开销的。需要进行一次运行时虚表的查找,才可以确定对象需要调用哪一个函数。

使用模板(template)

C++提供了模板,支持将类型以模板参数形式传入参数。使得我们可以以一种独立于特定类型的方式编写代码。

我们可以改写上文中的 do_print(obj) 函数,使其可以支持不同的类型:

template <typename T>
void do_print(T obj) {
    obj.print();
}

这里,传入参数的类型 T 无需继承 IPrintable 接口,只要其实现了 print() 成员函数即可做为对象传入。

C++模板的类型擦除作用于编译期,可以尽早的发现风险,同时(一般来说)不影响运行时的性能。

注意:Java/C#的泛型(generic)语法与C++的模板非常类似,但是Java/C#的泛型是作用于运行时的。这里注意区分二者的区别。

但是模板也有其局限性。模板有隐含的接口语义,但是由于模板所使用的对象并没有共同的基类(接口),所以它不能使用一个统一的容器来储存对象。

??? objs[] = { new Foo(), new Bar() };

C++类型擦除实战 —— std::function

在C语言中,我们要表示一个函数对象只能使用函数本身以及函数指针。但是在C++中,我们有了更多的选择:

std::bind
std::function

上面的这些对象,我们可以统称为可调用(callable)对象。也就是说,我们可以使用类似 f(obj) 的语法,以函数形式调用这些对象。

思考以下的场景:我们想要实现一个回调函数。这个函数是用户定义的,可以是以上可调用对象的任意一种。那么我们应该用什么类型来表示这个回调函数对象呢?

是的,答案就是 std::function 。C++中的 std::function 为我们提供了对可调用对象的抽象。我们可以使用 std::function 封装可调用对象,从而擦除其类型信息,使用统一的方法对其进行调用。

请参考以下代码:

// http://www.cplusplus.com/reference/functional/function/function/
#include <iostream>     // std::cout
#include <functional>   // std::function, std::negate

// a function:
int half(int x) {return x/2;}

// a function object class:
struct third_t {
  int operator()(int x) {return x/3;}
};

// a class with data members:
struct MyValue {
  int value;
  int fifth() {return value/5;}
};

int main () {
  std::function<int(int)> fn1 = half;                    // function
  std::function<int(int)> fn2 = &half;                   // function pointer
  std::function<int(int)> fn3 = third_t();               // function object
  std::function<int(int)> fn4 = [](int x){return x/4;};  // lambda expression
  std::function<int(int)> fn5 = std::negate<int>();      // standard function object

  std::cout << "fn1(60): " << fn1(60) << '\n';
  std::cout << "fn2(60): " << fn2(60) << '\n';
  std::cout << "fn3(60): " << fn3(60) << '\n';
  std::cout << "fn4(60): " << fn4(60) << '\n';
  std::cout << "fn5(60): " << fn5(60) << '\n';

  // stuff with members:
  std::function<int(MyValue&)> value = &MyValue::value;  // pointer to data member
  std::function<int(MyValue&)> fifth = &MyValue::fifth;  // pointer to member function

  MyValue sixty {60};

  std::cout << "value(sixty): " << value(sixty) << '\n';
  std::cout << "fifth(sixty): " << fifth(sixty) << '\n';

  return 0;
}

std::function 的缺陷

std::function 的类型擦除功能异常强大,几乎可以封装所有的可调用类型。但是,语法上面的便利却会带来了性能上的损失。

benchmark 结果上我们可以看出,在 O2 的优化参数下,函数调用(包括函数、函数模板和仿函数)、函数指针和lambda的性能相仿。而虚函数大概需要花费5倍左右的时间,而 std::function 则需要花费6倍以上的时间。对于一个会被经常调用到的函数,带来的额外的性能开销是不可以忽略的。

method Linux (Azure VM, E5-2673 v3, -O0) Linux (Azure VM, E5-2673 v3, -O2)
Function 12.4s 1.2s
Function Ptr 13.5s 1.2s
Inline Lambda 12.7s 1.2s
Virtual Function 14.1s 6.3s
std::function 77.3s 7.2s

究其原因,是由于 std::function 的模板参数中只提供了参数类型和返回值类型,所以为了进行类型擦除,其中内置了一个虚函数。所以一次 std::function 调用会引发隐式的多次函数调用,其中还包含着一次虚函数的调用。所以性能下降也就不难解释了。

解决方案

可以确定的是,除非必要,不要使用 std::function

例如,在 std::sort 中,我们使用模板传入可调用类型,这样就可以避免 std::function 的额外开销:

template< class RandomIt, class Compare >
void sort( RandomIt first, RandomIt last, Compare comp );

又例如我们可以避免使用不同的可调用类型来规避类型擦除,如统一使用函数指针。在C++14之后,inline lambda也可以表示为函数指针,所以我们也可以通过闭包来封装其它的可调用对象了。

当然,也可以自己造个 轮子 ,这就又是另一个故事了。

写在最后

新的C++规范给我们带来了很多的语法糖。对于传统C++程序员来说,好处在于我们可以写出更舒服的,更符合直觉的代码,但缺点是我们需要了解更多语言背后的东西。所以对于自己不熟悉的新式语法,无论看起来多么诱人,也需要多加谨慎。

参考链接


以上所述就是小编给大家介绍的《C++类型擦除与`std::function`性能探索》,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对 码农网 的支持!

查看所有标签

猜你喜欢:

本站部分资源来源于网络,本站转载出于传递更多信息之目的,版权归原作者或者来源机构所有,如转载稿涉及版权问题,请联系我们

中标

中标

阁策 / 四川人民出版社 / 2019-3-1 / 58.00元

一部IT销售的血泪史 一幅招投标人物群像图一起来看看 《中标》 这本书的介绍吧!

HTML 压缩/解压工具
HTML 压缩/解压工具

在线压缩/解压 HTML 代码

MD5 加密
MD5 加密

MD5 加密工具

HSV CMYK 转换工具
HSV CMYK 转换工具

HSV CMYK互换工具