xxfunction

C语言库函数的原型,有用的拿去

			_Fret (__stdcall _Farg0::*const _Val)(_FARG1_FARG2) const volatile,
			_Alloc _Ax)
		{	// store copy of _Val
		if (_Val == 0)
			_Set(0);
		else if (sizeof (_Myimpl) <= sizeof (_Space))
			{	// small enough, allocate locally
			new ((void *)&_Space) _Myimpl(_Val);
			_Set((_Ptrt *)&_Space);
			}
		else
			{	// use allocator
			typename _Alloc::template rebind<_Myimpl>::other _Al = _Ax;
			_Myimpl *_Ptr = _Al.allocate(1);

			new (_Ptr) _Myimpl(_Val, _Al);
			_Set(_Ptr);
			}
		}

  #ifndef _M_CEE
	template<class _Fret _C_CLASS_FARG0>
		void _Reset(_Fret (__fastcall _Farg0::*const _Val)(_FARG1_FARG2))
		{
		typedef _STD allocator<_Myty> _Alty0;
		typedef _Callable_pmf<_Fret (__fastcall _Farg0::*const)(_FARG1_FARG2), _Farg0>
			_MyWrapper;
		typedef _IMPL_NO_ALLOC_NAME<_MyWrapper, _Ret _C_ARG0_ARG1>
			_Myimpl;
		_Reset0pmf<_Myimpl>(_Val, _Alty0());
		}

	template<class _Fret _C_CLASS_FARG0,
		class _Alloc>
		void _Reset_alloc(_Fret (__fastcall _Farg0::*const _Val)(_FARG1_FARG2),
			_Alloc _Ax)
		{
		typedef _Callable_pmf<_Fret (__fastcall _Farg0::*const)(_FARG1_FARG2), _Farg0>
			_MyWrapper;
		typedef _IMPL_NAME<_MyWrapper, _Ret, _ARG0_ARG1, _Alloc> _Myimpl;
		_Reset0pmf<_Myimpl>(_Val, _Ax);
		}

	template<class _Myimpl,
		class _Fret _C_CLASS_FARG0,
		class _Alloc>
		void _Reset0pmf(_Fret (__fastcall _Farg0::*const _Val)(_FARG1_FARG2),
			_Alloc _Ax)
		{	// store copy of _Val
		if (_Val == 0)
			_Set(0);
		else if (sizeof (_Myimpl) <= sizeof (_Space))
			{	// small enough, allocate locally
			new ((void *)&_Space) _Myimpl(_Val);
			_Set((_Ptrt *)&_Space);
			}
		else
			{	// use allocator
			typename _Alloc::template rebind<_Myimpl>::other _Al = _Ax;
			_Myimpl *_Ptr = _Al.allocate(1);

			new (_Ptr) _Myimpl(_Val, _Al);
			_Set(_Ptr);
			}
		}

	template<class _Fret _C_CLASS_FARG0>
		void _Reset(_Fret (__fastcall _Farg0::*const _Val)(_FARG1_FARG2) const)
		{
		typedef _STD allocator<_Myty> _Alty0;
		typedef _Callable_pmf<
			_Fret (__fastcall _Farg0::*const)(_FARG1_FARG2) const, _Farg0> _MyWrapper;
		typedef _IMPL_NO_ALLOC_NAME<_MyWrapper, _Ret _C_ARG0_ARG1>
			_Myimpl;
		_Reset0pmfc<_Myimpl>(_Val, _Alty0());
		}

	template<class _Fret _C_CLASS_FARG0,
		class _Alloc>
		void _Reset_alloc(_Fret (__fastcall _Farg0::*const _Val)(_FARG1_FARG2) const,
			_Alloc _Ax)
		{
		typedef _Callable_pmf<
			_Fret (__fastcall _Farg0::*const)(_FARG1_FARG2) const, _Farg0> _MyWrapper;
		typedef _IMPL_NAME<_MyWrapper, _Ret, _ARG0_ARG1, _Alloc> _Myimpl;
		_Reset0pmfc<_Myimpl>(_Val, _Ax);
		}

	template<class _Myimpl,
		class _Fret _C_CLASS_FARG0,
		class _Alloc>
		void _Reset0pmfc(_Fret (__fastcall _Farg0::*const _Val)(_FARG1_FARG2) const,
			_Alloc _Ax)
		{	// store copy of _Val
		if (_Val == 0)
			_Set(0);
		else if (sizeof (_Myimpl) <= sizeof (_Space))
			{	// small enough, allocate locally
			new ((void *)&_Space) _Myimpl(_Val);
			_Set((_Ptrt *)&_Space);
			}
		else
			{	// use allocator
			typename _Alloc::template rebind<_Myimpl>::other _Al = _Ax;
			_Myimpl *_Ptr = _Al.allocate(1);

			new (_Ptr) _Myimpl(_Val, _Al);
			_Set(_Ptr);
			}
		}

	template<class _Fret _C_CLASS_FARG0>
		void _Reset(_Fret (__fastcall _Farg0::*const _Val)(_FARG1_FARG2) volatile)
		{
		typedef _STD allocator<_Myty> _Alty0;
		typedef _Callable_pmf<
			_Fret (__fastcall _Farg0::*const)(_FARG1_FARG2) volatile, _Farg0> _MyWrapper;
		typedef _IMPL_NO_ALLOC_NAME<_MyWrapper, _Ret _C_ARG0_ARG1>
			_Myimpl;
		_Reset0pmfv<_Myimpl>(_Val, _Alty0());
		}

	template<class _Fret _C_CLASS_FARG0,
		class _Alloc>
		void _Reset_alloc(_Fret (__fastcall _Farg0::*const _Val)(_FARG1_FARG2) volatile,
			_Alloc _Ax)
		{
		typedef _Callable_pmf<
			_Fret (__fastcall _Farg0::*const)(_FARG1_FARG2) volatile, _Farg0> _MyWrapper;
		typedef _IMPL_NAME<_MyWrapper, _Ret, _ARG0_ARG1, _Alloc> _Myimpl;
		_Reset0pmfv<_Myimpl>(_Val, _Ax);
		}

	template<class _Myimpl,
		class _Fret _C_CLASS_FARG0,
		class _Alloc>
		void _Reset0pmfv(_Fret (__fastcall _Farg0::*const _Val)(_FARG1_FARG2) volatile,
			_Alloc _Ax)
		{	// store copy of _Val
		if (_Val == 0)
			_Set(0);
		else if (sizeof (_Myimpl) <= sizeof (_Space))
			{	// small enough, allocate locally
			new ((void *)&_Space) _Myimpl(_Val);
			_Set((_Ptrt *)&_Space);
			}
		else
			{	// use allocator
			typename _Alloc::template rebind<_Myimpl>::other _Al = _Ax;
			_Myimpl *_Ptr = _Al.allocate(1);

			new (_Ptr) _Myimpl(_Val, _Al);
			_Set(_Ptr);
			}
		}

	template<class _Fret _C_CLASS_FARG0>
		void _Reset(_Fret (__fastcall _Farg0::*const _Val)(_FARG1_FARG2) const volatile)
		{
		typedef _STD allocator<_Myty> _Alty0;
		typedef _Callable_pmf<
			_Fret (__fastcall _Farg0::*const)(_FARG1_FARG2) const volatile, _Farg0>
			_MyWrapper;
		typedef _IMPL_NO_ALLOC_NAME<_MyWrapper, _Ret _C_ARG0_ARG1>
			_Myimpl;
		_Reset0pmfcv<_Myimpl>(_Val, _Alty0());
		}

	template<class _Fret _C_CLASS_FARG0,
		class _Alloc>
		void _Reset_alloc(
			_Fret (__fastcall _Farg0::*const _Val)(_FARG1_FARG2) const volatile,
			_Alloc _Ax)
		{
		typedef _Callable_pmf<
			_Fret (__fastcall _Farg0::*const)(_FARG1_FARG2) const volatile, _Farg0>
			_MyWrapper;
		typedef _IMPL_NAME<_MyWrapper, _Ret, _ARG0_ARG1, _Alloc> _Myimpl;
		_Reset0pmfcv<_Myimpl>(_Val, _Ax);
		}

	template<class _Myimpl,
		class _Fret _C_CLASS_FARG0,
		class _Alloc>
		void _Reset0pmfcv(
			_Fret (__fastcall _Farg0::*const _Val)(_FARG1_FARG2) const volatile,
			_Alloc _Ax)
		{	// store copy of _Val
		if (_Val == 0)
			_Set(0);
		else if (sizeof (_Myimpl) <= sizeof (_Space))
			{	// small enough, allocate locally
			new ((void *)&_Space) _Myimpl(_Val);
			_Set((_Ptrt *)&_Space);
			}
		else
			{	// use allocator
			typename _Alloc::template rebind<_Myimpl>::other _Al = _Ax;
			_Myimpl *_Ptr = _Al.allocate(1);

			new (_Ptr) _Myimpl(_Val, _Al);
			_Set(_Ptr);
			}
		}
  #endif /* _M_CEE */

 #endif /* _M_IX86 */

 #ifdef _M_CEE
	template<class _Fret _C_CLASS_FARG0>
		void _Reset(_Fret (__clrcall _Farg0::*const _Val)(_FARG1_FARG2))
		{
		typedef _STD allocator<_Myty> _Alty0;
		typedef _Callable_pmf<_Fret (__clrcall _Farg0::*const)(_FARG1_FARG2), _Farg0>
			_MyWrapper;
		typedef _IMPL_NO_ALLOC_NAME<_MyWrapper, _Ret _C_ARG0_ARG1>
			_Myimpl;
		_Reset0pmf<_Myimpl>(_Val, _Alty0());
		}

	template<class _Fret _C_CLASS_FARG0,
		class _Alloc>
		void _Reset_alloc(_Fret (__clrcall _Farg0::*const _Val)(_FARG1_FARG2),
			_Alloc _Ax)
		{
		typedef _Callable_pmf<_Fret (__clrcall _Farg0::*const)(_FARG1_FARG2), _Farg0>
			_MyWrapper;
		typedef _IMPL_NAME<_MyWrapper, _Ret, _ARG0_ARG1, _Alloc> _Myimpl;
		_Reset0pmf<_Myimpl>(_Val, _Ax);
		}

	template<class _Myimpl,
		class _Fret _C_CLASS_FARG0,
		class _Alloc>
		void _Reset0pmf(_Fret (__clrcall _Farg0::*const _Val)(_FARG1_FARG2),
			_Alloc _Ax)
		{	// store copy of _Val
		if (_Val == 0)
			_Set(0);
		else if (sizeof (_Myimpl) <= sizeof (_Space))
			{	// small enough, allocate locally
			new ((void *)&_Space) _Myimpl(_Val);
			_Set((_Ptrt *)&_Space);
			}
		else
			{	// use allocator
			typename _Alloc::template rebind<_Myimpl>::other _Al = _Ax;
			_Myimpl *_Ptr = _Al.allocate(1);

			new (_Ptr) _Myimpl(_Val, _Al);
			_Set(_Ptr);
			}
		}

	template<class _Fret _C_CLASS_FARG0>
		void _Reset(_Fret (__clrcall _Farg0::*const _Val)(_FARG1_FARG2) const)
		{
		typedef _STD allocator<_Myty> _Alty0;
		typedef _Callable_pmf<
			_Fret (__clrcall _Farg0::*const)(_FARG1_FARG2) const, _Farg0> _MyWrapper;
		typedef _IMPL_NO_ALLOC_NAME<_MyWrapper, _Ret _C_ARG0_ARG1>
			_Myimpl;
		_Reset0pmfc<_Myimpl>(_Val, _Alty0());
		}

	template<class _Fret _C_CLASS_FARG0,
		class _Alloc>
		void _Reset_alloc(_Fret (__clrcall _Farg0::*const _Val)(_FARG1_FARG2) const,
			_Alloc _Ax)
		{
		typedef _Callable_pmf<
			_Fret (__clrcall _Farg0::*const)(_FARG1_FARG2) const, _Farg0> _MyWrapper;
		typedef _IMPL_NAME<_MyWrapper, _Ret, _ARG0_ARG1, _Alloc> _Myimpl;
		_Reset0pmfc<_Myimpl>(_Val, _Ax);
		}

	template<class _Myimpl,
		class _Fret _C_CLASS_FARG0,
		class _Alloc>
		void _Reset0pmfc(_Fret (__clrcall _Farg0::*const _Val)(_FARG1_FARG2) const,
			_Alloc _Ax)
		{	// store copy of _Val
		if (_Val == 0)
			_Set(0);
		else if (sizeof (_Myimpl) <= sizeof (_Space))
			{	// small enough, allocate locally
			new ((void *)&_Space) _Myimpl(_Val);
			_Set((_Ptrt *)&_Space);
			}
		else
			{	// use allocator
			typename _Alloc::template rebind<_Myimpl>::other _Al = _Ax;
			_Myimpl *_Ptr = _Al.allocate(1);

			new (_Ptr) _Myimpl(_Val, _Al);
			_Set(_Ptr);
			}
		}

	template<class _Fret _C_CLASS_FARG0>
		void _Reset(_Fret (__clrcall _Farg0::*const _Val)(_FARG1_FARG2) volatile)
		{
		typedef _STD allocator<_Myty> _Alty0;
		typedef _Callable_pmf<
			_Fret (__clrcall _Farg0::*const)(_FARG1_FARG2) volatile, _Farg0> _MyWrapper;
		typedef _IMPL_NO_ALLOC_NAME<_MyWrapper, _Ret _C_ARG0_ARG1>
			_Myimpl;
		_Reset0pmfv<_Myimpl>(_Val, _Alty0());
		}

	template<class _Fret _C_CLASS_FARG0,
		class _Alloc>
		void _Reset_alloc(_Fret (__clrcall _Farg0::*const _Val)(_FARG1_FARG2) volatile,
			_Alloc _Ax)
		{
		typedef _Callable_pmf<
			_Fret (__clrcall _Farg0::*const)(_FARG1_FARG2) volatile, _Farg0> _MyWrapper;
		typedef _IMPL_NAME<_MyWrapper, _Ret, _ARG0_ARG1, _Alloc> _Myimpl;
		_Reset0pmfv<_Myimpl>(_Val, _Ax);
		}

	template<class _Myimpl,
		class _Fret _C_CLASS_FARG0,
		class _Alloc>
		void _Reset0pmfv(_Fret (__clrcall _Farg0::*const _Val)(_FARG1_FARG2) volatile,
			_Alloc _Ax)
		{	// store copy of _Val
		if (_Val == 0)
			_Set(0);
		else if (sizeof (_Myimpl) <= sizeof (_Space))
			{	// small enough, allocate locally
			new ((void *)&_Space) _Myimpl(_Val);
			_Set((_Ptrt *)&_Space);
			}
		else
			{	// use allocator
			typename _Alloc::template rebind<_Myimpl>::other _Al = _Ax;
			_Myimpl *_Ptr = _Al.allocate(1);

			new (_Ptr) _Myimpl(_Val, _Al);
			_Set(_Ptr);
			}
		}

	template<class _Fret _C_CLASS_FARG0>
		void _Reset(_Fret (__clrcall _Farg0::*const _Val)(_FARG1_FARG2) const volatile)
		{
		typedef _STD allocator<_Myty> _Alty0;
		typedef _Callable_pmf<
			_Fret (__clrcall _Farg0::*const)(_FARG1_FARG2) const volatile, _Farg0>
			_MyWrapper;
		typedef _IMPL_NO_ALLOC_NAME<_MyWrapper, _Ret _C_ARG0_ARG1>
			_Myimpl;
		_Reset0pmfcv<_Myimpl>(_Val, _Alty0());
		}

	template<class _Fret _C_CLASS_FARG0,
		class _Alloc>
		void _Reset_alloc(
			_Fret (__clrcall _Farg0::*const _Val)(_FARG1_FARG2) const volatile,
			_Alloc _Ax)
		{
		typedef _Callable_pmf<
			_Fret (__clrcall _Farg0::*const)(_FARG1_FARG2) const volatile, _Farg0>
			_MyWrapper;
		typedef _IMPL_NAME<_MyWrapper, _Ret, _ARG0_ARG1, _Alloc> _Myimpl;
		_Reset0pmfcv<_Myimpl>(_Val, _Ax);
		}

	template<class _Myimpl,
		class _Fret _C_CLASS_FARG0,
		class _Alloc>
		void _Reset0pmfcv(
			_Fret (__clrcall _Farg0::*const _Val)(_FARG1_FARG2) const volatile,
			_Alloc _Ax)
		{	// store copy of _Val
		if (_Val == 0)
			_Set(0);
		else if (sizeof (_Myimpl) <= sizeof (_Space))
			{	// small enough, allocate locally
			new ((void *)&_Space) _Myimpl(_Val);
			_Set((_Ptrt *)&_Space);
			}
		else
			{	// use allocator
			typename _Alloc::template rebind<_Myimpl>::other _Al = _Ax;
			_Myimpl *_Ptr = _Al.allocate(1);

			new (_Ptr) _Myimpl(_Val, _Al);
			_Set(_Ptr);
			}
		}
 #endif /* _M_CEE */

 #endif /* _NARGS */

	void _Tidy()
		{	// clean up
		if (_Impl != 0)
			{	// destroy callable object and maybe delete it
			_Impl->_Delete_this(!_Local());
			_Impl = 0;
			}
		}

	void _Swap(_Myty& _Right)
		{	// swap contents with contents of _Right
		if (this == &_Right)
			;	// same object, do nothing
		else if (_Local())
			if (_Right._Local())
				{	// both local
				_Myty _Temp;
				_Temp._Reset(*this);
				_Tidy();
				_Reset(_Right);
				_Right._Tidy();
				_Right._Reset(_Temp);
				_Temp._Tidy();
				}
			else
				{	// *this local, _Right remote/null
				_Ptrt *_Temp = _Right._Impl;
				_Right._Reset(*this);
				_Tidy();
				_Set(_Temp);
				}
		else
			if (_Right._Local())
				{	// *this remote/null, _Right local
				_Ptrt *_Temp = _Impl;
				_Reset(_Right);
				_Right._Tidy();
				_Right._Set(_Temp);
				}
			else
				_STD swap(_Impl, _Right._Impl);	// both remote/null
		}

	const _XSTD2 type_info& _Target_type() const
		{	// return type information for stored object
		return (_Impl ? _Impl->_Target_type() : typeid(void));
		}

	const void *_Target(const _XSTD2 type_info& _Info) const
		{	// return pointer to stored object
		return (_Impl ? _Impl->_Target(_Info) : 0);
		}

private:
	bool _Local() const
		{	// test for locally stored copy of object
		return ((void *)_Impl == (void *)&_Space);
		}

	void _Set(_Ptrt *_Ptr)
		{	// store pointer to object
		_Impl = _Ptr;
		}

	typedef void (*_Pfnty)();
	union _Space_union
		{	// storage for small wrappers
		_Pfnty _Pfn[3];
		void *_Pobj[3];
		long double _Ldbl;	// for maximum alignment
		char _Alias[3 * sizeof (void *)];	// to permit aliasing
		} _Space;

	_Ptrt *_Impl;
	};

template<class _Ret _C_CLASS_ARG0>
	struct _Get_function_impl<_Ret(_ARG0_ARG1)>
	{	// determine type from argument list
	typedef _NAME<_Ret _C_ARG0_ARG1> _Type;
	};

#undef _IMPL_NO_ALLOC_NAME
#undef _IMPL_NAME
#undef _BASE_NAME
#undef _NAME

/*
 * Copyright (c) 1992-2009 by P.J. Plauger.  ALL RIGHTS RESERVED.
 * Consult your license regarding permissions and restrictions.
V5.20:0009 */