boost::bind与虚函数,运行效率,谁高??100分!有答案了立马结贴给分.

2009-04-01 01:43:55 781 阅读 AI 写同款 · GEO 优化AI 选题数据监测一键分发 ›

C++11四大核心特性：万能引用、完美转发、可变模板与Lambda深度解析 C++11彻底重塑了现代C++的泛型编程范式，其核心在于四组原生机制——万能模板（Universal Reference）、完美转发（Perfect Forwarding）、可变参数模板（Variadic Templates）和Lambda表达式。它们共同构成零开销抽象的基础：万能模板通过引用折叠实现类型推导的灵活性；完美转发借助std::forward保留值类别，保障move语义端到端生效；可变参数模板支持编译期参数展开，支撑类型安全的函数接口与配置注入；Lambda则将闭包转化为轻量级函数对象，推动回调阅读详情

最近在看boost,从设计角度来讲很喜欢boost::lambda,boost::function,boost::bind , 这三者结合好,完全可以更优雅的实现"晚绑定",也就是OOP里多态要的效果...

就是不知从纯效率来讲boost::bind高还是虚函数高呢??因为我们都知道虚函数多一个VTBL,多一次寻址,效率是赶不上普通函数的...不知道相比boost:bind,谁更快些?

...全文

C++智能指针与STL高阶应用：从原理到实战的进阶指南在C++编程中，内存管理和数据结构的有效运用是提升代码质量与性能的核心。智能指针通过自动化资源管理，解决了传统手动内存分配可能引发的内存泄漏问题，其原理基于引用计数与所有权语义，为复杂系统提供了安全的基础。结合STL容器与算法，开发者能够构建高效、可维护的应用程序，尤其在并发编程和回调机制中展现技术价值。本文聚焦于shared_ptr的定制删除器与内存池集成、weak_ptr在缓存设计中的应用，以及std::function与STL算法的高阶技巧，通过实战案例如异步任务队列，帮助开发者深入理解这些工具在工程阅读详情

knift1128

C++ 语言 65,214 成员 250,514 内容

+ 关注 + 加入社区

切换为时间正序

JCIphone 2012-10-15

打赏
举报

试了一下，debug下boost::bind差太多，但是release下都差不多。

没有whoke说的2.5倍吧

学习了。。。

emptyness 2011-08-29

打赏
举报

boost::bind 太牛了.release效果非常好. 又试了下构造和析构 ,可惜不好判断release版本,是否优化了我的局部变量构造. 感觉效率可以接受.

whoke 2009-11-11

打赏
举报

楼上的都没有用Release版本测试吧。
Release版本的测试结果是虚函数是bind方式的2.5-3倍。

caocheng8230 2009-10-28

打赏
举报

不感用boost::binding了,
受到启发了.

knift1128 2009-04-03

打赏
举报

看来用boost的不多~~~~

机智的呆呆 2009-04-03

打赏
举报

std::bind1st使用过程中要生成几个临时的对象，通过对象调用operator（）,所以理论上讲比虚函数效率低，
没看过boost::bind，感觉应该类似把

knift1128 2009-04-03

打赏
举报

同时还看出来虚函数调用代价非常小,同样的代码,和普通函数只有1%-2%之间差距.....看来还是虚函数靠谱.

knift1128 2009-04-03

打赏
举报

昨天我也写了一段程序测试了~~boost::bind在MAX_LOOP各个数量级下都要比virtual function慢7-8倍~~~

郁闷~~~这就是boost华丽的代价.



#include <boost/bind.hpp>

#include <boost/function.hpp>

#include <Windows.h>

#include <stdio.h>

#define MAX_LOOP 10000000

#define CONST_NUM 3



typedef boost::function<void()> task;

class VBase

{

public:

	virtual void say();

};



class VChild:public VBase

{

public:

	VChild(int);

	void say();

private:

	int count;

};



class BChild

{

public:

	BChild(int);

	void say();

private:

	int count;

};



void VBase::say()

{



}



VChild::VChild(int count)

{

	this->count = count;

}

void VChild::say()

{

	this->count = this->count*CONST_NUM;

	this->count = this->count/CONST_NUM;

	this->count = this->count+CONST_NUM;

	this->count = this->count-CONST_NUM;

}



BChild::BChild(int c)

{

	this->count = c;

}



void BChild::say()

{

	this->count = this->count*CONST_NUM;

	this->count = this->count/CONST_NUM;

	this->count = this->count+CONST_NUM;

	this->count = this->count-CONST_NUM;

}



void runVFunction(VBase *pObject)

{

	int start = ::GetTickCount();

	for(int i=0 ; i < MAX_LOOP ;++i)

	{

		pObject->say();

	}

	printf("virtual function :%ims\n",(::GetTickCount()-start));

}



void runBind(task func)

{

	int start = ::GetTickCount();

	for(int i=0 ; i < MAX_LOOP ;++i)

	{

		func();

	}

	printf("boost::bind :%ims\n",(::GetTickCount()-start));

}



int main()

{

	VChild *vObj = new VChild(10);

	BChild *bObj = new BChild(10);

	runVFunction(vObj);

	runBind(boost::bind(&BChild::say,bObj));

	system("pause");

	return 0;

}

zhuxueling 2009-04-03

打赏
举报



//

// bind_vir_test.cxx					

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~	

  					

// file create   2009-04-03		

// last update   2009-04-03		

//

// Bugs Report   <zhuxueling@live.cn>	

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~	



#include<traxex/Function.hpp>

#include<traxex/ToolKit.hpp>

#include<iostream>

using namespace Traxex;



long long int  i;



struct B{

     virtual void do_someting() = 0;

};



struct T:public B{

     void do_someting(){

	  i *=2;

	  i /=2;

	  i +=2;

     }

};



int test0(){

     double time_start = time_now();

     T t;

     for( int i = 0; i < 100000000; ++i){

	  t.do_someting();

     }

     double time_end  = time_now();

     double time_used = time_end - time_start;

     std::cout << "time_use0: " << time_used << std::endl;

}



int test1(){

     double time_start = time_now();

     T t;

     function<void()> func = bind( &T::do_someting, &t);

     for( int i = 0; i < 100000000; ++i){

	  func();

     }

     double time_end  = time_now();

     double time_used = time_end - time_start;

     std::cout << "time_use1: " << time_used << std::endl;

}



int test2(){

     double time_start = time_now();

     T t;

     for( int i = 0; i < 100000000; ++i){

	  function<void()> func = bind( &T::do_someting, &t);

	  func();

     }

     double time_end  = time_now();

     double time_used = time_end - time_start;

     std::cout << "time_use2: " << time_used << std::endl;

}



int test3(){

     double time_start = time_now();

     B *t = new T();

     for( int i = 0; i < 100000000; ++i){

	  t->do_someting();

     }

     double time_end  = time_now();

     double time_used = time_end - time_start;

     std::cout << "time_use3: " << time_used << std::endl;

}



int main(){

     test0();

     test1();

     test2();

     test3();

}

zhuxueling 2009-04-03

打赏
举报

我对一个小函数调用1亿次，得到下面的数据。

time_use0: 1.63758 直接调用
time_use1: 7.25978 调用binder得到的functor
time_use2: 33.8029 先bind，之后调用binder得到的functor
time_use3: 1.70608 使用虚函数

可以看出，在用时上，1亿次调用中，

1。虚函数会多出 0.07秒左右，多出的时间用在虚函数表上。
2。对bind包装后的functor调用会多出6.6秒左右，多出的时间会在自动封包，拆包函数上。
3。如果构造了一个functor，之后调用之，时间会更长，32.2秒左右。多时的时间是functor的构造与析构，封包与拆包。

___________________________________________
Linux linux 2.6.28-ARCH , gcc (GCC) 4.3.3

ypb362148418 2009-04-01

打赏
举报

我觉得虚函数快一些

「已注销」 2009-04-01

打赏
举报

很多时候我更喜欢解藕，而牺牲效率。

「已注销」 2009-04-01

打赏
举报

如果是VS9SP1的话，应该是tr1::bind了吧。
没必要用boost。
喜欢tr1::bind，更喜欢其解藕！

knift1128 2009-04-01

打赏
举报

[Quote=引用 8 楼 taodm 的回复:]
能不能举个bind和虚函数可以互替的场合？
[/Quote]
重新整理了一下这个伪代码..

虚函数版



class BaseProtocol

{

public:

    virtual void onData(void *pData,sizt_t len);

};

class ServerProtocol:baseProtocol

{

public:

    virtual void onData(void *pData,sizt_t len)

    {

    //有数据来了~

    }

    virtual void onAccept(socket *pClient)

    {

    //有连接来了~

    }

};



//网络处理层,形参是基协议类指针,OOP的多态

void core(BaseProtocol *p)

{

    //这里socket处理

    while(1)

   {

    int n = epoll_wait(.....);

    //有连接了就调 p->onAccept

    //有数据了就调 p->onData

   }

}

int main()

{

//这里我要处理ServerProtocol这个协议

    ServerProtocol *pService = new ServerProtocol();

    core(pService);//工作     传的是ServerProtocol指针

}

boost::bind版



//这个是boost::function对象,类似C#的委托.

typedef boost::function<void (socket *)> acceptHandle;

typedef boost::function<void (void *,size_t)>dataHandle;

class BaseProtocol

{

public:

    //普通成员函数即可

    void onData(void *pData,sizt_t len);

};

class ServerProtocol

{

public:

    void onData(void *pData,sizt_t len)

    {

     //有数据

    }

    void onAccept(socket *pClient)

    {

     // 有连接

    }

};

//这里传boost::function  ,核心思想是,只关心能调用的东西的"样子"

void core(acceptHandle ah,dataHandle dh)

{

    //这里处理网络

    while(1)

    {

        int n = epoll_wait(.....);

        //有连接了就 直接 ah(....);

        //有数据了就调 dh(....);

    }

}

int main()

{

    //这里我要处理ServerProtocol这个协议

    ServerProtocol *pService = new ServerProtocol();

    core(boost:bind(&ServerProtocol::onAccept,pService),boost::bind(&ServerProtocol::onData,pService,_1,_2));//工作 boost::bind把协议对象,函数联系起来,当然core是不关心这些的,他只关心"样子"

}

taodm 2009-04-01

打赏
举报

那你实际测一下不就知道效率了。

knift1128 2009-04-01

打赏
举报

[Quote=引用 8 楼 taodm 的回复:]
能不能举个bind和虚函数可以互替的场合？
[/Quote]

你要封装一个Socket网络框架.
虚函数的"晚绑定":



class BaseProtocol

{

public:

virtual void onData(void *pData,sizt_t len);

virtual void onAccept(socket *pClient);

};

class ServerProtocol:baseProtocol

{

public:

virtual void onData(void *pData,sizt_t len){}

virtual void onAccept(socket *pClient){}

};

//

void core(BaseProtocol *p)

{

//这里socket处理

while(1)

{

int n = epoll_wait(.....);

//有连接了就调 p->onAccept

//有数据了就调 p->onData

}

}

int main()

{

//这里我要处理ServerProtocol这个协议

ServerProtocol *pService = new ServerProtocol();

core(pService);//工作

}

用boost::bind,无需虚函数,也无需要继承...协议与协议完全解藕。



typedef boost::function<void (socket *)> acceptHandle;

typedef boost::function<void (void *,size_t)>dataHandle;

class BaseProtocol

{

public:

void onData(void *pData,sizt_t len);

void onAccept(socket *pClient);

};

class ServerProtocol

{

public:

void onData(void *pData,sizt_t len){}

void onAccept(socket *pClient){}

};

void core(acceptHandle ah,dataHandle dh)

{

//这里处理网络

while(1)

{

int n = epoll_wait(.....);

//有连接了就 直接 ah(....);

//有数据了就调 dh(....);

}

}

int main()

{

//这里我要处理ServerProtocol这个协议

ServerProtocol *pService = new ServerProtocol();

core(boost:bind(&ServerProtocol::onAccept,pService),boost::bind(&ServerProtocol::onData,pService,_1,_2));//工作

}