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语言linux异常处理,【try……catch】C++ try…… catch 笔记（C语言中也可以Try-Catch异常处理）...
weixin_32837047的博客
05-13 1379
目录C++ try……catchcatch(CException *e) 打印异常信息不经意间的内存泄露:try-catch(CException *e) [异常对象需要手动释放]C++ try catch 捕获空指针异常，数组越界异常C++ try catch 异常类异常类大全C try……catch没用用到MFC，是不支持CException的。C++ try……catchcatch(CExc...
linux下c++ lesson4 类的封装
Tyeat的博客
02-23 93
1-圆的面积.cpp #include <iostream> using namespace std; /*struct Circle //结构体 { int r; double s; };*/ class Circle //类 { private: int r; //成员变量 属性 double s; public: void ...
C++异常处理 - try,catch,throw,finally的用法
weixin_34194359的博客
10-10 419
      写在前面 　　所谓异常处理，即让一个程序运行时遇到自己无法处理的错误时抛出一个异常，希望调用者可以发现处理问题. 　　异常处理的基本思想是简化程序的错误代码，为程序键壮性提供一个标准检测机制. 　　也许我们已经使用过异常，但是你习惯使用异常了吗？ 　　现在很多软件都是n*365*24小时运行，软件的健壮性至关重要.  内容导读 本文包括2个大的异常实现概...
c++ try catch 问题
热门推荐
windhaunting的专栏
10-27 8万+
try{} catch(…){}以前都是用try{} catch(…){}来捕获C++中一些意想不到的异常， 今天看了Winhack的帖子才知道，这种方法在VC中其实是靠不住的。例如下面的代码：try { BYTE* pch ; pch = ( BYTE* )00001234 ;   //给予一个非法地址 *pch = 6 ; //对非法地址赋值，会造成Access V
c++ try catch语句_try、finally、return的执行顺序，读完之后，大部分程序员收藏了...
weixin_39548490的博客
11-26 764
1、不管有没有出现异常，finally块中代码都会执行；2、当try和catch中有return时，finally仍然会执行；3、finally是在return后面的表达式运算后执行的(此时并没有返回运算后的值，而是先把要返回的值保存起来，不管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值)，所以函数返回值是在finally执行前确定的；4、finally中最好不要包含ret...
linux c 异常实现,linux c 实现try catch异常捕获
weixin_30583711的博客
05-16 617
前言：像如java这样的面相对象语言，异常处理机制让其代码更具健壮性，可以代码捕获到如算术异常，空指针异常等，俘获并能够在预知情况下进行相应处理。那么对于C而言，是否能实现其功能？简要分析：Linux有对线程或者进程退出时有一种信号量机制，而默认情况下，这种signal是系统自己处理的，而最统一的处理方式是exit，而至于什么原因退出这个完全取决于什么样的信号。至于linux下的这些signal多...
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++封装类的关键组件*...
C++ 中try finally关键字详解
09-02
本文给大家介绍C++ 中try finally关键字的相关知识，非常不错，本文介绍的非常详细，具有参考借鉴价值，感兴趣的朋友一起学习吧
java-study.rar_Java编程_Unix_Linux_
08-11
Java的设计理念是“一次编写，到处运行”（Write Once, Run Anywhere），这得益于其跨平台的特性，使得Java程序可以在任何支持Java虚拟机（JVM）的系统上运行。 **核心概念** 1. **面向对象**：Java基于面向对象...
C/C++/Java/android/PHP/iOS/Python期末试卷.rar
03-04
C++ 是 C 语言的扩展，增加了面向对象编程（OOP）的概念，如类、对象、封装、继承和多态，使得它更适合大型软件项目的开发。 知识点包括： 1. C 语言的基本语法：变量、数据类型、运算符、控制结构（如条件语句、...
C++用finally函数实现当前函数运行结束自动执行一段代码
biao2488890051的博客
07-29 1413
在fun函数开始处，定义一个栈对象，构造函数给它传递要给匿名函数进去初始化该对象，然后fun函数结束，会自动析构这个栈对象。（然而该对象的析构函数，恰好是。传递进去的这个匿名函数（也叫lambda函数），这样就实现了fun函数结束时候自动执行一段代码啦（这里就是那个匿名函数））。//希望在这里能自动执行一段设定好的代码，实现一些自动清除啥啥啥的操作。.........
【c++】final的用法
aoeaoao的博客
11-25 541
【c++】final的用法
C++ 它说 try, catch, 和 finally
bluelace25的专栏
10-31 1109
在 C++ 中，`try`, `catch`, 和 `finally` 关键字通常不是标准的 C++ 语法。C++ 使用 `try` 和 `catch` 来处理异常，但没有 `finally` 块。在这个例子中，`try` 块包含可能引发异常的代码。尽管 C++ 没有 `finally` 关键字，但在资源管理方面，C++ 提供了 RAII（资源获取即初始化）的机制，允许我们使用对象的生命周期来管理资源，以确保在离开作用域时资源得到释放，类似于 `finally` 块的功能。
为什么C++没有finally
XiufengWu的博客
11-22 6589
第一部分         标准 C++ 是没有类似 finally 这样的语句结构的。C# / Java 中保证无论是否出现异常，finally block 的代码均会得到执行；而 C++ 中，不论是否出现异常，局部变量的析构函数是会保证执行的，所以相对应与 finally block，C++ 的解决办法是 RAII。         在C++中通常使用RAII，即Resource A
c++ 标准库的各种容器(vector,deque,map,set,unordered_map,unordered_set,list)的性能考虑
ssz的技术博客
12-13 1万+
c++ 标准库的各种容器(vector,deque,map,set,unordered_map,unordered_set,list)的性能考虑   一、vector vector采用一段连续的内存来存储其元素，向vector添加元素的时候，如果容量不足，vector便会重新malloc一段更大的内存，然后把原内存中的数据memcpy到新的内存中，并free原内存块，然后将新元素加入。vec
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值