[function & type_traits] VC6 的 function traits 和 function 模板的新的实现方法

最新推荐文章于 2024-08-21 16:17:53 发布

cchhope

最新推荐文章于 2024-08-21 16:17:53 发布

阅读量785

点赞数

文章标签： function functor struct fun c++ c#

本文链接：https://blog.youkuaiyun.com/cchhope/article/details/2253394

版权

本文介绍如何在Visual C++ 6.0环境中利用Boost库的改进版本实现更灵活的函数特性和函数模板操作，包括自定义函数特性的实现方法及优化后的函数模板使用方式。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

以前写的《用 C++ 实现 C# 中的委托/事件》在VC6中无法完美实现现在终于可以了(还有一点点小缺憾)
委托部分就不提了

首先说function traits
在最新的boost 1.35中
VC6的function traits只支持参数个数
如:
typedef int func(int);
assert(boost::function_traits<func>::arity == 1);
不能得到参数和返回值的类型
用下面的方法, 就可以突破这个局限了

#include <boost/typeof/typeof.hpp>
namespace boost {
namespace detail {
template<typename Function> struct function_traits_helper;

template<typename R>
struct function_traits_helper0
{
BOOST_STATIC_CONSTANT(unsigned, arity = 0);
typedef R result_type;
};

template<typename R, typename T1>
struct function_traits_helper1
{
BOOST_STATIC_CONSTANT(unsigned, arity = 1);
typedef R result_type;
typedef T1 arg1_type;
.
.
.
};

template<typename F>
function_traits_helper<F> function_arity_helper(F* f);

template<typename R>
function_traits_helper0<R> function_arity_helper(R (*f)());

template<typename R, typename T1>
function_traits_helper1<R, T1> function_arity_helper(R (*f)(T1));
.
.
.
} // end namespace detail

template<typename Function>
struct function_traits : public
BOOST_TYPEOF(detail::function_arity_helper((Function*)0))
{
};
} // end namespace boost

限制:
VC6 不支持下面的语法:
typedef boost::function_traits<int(int)> function_traits1;
typedef boost::function_traits<int(*)(int)> function_traits2;
typedef boost::function_traits<int(&)(int)> function_traits3;
只支持:
typedef int func(int);
typedef boost::function_traits<func> function_traits1;

然后就轮到function模板了
boost中VC6的function模板只支持
如:
int func0();
boost::funtion0<int> fun0 = func0;
int func1(int);
boost::funtion1<int, int> fun1 = func1;
用起来甚是不爽
用了新方法之后就可以:
int func0();
typedef int typefunc0();
boost::funtion<typefunc0> fun0 = func0;
int func1(int);
typedef int typefunc1();
boost::funtion<typefunc1> fun1 = func1;
总算是改进了些

#include <boost/typeof/typeof.hpp>
#include <boost/function.hpp>
namespace boost
{
namespace function_detail {
template<typename F>
function_base function_arity_helper(F* f);

template<typename R>
function0<R> function_arity_helper(R (*f)());

template<typename R, typename T1>
function1<R, T1> function_arity_helper(R (*f)(T1));
.
.
.
} // end namespace detail

template<typename Function, typename Allocator = std::allocator<void> >
struct function : public
BOOST_TYPEOF(function_detail::function_arity_helper((Function*)0))
{
typedef
BOOST_TYPEOF_TPL(function_detail::function_arity_helper((Function*)0))
base_type;
typedef function self_type;

struct clear_type {};

public:
//typedef typename base_type::allocator_type allocator_type;
typedef Allocator allocator_type;

function() : base_type() {}

template<typename Functor>
function(Functor f
#ifndef BOOST_NO_SFINAE
           ,typename enable_if_c<
                            (boost::type_traits::ice_not<
                          (is_integral<Functor>::value)>::value),
                       int>::type = 0
#endif
           ) :
    base_type(f)
{
}

#ifndef BOOST_NO_SFINAE
function(clear_type*) : base_type() {}
#endif

function(const self_type& f) : base_type(static_cast<const
base_type&>(f)){}

function(const base_type& f) : base_type(static_cast<const
base_type&>(f)){}

self_type& operator=(const self_type& f)
{
self_type(f).swap(*this);
return *this;
}

template<typename Functor>
#ifndef BOOST_NO_SFINAE
typename enable_if_c<
                            (boost::type_traits::ice_not<
                         (is_integral<Functor>::value)>::value),
                      self_type&>::type
#else
self_type&
#endif
operator=(Functor f)
{
    self_type(f).swap(*this);
    return *this;
}

#ifndef BOOST_NO_SFINAE
self_type& operator=(clear_type*)
{
this->clear();
return *this;
}
#endif

self_type& operator=(const base_type& f)
{
    self_type(f).swap(*this);
    return *this;
}
};

template<typename Signature, typename Allocator>
inline void swap(function<Signature, Allocator>& f1,
                 function<Signature, Allocator>& f2)
{
f1.swap(f2);
}
}

限制:
同function traits.