linux上封装的c++的finally

最新推荐文章于 2023-10-31 12:51:39 发布
最新推荐文章于 2023-10-31 12:51:39 发布
阅读量1.1k 收藏
点赞数
分类专栏： 1. 編程 文章标签： c++ 模板 RAII
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/truexf/article/details/50518164
版权

很多编程语言里面有

try...finally...这种结构来保证无论是否发生异常，finallly后面的代码一定会被执行，这个地方常常放置关闭文件、句柄、free对象、解锁等等操作。但c++并没有这种语法结构。号称强大的c++为啥没有这个特性呢？因为c++本身实现这种功能的方式的逼格更高一些。c++有一个RAII的概念，具体可以百度 “c++ RAII”

以下的代码就是利用RAII来实现一组通用的finally功能，其中利用到了模板、函数对象等概念


/*
 * AutoObject.hpp
 *
 *  Created on: Jan 23, 2015
 *      Author: root
 */

//使用方式
/*
int myfunc();
int myfunc1(string arg)；

void myfunc()
{
AutoClass c1(AutoFunc(myfunc));
AutoClass c2(AutoFunc(myfunc1,string("hello")));

在作用域结束的时候会调用上面两个AutoFunc返回的对象的析构，从而调用了myfunc和myfunc1;
}

*/


#ifndef FYSLIB_AUTOOBJECT_HPP_
#define FYSLIB_AUTOOBJECT_HPP_

#include <pthread.h>

namespace fyslib{

class AutoMutex
{
public:
	pthread_mutex_t *f_mutex;
	AutoMutex(pthread_mutex_t *mutex){
		f_mutex = mutex;
		pthread_mutex_lock(f_mutex);
	}
	~AutoMutex(){
		pthread_mutex_unlock(f_mutex);
	}
private:
	AutoMutex(const AutoMutex&);
	AutoMutex& operator = (const AutoMutex&);
};

class BaseFuncClass
{
public:
  BaseFuncClass(){};
  virtual ~BaseFuncClass(){};
  virtual void ExecFunc(){};
private:
  BaseFuncClass(const BaseFuncClass&);
  BaseFuncClass& operator=(const BaseFuncClass&);
};

template<typename OBJTYPE,typename FUNCTYPE>
class ObjFuncClass0: public BaseFuncClass
{
public:
  ObjFuncClass0(OBJTYPE *obj,FUNCTYPE func){m_func = func;m_obj = obj;}
  void ExecFunc(){if (m_func && m_obj) m_obj->*m_func();}
private:
  FUNCTYPE m_func;
  OBJTYPE *m_obj;
};

template<typename OBJTYPE,typename FUNCTYPE,typename ARGTYPE1>
class ObjFuncClass1: public BaseFuncClass
{
public:
  ObjFuncClass1(OBJTYPE *obj,FUNCTYPE func,ARGTYPE1 arg1){m_func = func;m_obj = obj; m_arg1 = arg1;}
  void ExecFunc()
  {
	  if (m_func && m_obj)
		  (m_obj->*m_func)(m_arg1);
  }
private:
  FUNCTYPE m_func;
  OBJTYPE *m_obj;
  ARGTYPE1 m_arg1;
};

template<typename OBJTYPE,typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2>
class ObjFuncClass2: public BaseFuncClass
{
public:
  ObjFuncClass2(OBJTYPE *obj,FUNCTYPE func,ARGTYPE1 arg1,ARGTYPE2 arg2)
  {
    m_func = func;
    m_obj = obj;
    m_arg1 = arg1;
    m_arg2 = arg2;
  }
  void ExecFunc()
  {
	    if (m_func && m_obj)
	      (m_obj->*m_func)(m_arg1,m_arg2);
  }
private:
  FUNCTYPE m_func;
  OBJTYPE *m_obj;
  ARGTYPE1 m_arg1;
  ARGTYPE2 m_arg2;
};

template<typename OBJTYPE,typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2,typename ARGTYPE3>
class ObjFuncClass3: public BaseFuncClass
{
public:
  ObjFuncClass3(OBJTYPE *obj,FUNCTYPE func,ARGTYPE1 arg1,ARGTYPE2 arg2,ARGTYPE3 arg3)
  {
    m_func = func;
    m_obj = obj;
    m_arg1 = arg1;
    m_arg2 = arg2;
    m_arg3 = arg3;
  }
  void ExecFunc()
  {
	    if (m_func && m_obj)
	      (m_obj->*m_func)(m_arg1,m_arg2,m_arg3);
  }
private:
  FUNCTYPE m_func;
  OBJTYPE *m_obj;
  ARGTYPE1 m_arg1;
  ARGTYPE2 m_arg2;
  ARGTYPE3 m_arg3;
};

template<typename OBJTYPE,typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2,typename ARGTYPE3
,typename ARGTYPE4
>
class ObjFuncClass4: public BaseFuncClass
{
public:
  ObjFuncClass4(OBJTYPE *obj,FUNCTYPE func,ARGTYPE1 arg1,ARGTYPE2 arg2,ARGTYPE3 arg3,ARGTYPE4 arg4)
  {
    m_func = func;
    m_obj = obj;
    m_arg1 = arg1;
    m_arg2 = arg2;
    m_arg3 = arg3;
    m_arg4 = arg4;
  }
  void ExecFunc()
  {
	    if (m_func && m_obj)
	      (m_obj->*m_func)(m_arg1,m_arg2,m_arg3,m_arg4);
  }
private:
  FUNCTYPE m_func;
  OBJTYPE *m_obj;
  ARGTYPE1 m_arg1;
  ARGTYPE2 m_arg2;
  ARGTYPE3 m_arg3;
  ARGTYPE4 m_arg4;
};

template<typename OBJTYPE,typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2,typename ARGTYPE3
,typename ARGTYPE4,typename ARGTYPE5
>
class ObjFuncClass5: public BaseFuncClass
{
public:
  ObjFuncClass5(OBJTYPE *obj,FUNCTYPE func,ARGTYPE1 arg1,ARGTYPE2 arg2,ARGTYPE3 arg3,ARGTYPE4 arg4,ARGTYPE5 arg5)
  {
    m_func = func;
    m_obj = obj;
    m_arg1 = arg1;
    m_arg2 = arg2;
    m_arg3 = arg3;
    m_arg4 = arg4;
    m_arg5 = arg5;
  }
  void ExecFunc()
  {
	    if (m_func && m_obj)
	      (m_obj->*m_func)(m_arg1,m_arg2,m_arg3,m_arg4,m_arg5);
  }
private:
  FUNCTYPE m_func;
  OBJTYPE *m_obj;
  ARGTYPE1 m_arg1;
  ARGTYPE2 m_arg2;
  ARGTYPE3 m_arg3;
  ARGTYPE4 m_arg4;
  ARGTYPE5 m_arg5;
};

template<typename OBJTYPE,typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2,typename ARGTYPE3
,typename ARGTYPE4,typename ARGTYPE5,typename ARGTYPE6
>
class ObjFuncClass6: public BaseFuncClass
{
public:
  ObjFuncClass6(OBJTYPE *obj,FUNCTYPE func,ARGTYPE1 arg1,ARGTYPE2 arg2,ARGTYPE3 arg3
    ,ARGTYPE4 arg4,ARGTYPE5 arg5,ARGTYPE6 arg6)
  {
    m_func = func;
    m_obj = obj;
    m_arg1 = arg1;
    m_arg2 = arg2;
    m_arg3 = arg3;
    m_arg4 = arg4;
    m_arg5 = arg5;
    m_arg6 = arg6;
  }
  void ExecFunc()
  {
	    if (m_func && m_obj)
	      (m_obj->*m_func)(m_arg1,m_arg2,m_arg3,m_arg4,m_arg5,m_arg6);
  }
private:
  FUNCTYPE m_func;
  OBJTYPE *m_obj;
  ARGTYPE1 m_arg1;
  ARGTYPE2 m_arg2;
  ARGTYPE3 m_arg3;
  ARGTYPE4 m_arg4;
  ARGTYPE5 m_arg5;
  ARGTYPE6 m_arg6;
};

template<typename OBJTYPE,typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2,typename ARGTYPE3
,typename ARGTYPE4,typename ARGTYPE5,typename ARGTYPE6
,typename ARGTYPE7
>
class ObjFuncClass7: public BaseFuncClass
{
public:
  ObjFuncClass7(OBJTYPE *obj,FUNCTYPE func,ARGTYPE1 arg1,ARGTYPE2 arg2,ARGTYPE3 arg3
    ,ARGTYPE4 arg4,ARGTYPE5 arg5,ARGTYPE6 arg6
    ,ARGTYPE7 arg7)
  {
    m_func = func;
    m_obj = obj;
    m_arg1 = arg1;
    m_arg2 = arg2;
    m_arg3 = arg3;
    m_arg4 = arg4;
    m_arg5 = arg5;
    m_arg6 = arg6;
    m_arg7 = arg7;
  }
  void ExecFunc()
  {
	    if (m_func && m_obj)
	      (m_obj->*m_func)(m_arg1,m_arg2,m_arg3,m_arg4,m_arg5,m_arg6,m_arg7);
  }
private:
  FUNCTYPE m_func;
  OBJTYPE *m_obj;
  ARGTYPE1 m_arg1;
  ARGTYPE2 m_arg2;
  ARGTYPE3 m_arg3;
  ARGTYPE4 m_arg4;
  ARGTYPE5 m_arg5;
  ARGTYPE6 m_arg6;
  ARGTYPE7 m_arg7;
};

template<typename OBJTYPE,typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2,typename ARGTYPE3
,typename ARGTYPE4,typename ARGTYPE5,typename ARGTYPE6
,typename ARGTYPE7,typename ARGTYPE8
>
class ObjFuncClass8: public BaseFuncClass
{
public:
  ObjFuncClass8(OBJTYPE *obj,FUNCTYPE func,ARGTYPE1 arg1,ARGTYPE2 arg2,ARGTYPE3 arg3
    ,ARGTYPE4 arg4,ARGTYPE5 arg5,ARGTYPE6 arg6
    ,ARGTYPE7 arg7,ARGTYPE8 arg8)
  {
    m_func = func;
    m_obj = obj;
    m_arg1 = arg1;
    m_arg2 = arg2;
    m_arg3 = arg3;
    m_arg4 = arg4;
    m_arg5 = arg5;
    m_arg6 = arg6;
    m_arg7 = arg7;
    m_arg8 = arg8;
  }
  void ExecFunc()
  {
	    if (m_func && m_obj)
	      (m_obj->*m_func)(m_arg1,m_arg2,m_arg3,m_arg4,m_arg5,m_arg6,m_arg7,m_arg8);
  }
private:
  FUNCTYPE m_func;
  OBJTYPE *m_obj;
  ARGTYPE1 m_arg1;
  ARGTYPE2 m_arg2;
  ARGTYPE3 m_arg3;
  ARGTYPE4 m_arg4;
  ARGTYPE5 m_arg5;
  ARGTYPE6 m_arg6;
  ARGTYPE7 m_arg7;
  ARGTYPE8 m_arg8;
};

template<typename OBJTYPE,typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2,typename ARGTYPE3
,typename ARGTYPE4,typename ARGTYPE5,typename ARGTYPE6
,typename ARGTYPE7,typename ARGTYPE8,typename ARGTYPE9
>
class ObjFuncClass9: public BaseFuncClass
{
public:
  ObjFuncClass9(OBJTYPE *obj,FUNCTYPE func,ARGTYPE1 arg1,ARGTYPE2 arg2,ARGTYPE3 arg3
    ,ARGTYPE4 arg4,ARGTYPE5 arg5,ARGTYPE6 arg6
    ,ARGTYPE7 arg7,ARGTYPE8 arg8,ARGTYPE9 arg9)
  {
    m_func = func;
    m_obj = obj;
    m_arg1 = arg1;
    m_arg2 = arg2;
    m_arg3 = arg3;
    m_arg4 = arg4;
    m_arg5 = arg5;
    m_arg6 = arg6;
    m_arg7 = arg7;
    m_arg8 = arg8;
    m_arg9 = arg9;
  }
  void ExecFunc()
  {
	    if (m_func && m_obj)
	      (m_obj->*m_func)(m_arg1,m_arg2,m_arg3,m_arg4,m_arg5,m_arg6,m_arg7,m_arg8,m_arg9);
  }
private:
  FUNCTYPE m_func;
  OBJTYPE *m_obj;
  ARGTYPE1 m_arg1;
  ARGTYPE2 m_arg2;
  ARGTYPE3 m_arg3;
  ARGTYPE4 m_arg4;
  ARGTYPE5 m_arg5;
  ARGTYPE6 m_arg6;
  ARGTYPE7 m_arg7;
  ARGTYPE8 m_arg8;
  ARGTYPE9 m_arg9;
};

template<typename OBJTYPE,typename FUNCTYPE>
ObjFuncClass0<OBJTYPE,FUNCTYPE> *ObjAutoFunc(OBJTYPE *obj,FUNCTYPE func)
{
  return new ObjFuncClass0<OBJTYPE,FUNCTYPE>(obj,func);
}

template<typename OBJTYPE,typename FUNCTYPE,typename ARGTYPE1>
ObjFuncClass1<OBJTYPE,FUNCTYPE,ARGTYPE1> *ObjAutoFunc(OBJTYPE *obj,FUNCTYPE func,ARGTYPE1 arg1)
{
  return new ObjFuncClass1<OBJTYPE,FUNCTYPE,ARGTYPE1>(obj,func,arg1);
}

template<typename OBJTYPE,typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2>
ObjFuncClass2<OBJTYPE,FUNCTYPE,ARGTYPE1,ARGTYPE2> *ObjAutoFunc(OBJTYPE *obj,FUNCTYPE func,ARGTYPE1 arg1,ARGTYPE2 arg2)
{
  return new ObjFuncClass2<OBJTYPE,FUNCTYPE,ARGTYPE1,ARGTYPE2>(obj,func,arg1,arg2);
}

template<typename OBJTYPE,typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2,typename ARGTYPE3>
ObjFuncClass3<OBJTYPE,FUNCTYPE,ARGTYPE1,ARGTYPE2,ARGTYPE3>
*ObjAutoFunc(OBJTYPE *obj,FUNCTYPE func
             ,ARGTYPE1 arg1,ARGTYPE2 arg2,ARGTYPE3 arg3)
{
  return new ObjFuncClass3<OBJTYPE,FUNCTYPE,ARGTYPE1,ARGTYPE2,ARGTYPE3>(obj,func,arg1,arg2,arg3);
}

template<typename OBJTYPE,typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2,typename ARGTYPE3
  ,typename ARGTYPE4>
ObjFuncClass4<OBJTYPE,FUNCTYPE,ARGTYPE1,ARGTYPE2,ARGTYPE3,ARGTYPE4>
*ObjAutoFunc(OBJTYPE *obj,FUNCTYPE func
             ,ARGTYPE1 arg1,ARGTYPE2 arg2,ARGTYPE3 arg3
             ,ARGTYPE4 arg4)
{
  return new ObjFuncClass4<OBJTYPE,FUNCTYPE,ARGTYPE1,ARGTYPE2,ARGTYPE3,ARGTYPE4>(obj,func,arg1,arg2,arg3,arg4);
}

template<typename OBJTYPE,typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2,typename ARGTYPE3
,typename ARGTYPE4,typename ARGTYPE5
>
ObjFuncClass5<OBJTYPE,FUNCTYPE,ARGTYPE1,ARGTYPE2,ARGTYPE3,ARGTYPE4,ARGTYPE5>
*ObjAutoFunc(OBJTYPE *obj,FUNCTYPE func
             ,ARGTYPE1 arg1,ARGTYPE2 arg2,ARGTYPE3 arg3
             ,ARGTYPE4 arg4,ARGTYPE5 arg5
             )
{
  return new ObjFuncClass5<OBJTYPE,FUNCTYPE,ARGTYPE1,ARGTYPE2,ARGTYPE3,ARGTYPE4,ARGTYPE5>(obj,func,arg1,arg2,arg3
    ,arg4,arg5);
}

template<typename OBJTYPE,typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2,typename ARGTYPE3
,typename ARGTYPE4,typename ARGTYPE5,typename ARGTYPE6
>
ObjFuncClass6<OBJTYPE,FUNCTYPE,ARGTYPE1,ARGTYPE2,ARGTYPE3,ARGTYPE4,ARGTYPE5,ARGTYPE6>
*ObjAutoFunc(OBJTYPE *obj,FUNCTYPE func
             ,ARGTYPE1 arg1,ARGTYPE2 arg2,ARGTYPE3 arg3
             ,ARGTYPE4 arg4,ARGTYPE5 arg5,ARGTYPE6 arg6
             )
{
  return new ObjFuncClass6<OBJTYPE,FUNCTYPE,ARGTYPE1,ARGTYPE2,ARGTYPE3,ARGTYPE4,ARGTYPE5,ARGTYPE6>
    (obj,func,arg1,arg2,arg3
    ,arg4,arg5,arg6);
}

template<typename OBJTYPE,typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2,typename ARGTYPE3
,typename ARGTYPE4,typename ARGTYPE5,typename ARGTYPE6
,typename ARGTYPE7
>
ObjFuncClass7<OBJTYPE,FUNCTYPE,ARGTYPE1,ARGTYPE2,ARGTYPE3,ARGTYPE4,ARGTYPE5,ARGTYPE6
,ARGTYPE7>
*ObjAutoFunc(OBJTYPE *obj,FUNCTYPE func
             ,ARGTYPE1 arg1,ARGTYPE2 arg2,ARGTYPE3 arg3
             ,ARGTYPE4 arg4,ARGTYPE5 arg5,ARGTYPE6 arg6
             ,ARGTYPE4 arg7
             )
{
  return new ObjFuncClass7<OBJTYPE,FUNCTYPE,ARGTYPE1,ARGTYPE2,ARGTYPE3,ARGTYPE4,ARGTYPE5,ARGTYPE6
    ,ARGTYPE7>
    (obj,func,arg1,arg2,arg3
    ,arg4,arg5,arg6
    ,arg7
    );
}

template<typename OBJTYPE,typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2,typename ARGTYPE3
,typename ARGTYPE4,typename ARGTYPE5,typename ARGTYPE6
,typename ARGTYPE7,typename ARGTYPE8
>
ObjFuncClass8<OBJTYPE,FUNCTYPE,ARGTYPE1,ARGTYPE2,ARGTYPE3,ARGTYPE4,ARGTYPE5,ARGTYPE6
,ARGTYPE7,ARGTYPE8>
*ObjAutoFunc(OBJTYPE *obj,FUNCTYPE func
             ,ARGTYPE1 arg1,ARGTYPE2 arg2,ARGTYPE3 arg3
             ,ARGTYPE4 arg4,ARGTYPE5 arg5,ARGTYPE6 arg6
             ,ARGTYPE4 arg7,ARGTYPE8 arg8
             )
{
  return new ObjFuncClass8<OBJTYPE,FUNCTYPE,ARGTYPE1,ARGTYPE2,ARGTYPE3,ARGTYPE4,ARGTYPE5,ARGTYPE6
    ,ARGTYPE7,ARGTYPE8>
    (obj,func,arg1,arg2,arg3
    ,arg4,arg5,arg6
    ,arg7,arg8
    );
}

template<typename OBJTYPE,typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2,typename ARGTYPE3
,typename ARGTYPE4,typename ARGTYPE5,typename ARGTYPE6
,typename ARGTYPE7,typename ARGTYPE8,typename ARGTYPE9
>
ObjFuncClass9<OBJTYPE,FUNCTYPE,ARGTYPE1,ARGTYPE2,ARGTYPE3,ARGTYPE4,ARGTYPE5,ARGTYPE6
,ARGTYPE7,ARGTYPE8,ARGTYPE9>
*ObjAutoFunc(OBJTYPE *obj,FUNCTYPE func
             ,ARGTYPE1 arg1,ARGTYPE2 arg2,ARGTYPE3 arg3
             ,ARGTYPE4 arg4,ARGTYPE5 arg5,ARGTYPE6 arg6
             ,ARGTYPE4 arg7,ARGTYPE8 arg8,ARGTYPE9 arg9
             )
{
  return new ObjFuncClass9<OBJTYPE,FUNCTYPE,ARGTYPE1,ARGTYPE2,ARGTYPE3,ARGTYPE4,ARGTYPE5,ARGTYPE6
  ,ARGTYPE7,ARGTYPE8,ARGTYPE9>
    (obj,func,arg1,arg2,arg3
    ,arg4,arg5,arg6
    ,arg7,arg8,arg9
    );
}


template<typename FUNCTYPE>
class FuncClass0: public BaseFuncClass
{
public:
  FuncClass0(FUNCTYPE func){m_func = func;}
  void ExecFunc(){if (m_func) m_func();}
private:
  FUNCTYPE m_func;
};


template<typename FUNCTYPE,typename ARGTYPE1>
class FuncClass1: public BaseFuncClass
{
public:
  FuncClass1(FUNCTYPE func,ARGTYPE1 arg1)
  {
    m_func = func;
    m_arg1 = arg1;
  }
  void ExecFunc()
  {
	  if (m_func) m_func(m_arg1);
  }
private:
  FUNCTYPE m_func;
  ARGTYPE1 m_arg1;

};

template<typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2>
class FuncClass2: public BaseFuncClass
{
public:
  FuncClass2(FUNCTYPE func,ARGTYPE1 arg1,ARGTYPE2 arg2)
  {
    m_func = func;
    m_arg1 = arg1;
    m_arg2 = arg2;
  }
  void ExecFunc()
  {
	  if (m_func) m_func(m_arg1,m_arg2);
  }
private:
  FUNCTYPE m_func;
  ARGTYPE1 m_arg1;
  ARGTYPE2 m_arg2;
};

template<typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2,typename ARGTYPE3>
class FuncClass3: public BaseFuncClass
{
public:
  FuncClass3(FUNCTYPE func,ARGTYPE1 arg1,ARGTYPE2 arg2,ARGTYPE3 arg3)
  {
    m_func = func;
    m_arg1 = arg1;
    m_arg2 = arg2;
    m_arg3 = arg3;
  }
  void ExecFunc()
  {
	  if (m_func) m_func(m_arg1,m_arg2,m_arg3);
  }
private:
  FUNCTYPE m_func;
  ARGTYPE1 m_arg1;
  ARGTYPE2 m_arg2;
  ARGTYPE3 m_arg3;
};

template<typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2,typename ARGTYPE3,typename ARGTYPE4>
class FuncClass4: public BaseFuncClass
{
public:
  FuncClass4(FUNCTYPE func,ARGTYPE1 arg1,ARGTYPE2 arg2,ARGTYPE3 arg3,ARGTYPE4 arg4)
  {
    m_func = func;
    m_arg1 = arg1;
    m_arg2 = arg2;
    m_arg3 = arg3;
    m_arg4 = arg4;
  }
  void ExecFunc()
  {
	  if (m_func) m_func(m_arg1,m_arg2,m_arg3,m_arg4);
  }
private:
  FUNCTYPE m_func;
  ARGTYPE1 m_arg1;
  ARGTYPE2 m_arg2;
  ARGTYPE3 m_arg3;
  ARGTYPE4 m_arg4;
};

template<typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2,typename ARGTYPE3,typename ARGTYPE4,typename ARGTYPE5>
class FuncClass5: public BaseFuncClass
{
public:
  FuncClass5(FUNCTYPE func,ARGTYPE1 arg1,ARGTYPE2 arg2,ARGTYPE3 arg3,ARGTYPE4 arg4,ARGTYPE5 arg5)
  {
    m_func = func;
    m_arg1 = arg1;
    m_arg2 = arg2;
    m_arg3 = arg3;
    m_arg4 = arg4;
    m_arg5 = arg5;
  }
  void ExecFunc()
  {
	  if (m_func) m_func(m_arg1,m_arg2,m_arg3,m_arg4,m_arg5);
  }
private:
  FUNCTYPE m_func;
  ARGTYPE1 m_arg1;
  ARGTYPE2 m_arg2;
  ARGTYPE3 m_arg3;
  ARGTYPE4 m_arg4;
  ARGTYPE5 m_arg5;
};

template<typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2,typename ARGTYPE3,typename ARGTYPE4,typename ARGTYPE5
,typename ARGTYPE6>
class FuncClass6: public BaseFuncClass
{
public:
  FuncClass6(FUNCTYPE func,ARGTYPE1 arg1,ARGTYPE2 arg2,ARGTYPE3 arg3,ARGTYPE4 arg4,ARGTYPE5 arg5,ARGTYPE6 arg6)
  {
    m_func = func;
    m_arg1 = arg1;
    m_arg2 = arg2;
    m_arg3 = arg3;
    m_arg4 = arg4;
    m_arg5 = arg5;
    m_arg6 = arg6;
  }
  void ExecFunc()
  {
	  if (m_func) m_func(m_arg1,m_arg2,m_arg3,m_arg4,m_arg5,m_arg6);
  }
private:
  FUNCTYPE m_func;
  ARGTYPE1 m_arg1;
  ARGTYPE2 m_arg2;
  ARGTYPE3 m_arg3;
  ARGTYPE4 m_arg4;
  ARGTYPE5 m_arg5;
  ARGTYPE6 m_arg6;
};

template<typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2,typename ARGTYPE3,typename ARGTYPE4,typename ARGTYPE5
,typename ARGTYPE6,typename ARGTYPE7>
class FuncClass7: public BaseFuncClass
{
public:
  FuncClass7(FUNCTYPE func,ARGTYPE1 arg1,ARGTYPE2 arg2,ARGTYPE3 arg3,ARGTYPE4 arg4,ARGTYPE5 arg5,ARGTYPE6 arg6
    ,ARGTYPE7 arg7)
  {
    m_func = func;
    m_arg1 = arg1;
    m_arg2 = arg2;
    m_arg3 = arg3;
    m_arg4 = arg4;
    m_arg5 = arg5;
    m_arg6 = arg6;
    m_arg7 = arg7;
  }
  void ExecFunc()
  {
	  if (m_func) m_func(m_arg1,m_arg2,m_arg3,m_arg4,m_arg5,m_arg6,m_arg7);
  }
private:
  FUNCTYPE m_func;
  ARGTYPE1 m_arg1;
  ARGTYPE2 m_arg2;
  ARGTYPE3 m_arg3;
  ARGTYPE4 m_arg4;
  ARGTYPE5 m_arg5;
  ARGTYPE6 m_arg6;
  ARGTYPE7 m_arg7;
};

template<typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2,typename ARGTYPE3,typename ARGTYPE4,typename ARGTYPE5
,typename ARGTYPE6,typename ARGTYPE7,typename ARGTYPE8>
class FuncClass8: public BaseFuncClass
{
public:
  FuncClass8(FUNCTYPE func,ARGTYPE1 arg1,ARGTYPE2 arg2,ARGTYPE3 arg3,ARGTYPE4 arg4,ARGTYPE5 arg5,ARGTYPE6 arg6
    ,ARGTYPE7 arg7,ARGTYPE8 arg8)
  {
    m_func = func;
    m_arg1 = arg1;
    m_arg2 = arg2;
    m_arg3 = arg3;
    m_arg4 = arg4;
    m_arg5 = arg5;
    m_arg6 = arg6;
    m_arg7 = arg7;
    m_arg8 = arg8;
  }
  void ExecFunc()
  {
	  if (m_func) m_func(m_arg1,m_arg2,m_arg3,m_arg4,m_arg5,m_arg6,m_arg7,m_arg8);
  }
private:
  FUNCTYPE m_func;
  ARGTYPE1 m_arg1;
  ARGTYPE2 m_arg2;
  ARGTYPE3 m_arg3;
  ARGTYPE4 m_arg4;
  ARGTYPE5 m_arg5;
  ARGTYPE6 m_arg6;
  ARGTYPE7 m_arg7;
  ARGTYPE8 m_arg8;
};

template<typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2,typename ARGTYPE3,typename ARGTYPE4,typename ARGTYPE5
,typename ARGTYPE6,typename ARGTYPE7,typename ARGTYPE8,typename ARGTYPE9>
class FuncClass9: public BaseFuncClass
{
public:
  FuncClass9(FUNCTYPE func,ARGTYPE1 arg1,ARGTYPE2 arg2,ARGTYPE3 arg3,ARGTYPE4 arg4,ARGTYPE5 arg5,ARGTYPE6 arg6
    ,ARGTYPE7 arg7,ARGTYPE8 arg8,ARGTYPE9 arg9)
  {
    m_func = func;
    m_arg1 = arg1;
    m_arg2 = arg2;
    m_arg3 = arg3;
    m_arg4 = arg4;
    m_arg5 = arg5;
    m_arg6 = arg6;
    m_arg7 = arg7;
    m_arg8 = arg8;
    m_arg9 = arg9;
  }
  void ExecFunc()
  {
	  if (m_func) m_func(m_arg1,m_arg2,m_arg3,m_arg4,m_arg5,m_arg6,m_arg7,m_arg8,m_arg9);
  }
private:
  FUNCTYPE m_func;
  ARGTYPE1 m_arg1;
  ARGTYPE2 m_arg2;
  ARGTYPE3 m_arg3;
  ARGTYPE4 m_arg4;
  ARGTYPE5 m_arg5;
  ARGTYPE6 m_arg6;
  ARGTYPE7 m_arg7;
  ARGTYPE8 m_arg8;
  ARGTYPE9 m_arg9;
};

//...3,4,5,6,7,8,9

template<typename FUNCTYPE>
FuncClass0<FUNCTYPE> *AutoFunc(FUNCTYPE func_ptr)
{
  FuncClass0<FUNCTYPE> *ptr = new FuncClass0<FUNCTYPE>(func_ptr);
  return ptr;
}

template<typename FUNCTYPE,typename ARGTYPE1>
FuncClass1<FUNCTYPE,ARGTYPE1> *AutoFunc(FUNCTYPE func_ptr,ARGTYPE1 arg1)
{
  return (new FuncClass1<FUNCTYPE,ARGTYPE1>(func_ptr,arg1));
}

template<typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2>
FuncClass2<FUNCTYPE,ARGTYPE1,ARGTYPE2> *AutoFunc(FUNCTYPE func_ptr,ARGTYPE1 arg1,ARGTYPE2 arg2)
{
  return (new FuncClass2<FUNCTYPE,ARGTYPE1,ARGTYPE2>(func_ptr,arg1,arg2));
}

template<typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2,typename ARGTYPE3>
FuncClass3<FUNCTYPE,ARGTYPE1,ARGTYPE2,ARGTYPE3>
*AutoFunc(FUNCTYPE func_ptr,
          ARGTYPE1 arg1,ARGTYPE2 arg2,ARGTYPE3 arg3)
{
  return (new FuncClass3<FUNCTYPE,ARGTYPE1,ARGTYPE2,ARGTYPE3>(func_ptr,arg1,arg2,arg3));
}

template<typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2,typename ARGTYPE3,typename ARGTYPE4>
FuncClass4<FUNCTYPE,ARGTYPE1,ARGTYPE2,ARGTYPE3,ARGTYPE4>
*AutoFunc(FUNCTYPE func_ptr,
          ARGTYPE1 arg1,ARGTYPE2 arg2,ARGTYPE3 arg3,
          ARGTYPE4 arg4)
{
  return (new FuncClass4<FUNCTYPE,ARGTYPE1,ARGTYPE2,ARGTYPE3,ARGTYPE4>(func_ptr,arg1,arg2,arg3,arg4));
}

template<typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2,typename ARGTYPE3,typename ARGTYPE4
,typename ARGTYPE5>
FuncClass5<FUNCTYPE,ARGTYPE1,ARGTYPE2,ARGTYPE3,ARGTYPE4,
ARGTYPE5> *AutoFunc(FUNCTYPE func_ptr,
                    ARGTYPE1 arg1,ARGTYPE2 arg2,ARGTYPE3 arg3,
                    ARGTYPE4 arg4,ARGTYPE5 arg5)
{
  return (new FuncClass5<FUNCTYPE,ARGTYPE1,ARGTYPE2,ARGTYPE3,ARGTYPE4,ARGTYPE5>(func_ptr,arg1,arg2,arg3,arg4,arg5));
}

template<typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2,typename ARGTYPE3,typename ARGTYPE4
,typename ARGTYPE5,typename ARGTYPE6>
FuncClass6<FUNCTYPE,ARGTYPE1,ARGTYPE2,ARGTYPE3,ARGTYPE4,
ARGTYPE5,ARGTYPE6> *AutoFunc(FUNCTYPE func_ptr,
                             ARGTYPE1 arg1,ARGTYPE2 arg2,ARGTYPE3 arg3,
                             ARGTYPE4 arg4,ARGTYPE5 arg5,ARGTYPE6 arg6)
{
  return (new FuncClass6<FUNCTYPE,ARGTYPE1,ARGTYPE2,ARGTYPE3,ARGTYPE4,ARGTYPE5,ARGTYPE6>
    (func_ptr,arg1,arg2,arg3,arg4,arg5,arg6));
}

template<typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2,typename ARGTYPE3,typename ARGTYPE4
,typename ARGTYPE5,typename ARGTYPE6,typename ARGTYPE7>
FuncClass7<FUNCTYPE,ARGTYPE1,ARGTYPE2,ARGTYPE3,ARGTYPE4,
ARGTYPE5,ARGTYPE6,ARGTYPE7> *AutoFunc(FUNCTYPE func_ptr,
                                      ARGTYPE1 arg1,ARGTYPE2 arg2,ARGTYPE3 arg3,
                                      ARGTYPE4 arg4,ARGTYPE5 arg5,ARGTYPE6 arg6,
                                      ARGTYPE7 arg7)
{
  return (new FuncClass7<FUNCTYPE,ARGTYPE1,ARGTYPE2,ARGTYPE3,ARGTYPE4,ARGTYPE5,ARGTYPE6,ARGTYPE7>
    (func_ptr,arg1,arg2,arg3,arg4,arg5,arg6,arg7));
}

template<typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2,typename ARGTYPE3,typename ARGTYPE4
,typename ARGTYPE5,typename ARGTYPE6,typename ARGTYPE7,typename ARGTYPE8>
FuncClass8<FUNCTYPE,ARGTYPE1,ARGTYPE2,ARGTYPE3,ARGTYPE4,
ARGTYPE5,ARGTYPE6,ARGTYPE7,ARGTYPE8> *AutoFunc(FUNCTYPE func_ptr,
                                               ARGTYPE1 arg1,ARGTYPE2 arg2,ARGTYPE3 arg3,
                                               ARGTYPE4 arg4,ARGTYPE5 arg5,ARGTYPE6 arg6,
                                               ARGTYPE7 arg7,ARGTYPE8 arg8)
{
  return (new FuncClass8<FUNCTYPE,ARGTYPE1,ARGTYPE2,ARGTYPE3,ARGTYPE4,ARGTYPE5,ARGTYPE6,ARGTYPE7,ARGTYPE8>
    (func_ptr,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8));
}

template<typename FUNCTYPE,typename ARGTYPE1,typename ARGTYPE2,typename ARGTYPE3,typename ARGTYPE4
,typename ARGTYPE5,typename ARGTYPE6,typename ARGTYPE7,typename ARGTYPE8,typename ARGTYPE9>
FuncClass9<FUNCTYPE,ARGTYPE1,ARGTYPE2,ARGTYPE3,ARGTYPE4,
ARGTYPE5,ARGTYPE6,ARGTYPE7,ARGTYPE8,ARGTYPE9> *AutoFunc(FUNCTYPE func_ptr,
                                                        ARGTYPE1 arg1,ARGTYPE2 arg2,ARGTYPE3 arg3,
                                                        ARGTYPE4 arg4,ARGTYPE5 arg5,ARGTYPE6 arg6,
                                                        ARGTYPE7 arg7,ARGTYPE8 arg8,ARGTYPE9 arg9)
{
  return (new FuncClass9<FUNCTYPE,ARGTYPE1,ARGTYPE2,ARGTYPE3,ARGTYPE4,ARGTYPE5,ARGTYPE6,ARGTYPE7,ARGTYPE8,ARGTYPE9>
    (func_ptr,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9));
}

class AutoFuncClass
{
public:
  AutoFuncClass(BaseFuncClass *obj):m_funcobj(obj){}
  ~AutoFuncClass()
  {
	  if (m_funcobj){
		  m_funcobj->ExecFunc();
		  delete m_funcobj;
	  }
  }
private:
  BaseFuncClass *m_funcobj;
};

//...3,4,5,6,7,8,9


}//end of namespace fyslib

#endif /* FYSLIB_AUTOOBJECT_HPP_ */


「已注销」
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++异常处理 - try,catch,throw,finally的用法
weixin_34194359的博客
10-10 420
      写在前面 　　所谓异常处理，即让一个程序运行时遇到自己无法处理的错误时抛出一个异常，希望调用者可以发现处理问题. 　　异常处理的基本思想是简化程序的错误代码，为程序键壮性提供一个标准检测机制. 　　也许我们已经使用过异常，但是你习惯使用异常了吗？ 　　现在很多软件都是n*365*24小时运行，软件的健壮性至关重要.  内容导读 本文包括2个大的异常实现概...
C++ 中try finally关键字详解
09-02
本文给大家介绍C++ 中try finally关键字的相关知识，非常不错，本文介绍的非常详细，具有参考借鉴价值，感兴趣的朋友一起学习吧
C++ 关键字 (try-finally)
热门推荐
learning attitude
01-25 1万+
C++ 关键字 (try-finally)
C#,Java,C++中的finally关键字
weixin_34204722的博客
04-30 136
博客原文：http://hankjin.blog.163.com/blog/static/33731937201031511305338/ 先说C++，标准C++不支持finally, 如果要实现finally的效果，可以用析构函数来实现： class File_handle { FILE* p;public: File_handle(const char* n, const char...
【c++】final的用法
aoeaoao的博客
11-25 549
【c++】final的用法
C++用finally函数实现当前函数运行结束自动执行一段代码
biao2488890051的博客
07-29 1415
在fun函数开始处，定义一个栈对象，构造函数给它传递要给匿名函数进去初始化该对象，然后fun函数结束，会自动析构这个栈对象。（然而该对象的析构函数，恰好是。传递进去的这个匿名函数（也叫lambda函数），这样就实现了fun函数结束时候自动执行一段代码啦（这里就是那个匿名函数））。//希望在这里能自动执行一段设定好的代码，实现一些自动清除啥啥啥的操作。.........
iOS、C、Linux、C++面试宝典.zip
最新发布
01-20
2. **C++面向对象编程**：C++中的类、对象、封装、继承、多态是面试中的常见话题。理解这些概念以及如何使用它们来构建复杂系统是评估C++技能的关键。 3. **C++模板和STL**：标准模板库（STL）提供了容器（如vector...
C_Linux_C++.rar
06-08
在IT行业中，Linux和C/C++是程序员们必备的基础技能，尤其对于系统级开发和网络编程更为重要。本文将深入探讨这两个主题，并结合DNS基础知识，为程序员提供一个全面的学习框架。 首先，让我们从Linux开始。Linux是...
simple-redis_redis_C++_
10-03
这个"simple-redis"项目提供了一个C++的简单封装，允许开发者在Linux环境下与Redis服务器进行交互。C++的Redis客户端库通常会提供异步和同步两种API，以便在不同场景下选择合适的通信模式。 **C++封装类的关键组件*...
java-study.rar_Java编程_Unix_Linux_
08-11
Java的设计理念是“一次编写，到处运行”（Write Once, Run Anywhere），这得益于其跨平台的特性，使得Java程序可以在任何支持Java虚拟机（JVM）的系统上运行。 **核心概念** 1. **面向对象**：Java基于面向对象...
c++中怎么实现Java中finally语句
weixin_30929295的博客
02-09 91
所有学习c++的书籍都明确提出了，不要使用goto,以免造成程序流程的混乱，使理解和调试程序都产生困难。 但是我们遇到这样一个场景怎么办：就是不管程序执行成功与否，都要执行一些资源释放语句，相当java中的finally语句。c++的中没有finally的支持，即使使用try catch，资源释放也需要写两次，执行成功一次，catch中一次。使用goto可以很优雅的实现了finally. ...
为什么C++没有finally
XiufengWu的博客
11-22 6599
第一部分         标准 C++ 是没有类似 finally 这样的语句结构的。C# / Java 中保证无论是否出现异常，finally block 的代码均会得到执行；而 C++ 中，不论是否出现异常，局部变量的析构函数是会保证执行的，所以相对应与 finally block，C++ 的解决办法是 RAII。         在C++中通常使用RAII，即Resource A
c语言linux异常处理,【try……catch】C++ try…… catch 笔记（C语言中也可以Try-Catch异常处理）...
weixin_32837047的博客
05-13 1387
目录C++ try……catchcatch(CException *e) 打印异常信息不经意间的内存泄露:try-catch(CException *e) [异常对象需要手动释放]C++ try catch 捕获空指针异常，数组越界异常C++ try catch 异常类异常类大全C try……catch没用用到MFC，是不支持CException的。C++ try……catchcatch(CExc...
C/C++ 11 try-catch-finally 扩展（函数式）
liulilittle的博客
04-17 2937
提供对于标准C/C++ 11完善的SEH（结构化异常处理）处理扩展 1、try 2、catch 3、catch-when 4、finally usage： using ep::Try; class exceptionA : public std::exception { public: exceptionA(char const* const _Message) :exceptio...
C++中为什么没有try finally的理解
diligentcat的专栏
03-25 1628
<br />因为c++中有一个非常重要的原则，就是：在异常发生前成功调用构造函数的类一定能够执行析构函数。
C++ 它说 try, catch, 和 finally
bluelace25的专栏
10-31 1131
在 C++ 中，`try`, `catch`, 和 `finally` 关键字通常不是标准的 C++ 语法。C++ 使用 `try` 和 `catch` 来处理异常，但没有 `finally` 块。在这个例子中，`try` 块包含可能引发异常的代码。尽管 C++ 没有 `finally` 关键字，但在资源管理方面，C++ 提供了 RAII（资源获取即初始化）的机制，允许我们使用对象的生命周期来管理资源，以确保在离开作用域时资源得到释放，类似于 `finally` 块的功能。
C++11 final 标识符
大袖技术
01-08 434
一、final final 是 C++11 新增的一个标识符 主要用于在类定义时，可以显式强调不能继承 防止我们在使用类的过程中 有意或者无意为该类创建子类 二、举个栗子 1、类继承 看以下代码 #include <iostream> using namespace std; class A {}; class B: public A{}; int main(int argc, char ** argv) { return 0; } B 类是 A 类的派生类 接着
Python入门学习资源大放送
平台涵盖了多种编程语言（如Java、.Net、C/C++、Perl、Ruby等）、数据库管理系统（如MySQL、SQL Server、Oracle等）、前端技术（HTML、CSS、JavaScript、Ajax）、PHP开发、UML、Linux及UNIX操作系统等多个领域的学习...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值