编译时推导函数调用约定、常量性、返回值、参数等函数类型特征

已于 2023-06-06 20:16:02 修改
阅读量846 收藏
点赞数 1
分类专栏： C++标准库扩展 文章标签： 推断调用约定
于 2017-12-11 18:14:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/passFuHao/article/details/78775308
版权

已知调用约定不是类型，也无法在运行时检查。所以，看似无法根据调用约定的不同实现分治，可std::thread和std::invoke是如何处理调用约定的？

存在以下事实；语句：

(void( __stdcall* )())0 == (void( __cdecl* )())0;

无法被正确编译，cl.exe报告的编译错误为：error C2446: “==”: 没有从“void (__cdecl *)(void)”到“void (__stdcall *)(void)”的转换 
但以下语句可以通过编译：

(void( __stdcall* )())0 == (void( __stdcall* )())0;

即：说明编译器能根据函数类型中的调用约定不同而产生不同的函数类型，所以，可以根据函数类型的调用约定不同进行特化。（此结论不适用于VS2013，VS2013虽可根据调用约定不同产出不同函数类型，但不可利用之进行特化）

完整实现如下：

#if _MSC_VER >1800 // 大于 VS2013
	/*
		FnSynopsis
			得到函数提要，包括函数返回类型、形参数量和各参数类型、调用约定以及
		函数是否声明为CONST等。

		类型成员：
			_ResultType，函数的返回类型。
			_FormalTypes，用 tuple 表示的形式参数包，可通过 tuple_size、
		tuple_element 等类得到其中包含的形参数量或类型。
			_PtrType，复原后的函数指针类型。

		值成员：
			CallType，调用约定；参见：CallConvention
			DeclareAsConst，函数是否声明为CONST。

		示例，得到函数调用约定：

			int __stdcall global_fun( int, double );

			struct A
			{
				static char __cdecl static_member_fun( unsigned char, char *& );
				float __stdcall member_fun( wchar_t & );
				float const_member_fun( int & ) const;

				void __cdecl cdecl_ellipsis_fun( const char *, ... );
			};
			
			void cdecl_ellipsis_fun( const char *, ... );

			int main( int argc, char ** argv )
			{
				int( __stdcall* p_global_fun )(int, double)  = global_fun;
				FnSynopsis< decltype(global_fun)>::CallType;		// _STD_CALL
				FnSynopsis< remove_reference_t<decltype(*p_global_fun)>>::CallType;	// _STD_CALL

				FnSynopsis< string( int, double ) const> ::CallType;	// 默认为_CDECL_CALL，视编译设置而定
				FnSynopsis< string( int, double ) >::CallType;				// 默认为_CDECL_CALL，视编译设置而定

				FnSynopsis< decltype(cdecl_ellipsis_fun)>::CallType;	// 错误，无法处理 c-style 变参函数；参考备注。

				FnSynopsis< decltype(A::static_member_fun)>::CallType;	// _CDECL_CALL
				FnSynopsis< decltype(&A::member_fun) >::CallType;			// _STD_CALL
				FnSynopsis< decltype(&A::const_member_fun)>::CallType;	// _THIS_CALL
				FnSynopsis< decltype(&A::cdecl_ellipsis_fun)>::CallType;	// 错误，无法处理 c-style 变参函数；参考备注。

				return EXIT_SUCCESS;
			}

		备注：
			1、FnSynopsis无法处理 c-style 变参函数，如果你有此有需求，以下是建议的实现：

				template< typename _Ret, typename ..._Types >
					struct FnSynopsis< _Ret __cdecl( _Types..., ... ) >
				{
					typedef _Ret _ResultType;
					typedef std::tuple< _Types... > _FormalTypes;	// 注意：_FormalTypes只包含函数的非 ... 部分的形参描述。
					typedef _Ret( __cdecl *_PtrType )(_Types...);
					static const CallConvention CallType = _CDECL_CALL;	// 注意：c-style 变参函数的调用约定一定是 __cdecl
					enum { DeclareAsConst = false };
				};

			2、FnSynopsis无法处理未实例化的模板函数。ms c++ 标准库中 bind 函数返回的对象其 operator() 是模板函数。

		< .fuhao >
	*/	
	template< typename _Tx > struct FnSynopsis;

	enum CallConvention {
		_CDECL_CALL,	// __cdecl
		_STD_CALL,		// __stdcall
		_FAST_CALL,		// __fastcall
		_THIS_CALL,		// __thiscall
		_CLR_CALL			// __clrcall
	};

#define DEFINE_FNSYNOPSIS_IMPL( _CallType, _CallTypeValue ) \
	template< typename _Ret, typename ..._Types >\
		struct FnSynopsis< _Ret _CallType( _Types... ) >\
	{\
		typedef _Ret _ResultType;\
		typedef VOID _ClassType;\
		typedef std::tuple< _Types... > _FormalTypes;\
		typedef _Ret( _CallType *_PtrType )( _Types... );\
		static const CallConvention CallType = _CallTypeValue; \
		enum { DeclareAsConst = false };\
		enum { IsMemberFunction = false };\
	};\
	template< typename _Ret, typename ..._Types >\
		struct FnSynopsis< _Ret _CallType( _Types ... ) const >\
	{\
		typedef _Ret _ResultType;\
		typedef VOID _ClassType;\
		typedef std::tuple< _Types... > _FormalTypes;\
		typedef _Ret( _CallType *const _PtrType )( _Types... );\
		static const CallConvention CallType = _CallTypeValue; \
		enum { DeclareAsConst = true };\
		enum { IsMemberFunction = false };\
	}

#define DEFINE_MEM_FNSYNOPSIS_IMPL( _CallType, _CallTypeValue )\
	template< typename _Ret, typename _Class, typename ..._Types >\
		struct FnSynopsis< _Ret( _CallType _Class::* )(_Types...) >\
	{\
		typedef _Ret _ResultType;\
		typedef _Class _ClassType;\
		typedef std::tuple< _Types... > _FormalTypes;\
		typedef _Ret( _CallType _Class::* _PtrType) (_Types ...);\
		static const CallConvention CallType = _CallTypeValue; \
		enum { DeclareAsConst = false };\
		enum { IsMemberFunction = true };\
	};\
	template< typename _Ret, typename _Class, typename ..._Types >\
		struct FnSynopsis< _Ret( _CallType _Class::* )(_Types...) const >\
	{\
		typedef _Ret _ResultType;\
		typedef _Class _ClassType;\
		typedef std::tuple< _Types... > _FormalTypes;\
		typedef _Ret( _CallType _Class::* _PtrType) (_Types ...) const;\
		static const CallConvention CallType = _CallTypeValue; \
		enum { DeclareAsConst = true };\
		enum { IsMemberFunction = true };\
	}

	DEFINE_FNSYNOPSIS_IMPL( __cdecl, _CDECL_CALL );
	DEFINE_FNSYNOPSIS_IMPL( __stdcall, _STD_CALL );

	DEFINE_MEM_FNSYNOPSIS_IMPL( __cdecl, _CDECL_CALL );
	DEFINE_MEM_FNSYNOPSIS_IMPL( __stdcall, _STD_CALL );
	DEFINE_MEM_FNSYNOPSIS_IMPL( __thiscall, _THIS_CALL );

	#ifdef _M_CEE
	DEFINE_FNSYNOPSIS_IMPL( __clrcall, _CLR_CALL );
	DEFINE_MEM_FNSYNOPSIS_IMPL( __clrcall, _CLR_CALL );
	#else
	DEFINE_FNSYNOPSIS_IMPL( __fastcall, _FAST_CALL );
	DEFINE_MEM_FNSYNOPSIS_IMPL( __fastcall, _FAST_CALL );
	#endif

	// 针对可调用对象的 FnSynopsis，用法和 FnSynopsis 差不多。
	template< typename _Tx, typename = _Tx > struct CallableSynopsis;

	template< typename _Tx >
	struct CallableSynopsis< _Tx, typename std::enable_if< std::is_class< typename std::remove_reference< _Tx >::type >::value, _Tx >::type >
		: public FnSynopsis< decltype(&std::remove_reference<_Tx>::type::operator()) >
	{
		enum : bool { IsCallableObject = true };
	};

	template< typename _Tx >
	struct CallableSynopsis< _Tx, typename std::enable_if< !std::is_class< typename std::remove_reference< _Tx >::type  >::value, _Tx >::type >
		: public FnSynopsis< typename std::remove_pointer< typename std::remove_reference< _Tx >::type >::type >
	{
		enum : bool { IsCallableObject = false };
	};

#endif

有一点值得注意：
FnSynopsis内的_FormalTypes成员是 tuple，不是函数的参数的类型包，若需将此复原为类型包，可参考以下实现：

	void fun( int, string );

	template< typename ..._Types >
	void restore( tuple< _Types ... > && )
	{
		printf( "ArgsNumber:%d\n", sizeof...(_Types) );
	}

使用：

restore( FnSynopsis< decltype(fun) >::_FormalTypes() );

若要利用 _FormalTypes存储参数，并伺机调用，建议实现如下：

void fn1( string, int ){}

template< typename _Fn1, typename ..._Types >
auto Bypass( _Fn1 &&_Func, tuple< _Types ... > Tuple )->result_of_t< _Fn1&(_Types...)>
{
	return ApplyTupleExpand( _Func, std::move( Tuple ) );
}

template< typename _Fn1, typename ..._Types >
auto Call( _Fn1 && _Func, _Types &&... Args )->result_of_t< _Fn1&(_Types...)>
{
	FnSynopsis< remove_reference_t< remove_pointer_t< decltype(_Func)>>>::_FormalTypes Tuple = make_tuple( std::forward< _Types >( Args )... );
	return Bypass( _Func, Tuple );
}

使用：

Call( fn1, string(), 123 );

ApplyTupleExpand 实现如下：

	/*
		ApplyTupleExpand
			展开std::tuple，并将tuple元素作为参数调用_Func。

		参数：
			_Func，函数对象。ApplyTupleExpand调用此函数时会向其传递已展开为参数包的Tuple。
			Tuple，将要被展开为参数包的std::tuple对象。

		返回值：
			返回_Func的调用结果。

		注意：
			如果要处理 move 语义，需要在调用 ApplyTupleExpand 传入右值的 Tuple；

		示例：
			VOID Fun( String _RightString, String &_LRefString, CONST String &_CLRefString, String _String )
			{
			}

			template< typename _Fn1, typename ..._Types >
			VOID Call( _Fn1 &&_Func, _Types &&... Args )
			{
				tuple< _Types&&... > _Tup( std::forward< _Type >( Args )... );
				ApplyTupleExpand( _Func, std::move( _Tup ) );		注意使用std::move，否则向 Fun 函数的_RightString形参传递参数时将采用拷贝方式
			}

			int main( int argc, char ** argv )
			{
				String RightStringArg;
				String LRefStringArg;
				String LCRefStringgArg;
				String StringArg;
				Call( Fun, std::move( RightStringArg ), LRefStringArg, LCRefStringArg, StringArg );

				return NOERROR;
			}
				
		< .fuhao >
	*/
	template< std::size_t N > struct _TupleExpand{
		template< typename _Fty, typename _Ety, typename... _Remain >
		static inline auto Expand( _Fty &&_Func, _Ety && _Elem, _Remain&&... Args )->\
			decltype(_TupleExpand< N - 1 >::Expand(
			std::forward< _Fty>( _Func ), std::forward< _Ety >( _Elem ),
			std::get< N - 1 >( std::forward< _Ety >( _Elem ) ),
			std::forward< _Remain>( Args )... )){
			return _TupleExpand< N - 1 >::Expand( std::forward< _Fty >( _Func ),
				std::forward<_Ety>( _Elem ),
				std::get<N - 1>( std::forward<_Ety>( _Elem ) ),
				std::forward<_Remain>( Args )... );
		}
	};

	template<> struct _TupleExpand < 0 > {
		template< typename _Fty, typename _Ety, typename... _Remain>
		static inline auto Expand( _Fty && _Func, _Ety &&, _Remain &&... Args )->\
			decltype(::std::forward<_Fty>( _Func ) (::std::forward<_Remain>( Args )...)){
			return ::std::forward< _Fty >( _Func )(::std::forward < _Remain >( Args )...);
		}
	};

	template< typename _Fty, typename _Tuple >
	inline auto ApplyTupleExpand( _Fty && _Func, _Tuple && Tuple )->\
	decltype(_TupleExpand< std::tuple_size< typename std::decay< _Tuple >::type >::value >::Expand( std::forward< _Fty >( _Func ), std::forward< _Tuple >( Tuple ) )){
		return _TupleExpand < std::tuple_size < typename std::decay< _Tuple >::type >::value >::Expand( std::forward< _Fty>( _Func ), std::forward< _Tuple >( Tuple ) );
	}

以及一个扩展版，使用了部分 c++ 14特性的实现，如下：

#if _MSC_VER > 1800 // VS2013以上版本
	/*
		ApplyTupleExpandEx
			同 ApplyTupleExpand 的作用相同。

		参数：
			_Func，要调用的函数。
			Tuple，将要被展开为参数包的std::tuple对象。

		返回值：
			_Func 的返回值。
	*/
	template< typename _Fty, typename _Tuple, size_t ... Index >
	decltype(auto) ApplyTupleExpandImpl(
		_Fty &&_Func, _Tuple &&Tuple, std::index_sequence<Index...> )
	{
		return _Func( std::get< Index>( std::forward<_Tuple>( Tuple ) )... );
	}

	template< typename _Fty, typename _Tuple >
	decltype(auto) ApplyTupleExpandEx( _Fty &&_Func, _Tuple &&Tuple )
	{
		using std::decay;
		using std::tuple_size;
		using std::make_index_sequence;

		return ApplyTupleExpandImpl( std::forward< _Fty>( _Func ),
			std::forward< _Tuple >( Tuple ),
			make_index_sequence< tuple_size< typename decay< _Tuple>::type >::value >{} );
	}
#endif

至此，实现了一个可以推导函数调用约定的基础设施。至于作何用，基础设施的作用是无限大，发挥想像就行了。事实上，这是我的GDI对象调试器项目中一部分核心代码，用来为hook大量的GDI函数编写通用的detour函数所用。

穿女装的程序员
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言main函数的参数及其返回值详细解析
01-01
main函数的返回值用于说明程序的退出状态。如果返回0，则代表程序正常退出；返回其它数字的含义则由系统决定。通常，返回非零代表程序异常退出。下面我们在winxp环境下做一个小实验。首先编译下面的程序：int main( ...
易语言调用函数编译原理
07-22
易语言调用函数编译原理源码,调用函数编译原理,是否汉字,读字符,是否运算符,指针回溯,跳过空格,跳过注释,外部接口_表达式计算,表达式计算,函数调用,函数_位或,函数_测试,计算表达式数组,单个计算,输出状态
function 的简单实现
yjh201301的博客
01-26 450
template  class  Invoker_Base { public:     virtual  R  operator()(Arg arg) = 0; }; template  class  Function_Ptr_Invoker :         public  Invoker_Base { private:     typedef  R (*FUNC
名字修饰与调用约定
云淡风轻
03-08 538
下面是整理的关于c/c++名字修饰和调用约定的规则：名字修饰调用约定CC++__stdcall约定在输出函数名前加上一个下划线前缀，后面加上一个"@"符号和其参数的字节数目，格式为_functionname@number1. 以“？”标示函数名的开始，后跟函数名；2. 函数名后面以“@@YG”标识参数表的开始，后跟参数表。3. 参数表以代号标示：X--void；D--char；E--unsigned char；F--short；H--int；I--unsigned char；J--long；K--unsig
常量函数与常量对象的使用
liuxunfei15的博客
07-18 3476
常量函数形式：int fun(void) const; 注意：const int fun(void) 不是常量函数，只是函数的返回值为常量 #include &lt;iostream&gt; using namespace std; class DEMO { private: int a; public: DEMO(int a=0):a(a){} void show ...
c++进阶（二）函数调用约定及函数名称修饰符
firedragonpzy
07-13 148
[code="c++"]几乎每种编程语言都有函数的概念,而作为函数,就一定有参数的概念;一般来说,参数的传递是通过堆栈来实现的,堆栈是一种先入后出的数据结构,使用Push()把参数压入栈中,使用Pop()把参数弹出栈,而且Push()和Pop()必须成对出现; 重要的一点:函数调用约定不仅决定了发生函数调用时函数参数的入栈顺序,还决定了是由调用者函数还是被调用者函数负责清除函数栈中的参数并还原栈...
位常量性(bitwise constness)与逻辑常量性(logical constness)
f593256的博客
07-04 290
总结： "Bitwise constness" 强调在 const 成员函数中不能修改任何成员变量的值，而 "logical constness" 强调在 const 成员函数中不能修改外部可见的逻辑状态，但可以修改成员变量的值。2. Logical Constness（逻辑常量性）： Logical constness 表示在 const 成员函数中不会修改外部可见的逻辑状态，但可能会修改成员变量的值，只要这些修改对外部不可见。是一个 const 成员函数，它计算矩形的面积。
C++ Qt QComboBox使用教程
热门推荐
琅嬛福地
03-22 1万+
QComboBox提供了下拉列表选择的功能，使用方法如下: （1）添加数据项 //给combobox添加内容项 ui->comboBox->addItem("11"); ui->comboBox->addItem("12"); ui->comboBox->addItem("13"); ui->co...
函数常量
qq_16490557的专栏
07-01 481
const修饰类的成员函数，则该成员函数不能修改类中任何非const成员函数。一般写在函数的最后来修饰。 class A { … void function()const; //常成员函数, 它不改变对象的成员变量. 也不能调用类中任何非const成员函数。 } 对于const类对象/指针/引用，只能调用类的const成员函数，因此，const修饰成员函数的最重要作用就是限制对于const对象的使
详解成员函数的常量性
tianxiaolu1175的专栏
07-11 891
1.什么是成员函数的常量性？ 关于成员函数的常量性当前有两个流行的概念（1）bitwise constness(又称physical constness) (2)logical constness (1)什么称之为bitwise constness ? bitwise constness 是指 ，成员函数只有在不更改对象的任何成员变量（static 除外，因为类的static 变量属于类 而
运行时常量(const)和编译时常量(constexpr)
u012516419的博客
04-27 3150
在c++中，我们会常常遇到常量的概念。常量表示该值不可修改。如: const int i=3;//i为常量 const 还可以修饰函数参数，函数返回值，函数本身，类等。在不同的条件下，const有不同的意义，大多数情况const描述的都是”运行时常量概念“，既具有运行时数据不可更改性。不过有时候，我们需要编译时期的常量性，这是const关键字无法保证的。如： const int getc...
大华相机中的一个模板嵌套
weixin_47564352的博客
04-06 249
CSingleDisplayDlg::CSingleDisplayDlg(CWnd* pParent /*=NULL*/) : CDialog(CSingleDisplayDlg::IDD, pParent) , _connected(false) , _isGrabbing(false) , _bRunning(false) , _frameCnt(0) , _frameCtrl(false) , _maxFrameCnt(0) , _devListDlg(NULL) , _displ.
基于C++内存分配、函数调用与返回值的深入分析
12-31
在谈述函数调用和返回值问题之前，先来看看C++中内存分配的问题。 C++编译器将计算机内存分为代码区和数据区，很显然，代码区就是存放程序代码，而数据区则是存放程序编译和执行过程出现的变量和常量。数据区又分为...
编译原理豪华版程序.rar_编译原理_编译原理 识别函数及参数
09-22
编译原理豪华版程序用VC++编写
C# 调用c++ 库 参数为指针类型导出函数
02-23
参数为指针类型导出函数 c# Csharp调用 c++库 参数为导入和导出指针两种 包含C++ DLL源码 如fun(cont char* A,char*B) A为输入参数，B为输出参数-C# CSharp call C++ DLL lib dll function param use export and ...
spring java图片上传源码.rar
最新发布
04-26
源码实现了图片上传功能，可供相关功能开发的小伙伴参考学习使用。
新入职员工工作总结范文大全(篇).docx
04-26
工作总结，新年计划，岗位总结，工作汇报，个人总结，述职报告，范文下载，新年总结，新建计划。
本项目内容为《SpringBoot 2.X 基础教程》配套源码.zip
04-26
提供的源码资源涵盖了安卓应用、小程序、Python应用和Java应用等多个领域，每个领域都包含了丰富的实例和项目。这些源码都是基于各自平台的最新技术和标准编写，确保了在对应环境下能够无缝运行。同时，源码中配备了详细的注释和文档，帮助用户快速理解代码结构和实现逻辑。 适用人群： 这些源码资源特别适合大学生群体。无论你是计算机相关专业的学生，还是对其他领域编程感兴趣的学生，这些资源都能为你提供宝贵的学习和实践机会。通过学习和运行这些源码，你可以掌握各平台开发的基础知识，提升编程能力和项目实战经验。 使用场景及目标： 在学习阶段，你可以利用这些源码资源进行课程实践、课外项目或毕业设计。通过分析和运行源码，你将深入了解各平台开发的技术细节和最佳实践，逐步培养起自己的项目开发和问题解决能力。此外，在求职或创业过程中，具备跨平台开发能力的大学生将更具竞争力。 其他说明： 为了确保源码资源的可运行性和易用性，特别注意了以下几点：首先，每份源码都提供了详细的运行环境和依赖说明，确保用户能够轻松搭建起开发环境；其次，源码中的注释和文档都非常完善，方便用户快速上手和理解代码；最后，我会定期更新这些源码资源，以适应各平台技术的最新发展和市场需求。
IMG_20240426_195457.jpg
04-26
IMG_20240426_195457.jpg
C++ 函数调用约定
11-15
C++函数调用约定是指在编译器编译函数时，函数的参数如何被压入堆栈，返回值如何从堆栈中弹出等规则。常见的C++函数调用约定有三种：stdcall、cdecl和thiscall。 stdcall是一种被广泛使用的函数调用约定，它要求被调用的函数自己清理堆栈。stdcall约定的函数参数是从右往左依次压入堆栈中的，返回值通常存放在EAX寄存器中。 cdecl是C/C++默认的函数调用约定，它要求调用者清理堆栈。cdecl约定的函数参数也是从右往左依次压入堆栈中的，返回值通常存放在EAX寄存器中。 thiscall是一种微软的函数调用约定，它用于成员函数的调用。thiscall约定的函数参数是从右往左依次压入堆栈中的，返回值通常存放在EAX寄存器中，同时this指针会被压入ECX寄存器中。 下面是一个使用stdcall约定的C++函数的例子： ```cpp #include <iostream> using namespace std; // 声明使用stdcall约定 int __stdcall add(int a, int b); int main() { int a = 1, b = 2; int sum = add(a, b); cout << "sum = " << sum << endl; return 0; } // 定义使用stdcall约定 int __stdcall add(int a, int b) { return a + b; } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值