增强boost中function_traits的能力

最新推荐文章于 2024-08-21 16:17:53 发布
最新推荐文章于 2024-08-21 16:17:53 发布
阅读量2.7k 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： C/C++ 文章标签： function struct c++ 文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Realdodo/article/details/1200509
本文介绍了一个针对Boost库function_traits的增强方案，新增了对成员函数的trait提取功能，包括返回类型、参数类型及父类类型等。通过偏特化模板实现了这一目标。

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

boost的type_traits功能相当强大，特别是function_traits，能够辅助做很多事情。
但是美中不足，function_traits竟然没有针对成员函数做任何的traits提取，似乎有些缺憾。我在boost 1.33基础上修改了boost/type_traits/function_traits.hpp的内容，增强其中的功能，希望能够暂时弥补一下这个遗憾。
以下就直接贴代码了，在Begin of Added by realdodo和End of Added by realdodo之间的就是我的修改了。如果想了解这个function_traits是怎么用的，可以参考 http://www.boost.org/上面的文档。如果想了解原理，那就看看C++ Template里面关于模板偏特化的描述，其实我主要是在做体力活啦。
当然，自己下一个boost用一下、改一下还是最能够说明问题。


//   Copyright 2000 John Maddock (john@johnmaddock.co.uk)
 //   Use, modification and distribution are subject to the Boost Software License,
 //   Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 //    http://www.boost.org/LICENSE_1_0.txt ).
 //
//   See  http://www.boost.org/libs/type_traits  for most recent version including documentation.

#ifndef BOOST_TT_FUNCTION_TRAITS_HPP_INCLUDED
 #define  BOOST_TT_FUNCTION_TRAITS_HPP_INCLUDED

#include  < boost / config.hpp >
#include  < boost / type_traits / is_function.hpp >
#include  < boost / type_traits / add_pointer.hpp >

namespace  boost  {

#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
namespace detail {

template<typename Function> struct function_traits_helper;

template<typename R>
struct function_traits_helper<R (*)(void)>
{
  BOOST_STATIC_CONSTANT(int, arity = 0);
  typedef R result_type;
};

template<typename R, typename T1>
struct function_traits_helper<R (*)(T1)>
{
  BOOST_STATIC_CONSTANT(int, arity = 1);
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T1 argument_type;
};

template<typename R, typename T1, typename T2>
struct function_traits_helper<R (*)(T1, T2)>
{
  BOOST_STATIC_CONSTANT(int, arity = 2);
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T1 first_argument_type;
  typedef T2 second_argument_type;
};

template<typename R, typename T1, typename T2, typename T3>
struct function_traits_helper<R (*)(T1, T2, T3)>
{
  BOOST_STATIC_CONSTANT(int, arity = 3);
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
};

template<typename R, typename T1, typename T2, typename T3, typename T4>
struct function_traits_helper<R (*)(T1, T2, T3, T4)>
{
  BOOST_STATIC_CONSTANT(int, arity = 4);
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
  typedef T4 arg4_type;
};

template<typename R, typename T1, typename T2, typename T3, typename T4,
         typename T5>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5)>
{
  BOOST_STATIC_CONSTANT(int, arity = 5);
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
  typedef T4 arg4_type;
  typedef T5 arg5_type;
};

template<typename R, typename T1, typename T2, typename T3, typename T4,
         typename T5, typename T6>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6)>
{
  BOOST_STATIC_CONSTANT(int, arity = 6);
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
  typedef T4 arg4_type;
  typedef T5 arg5_type;
  typedef T6 arg6_type;
};

template<typename R, typename T1, typename T2, typename T3, typename T4,
         typename T5, typename T6, typename T7>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7)>
{
  BOOST_STATIC_CONSTANT(int, arity = 7);
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
  typedef T4 arg4_type;
  typedef T5 arg5_type;
  typedef T6 arg6_type;
  typedef T7 arg7_type;
};

template<typename R, typename T1, typename T2, typename T3, typename T4,
         typename T5, typename T6, typename T7, typename T8>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8)>
{
  BOOST_STATIC_CONSTANT(int, arity = 8);
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
  typedef T4 arg4_type;
  typedef T5 arg5_type;
  typedef T6 arg6_type;
  typedef T7 arg7_type;
  typedef T8 arg8_type;
};

template<typename R, typename T1, typename T2, typename T3, typename T4,
         typename T5, typename T6, typename T7, typename T8, typename T9>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9)>
{
  BOOST_STATIC_CONSTANT(int, arity = 9);
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
  typedef T4 arg4_type;
  typedef T5 arg5_type;
  typedef T6 arg6_type;
  typedef T7 arg7_type;
  typedef T8 arg8_type;
  typedef T9 arg9_type;
};

template<typename R, typename T1, typename T2, typename T3, typename T4,
         typename T5, typename T6, typename T7, typename T8, typename T9,
         typename T10>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
{
  BOOST_STATIC_CONSTANT(int, arity = 10);
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
  typedef T4 arg4_type;
  typedef T5 arg5_type;
  typedef T6 arg6_type;
  typedef T7 arg7_type;
  typedef T8 arg8_type;
  typedef T9 arg9_type;
  typedef T10 arg10_type;
};

//
// Begin of Added by realdodo.
//

template <typename R,
          typename Parent>
struct function_traits_helper<R (Parent::**)()>
{
    BOOST_STATIC_CONSTANT(int, arity = 0);
    typedef R result_type;
    typedef Parent parent_type;
};

template <typename R,
          typename Parent,
          typename T1>
struct function_traits_helper<R (Parent::**)(T1)>
{
    BOOST_STATIC_CONSTANT(int, arity = 1);
    typedef R result_type;
    typedef Parent parent_type;
    typedef T1 arg1_type;
};

template <typename R,
          typename Parent,
          typename T1,
          typename T2>
struct function_traits_helper<R (Parent::**)(T1, T2)>
{
    BOOST_STATIC_CONSTANT(int, arity = 2);
    typedef R result_type;
    typedef Parent parent_type;
    typedef T1 arg1_type;
    typedef T2 arg2_type;
};

template <typename R,
          typename Parent,
          typename T1,
          typename T2,
          typename T3>
struct function_traits_helper<R (Parent::**)(T1, T2, T3)>
{
    BOOST_STATIC_CONSTANT(int, arity = 3);
    typedef R result_type;
    typedef Parent parent_type;
    typedef T1 arg1_type;
    typedef T2 arg2_type;
    typedef T3 arg3_type;
};

template <typename R,
          typename Parent,
          typename T1,
          typename T2,
          typename T3,
          typename T4>
struct function_traits_helper<R (Parent::**)(T1, T2, T3, T4)>
{
    BOOST_STATIC_CONSTANT(int, arity = 4);
    typedef R result_type;
    typedef Parent parent_type;
    typedef T1 arg1_type;
    typedef T2 arg2_type;
    typedef T3 arg3_type;
    typedef T4 arg4_type;
};

template <typename R,
          typename Parent,
          typename T1,
          typename T2,
          typename T3,
          typename T4,
          typename T5>
struct function_traits_helper<R (Parent::**)(T1, T2, T3, T4, T5)>
{
    BOOST_STATIC_CONSTANT(int, arity = 5);
    typedef R result_type;
    typedef Parent parent_type;
    typedef T1 arg1_type;
    typedef T2 arg2_type;
    typedef T3 arg3_type;
    typedef T4 arg4_type;
    typedef T5 arg5_type;
};

template <typename R,
          typename Parent,
          typename T1,
          typename T2,
          typename T3,
          typename T4,
          typename T5,
          typename T6>
struct function_traits_helper<R (Parent::**)(T1, T2, T3, T4, T5, T6)>
{
    BOOST_STATIC_CONSTANT(int, arity = 6);
    typedef R result_type;
    typedef Parent parent_type;
    typedef T1 arg1_type;
    typedef T2 arg2_type;
    typedef T3 arg3_type;
    typedef T4 arg4_type;
    typedef T5 arg5_type;
    typedef T6 arg6_type;
};

template <typename R,
          typename Parent,
          typename T1,
          typename T2,
          typename T3,
          typename T4,
          typename T5,
          typename T6,
          typename T7>
struct function_traits_helper<R (Parent::**)(T1, T2, T3, T4, T5, T6, T7)>
{
    BOOST_STATIC_CONSTANT(int, arity = 7);
    typedef R result_type;
    typedef Parent parent_type;
    typedef T1 arg1_type;
    typedef T2 arg2_type;
    typedef T3 arg3_type;
    typedef T4 arg4_type;
    typedef T5 arg5_type;
    typedef T6 arg6_type;
    typedef T7 arg7_type;
};

template <typename R,
          typename Parent,
          typename T1,
          typename T2,
          typename T3,
          typename T4,
          typename T5,
          typename T6,
          typename T7,
          typename T8>
struct function_traits_helper<R (Parent::**)(T1, T2, T3, T4, T5, T6, T7, T8)>
{
    BOOST_STATIC_CONSTANT(int, arity = 8);
    typedef R result_type;
    typedef Parent parent_type;
    typedef T1 arg1_type;
    typedef T2 arg2_type;
    typedef T3 arg3_type;
    typedef T4 arg4_type;
    typedef T5 arg5_type;
    typedef T6 arg6_type;
    typedef T7 arg7_type;
    typedef T8 arg8_type;
};

template <typename R,
          typename Parent,
          typename T1,
          typename T2,
          typename T3,
          typename T4,
          typename T5,
          typename T6,
          typename T7,
          typename T8,
          typename T9>
struct function_traits_helper<R (Parent::**)(T1, T2, T3, T4, T5, T6, T7, T8, T9)>
{
    BOOST_STATIC_CONSTANT(int, arity = 9);
    typedef R result_type;
    typedef Parent parent_type;
    typedef T1 arg1_type;
    typedef T2 arg2_type;
    typedef T3 arg3_type;
    typedef T4 arg4_type;
    typedef T5 arg5_type;
    typedef T6 arg6_type;
    typedef T7 arg7_type;
    typedef T8 arg8_type;
    typedef T9 arg9_type;
};

template <typename R,
          typename Parent,
          typename T1,
          typename T2,
          typename T3,
          typename T4,
          typename T5,
          typename T6,
          typename T7,
          typename T8,
          typename T9,
          typename T10>
struct function_traits_helper<R (Parent::**)(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
{
    BOOST_STATIC_CONSTANT(int, arity = 10);
    typedef R result_type;
    typedef Parent parent_type;
    typedef T1 arg1_type;
    typedef T2 arg2_type;
    typedef T3 arg3_type;
    typedef T4 arg4_type;
    typedef T5 arg5_type;
    typedef T6 arg6_type;
    typedef T7 arg7_type;
    typedef T8 arg8_type;
    typedef T9 arg9_type;
    typedef T10 arg10_type;
};

//
// End of Added by realdodo.
//

} // end namespace detail

template<typename Function>
struct function_traits : 
    public detail::function_traits_helper<typename add_pointer<Function>::type>
{
};

#else

namespace detail {

template<int N> 
struct type_of_size
{
  char elements[N];
};

template<typename R>
type_of_size<1> function_arity_helper(R (*f)());

template<typename R, typename T1>
type_of_size<2> function_arity_helper(R (*f)(T1));

template<typename R, typename T1, typename T2>
type_of_size<3> function_arity_helper(R (*f)(T1, T2));

template<typename R, typename T1, typename T2, typename T3>
type_of_size<4> function_arity_helper(R (*f)(T1, T2, T3));

template<typename R, typename T1, typename T2, typename T3, typename T4>
type_of_size<5> function_arity_helper(R (*f)(T1, T2, T3, T4));

template<typename R, typename T1, typename T2, typename T3, typename T4,
         typename T5>
type_of_size<6> function_arity_helper(R (*f)(T1, T2, T3, T4, T5));

template<typename R, typename T1, typename T2, typename T3, typename T4,
         typename T5, typename T6>
type_of_size<7> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6));

template<typename R, typename T1, typename T2, typename T3, typename T4,
         typename T5, typename T6, typename T7>
type_of_size<8> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6, T7));

template<typename R, typename T1, typename T2, typename T3, typename T4,
         typename T5, typename T6, typename T7, typename T8>
type_of_size<9> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6, T7, T8));

template<typename R, typename T1, typename T2, typename T3, typename T4,
         typename T5, typename T6, typename T7, typename T8, typename T9>
type_of_size<10> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6, T7, T8, 
                                              T9));

template<typename R, typename T1, typename T2, typename T3, typename T4,
         typename T5, typename T6, typename T7, typename T8, typename T9,
         typename T10>
type_of_size<11> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6, T7, T8, 
                                              T9, T10));

//
// Begin of Added by realdodo.
//

template<typename R, typename P>
type_of_size<1> function_arity_helper(R (P::*f)());

template<typename R, typename P, typename T1>
type_of_size<2> function_arity_helper(R (P::*f)(T1));

template<typename R, typename P, typename T1, typename T2>
type_of_size<3> function_arity_helper(R (P::*f)(T1, T2));

template<typename R, typename P, typename T1, typename T2, typename T3>
type_of_size<4> function_arity_helper(R (P::*f)(T1, T2, T3));

template<typename R, typename P, typename T1, typename T2, typename T3, typename T4>
type_of_size<5> function_arity_helper(R (P::*f)(T1, T2, T3, T4));

template<typename R, typename P, typename T1, typename T2, typename T3, typename T4,
         typename T5>
type_of_size<6> function_arity_helper(R (P::*f)(T1, T2, T3, T4, T5));

template<typename R, typename P, typename T1, typename T2, typename T3, typename T4,
         typename T5, typename T6>
type_of_size<7> function_arity_helper(R (P::*f)(T1, T2, T3, T4, T5, T6));

template<typename R, typename P, typename T1, typename T2, typename T3, typename T4,
         typename T5, typename T6, typename T7>
type_of_size<8> function_arity_helper(R (P::*f)(T1, T2, T3, T4, T5, T6, T7));

template<typename R, typename P, typename T1, typename T2, typename T3, typename T4,
         typename T5, typename T6, typename T7, typename T8>
type_of_size<9> function_arity_helper(R (P::*f)(T1, T2, T3, T4, T5, T6, T7, T8));

template<typename R, typename P, typename T1, typename T2, typename T3, typename T4,
         typename T5, typename T6, typename T7, typename T8, typename T9>
type_of_size<10> function_arity_helper(R (P::*f)(T1, T2, T3, T4, T5, T6, T7, T8, 
                                              T9));

template<typename R, typename P, typename T1, typename T2, typename T3, typename T4,
         typename T5, typename T6, typename T7, typename T8, typename T9,
         typename T10>
type_of_size<11> function_arity_helper(R (P::*f)(T1, T2, T3, T4, T5, T6, T7, T8, 
                                              T9, T10));

//
// End of Added by realdodo.
//

} // end namespace detail

// Won't work with references
template<typename Function>
struct function_traits
{
  BOOST_STATIC_CONSTANT(int, arity = (sizeof(detail::function_arity_helper((Function*)0))-1));
};

#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
}

#endif   //  BOOST_TT_FUNCTION_TRAITS_HPP_INCLUDED
 
Boost库中的leaf库提供了一些能够方便地进行错误处理的API和工具，其中就包括函数模板类`function_traits`
uote_e的博客
08-24 141
它的主要作用是通过参数推导从函数指针或函数对象中提取返回值类型和参数类型，这可以方便地实现泛型编程中的函数类型检查等需求。的测试程序，我们将输入不同类型的函数指针或函数对象，并打印出它们的返回值类型和参数列表。Boost库中的leaf库提供了一些能够方便地进行错误处理的API和工具，其中就包括函数模板类。模板能够准确地从函数指针或可调用对象中提取类型信息，并且在编译期进行检查。只适用于具有确定返回值和参数类型的函数。模板，我们可以写出更加安全和可维护的泛型代码。下面是一个简单的使用。当然，需要注意的是，
C++中boost库的function_types::is_member_function_pointer用法示例
HackNebulaZ的博客
09-04 114
C++中boost库的function_types::is_member_function_pointer用法示例。编译并运行上述代码，输出将显示"Is member function pointer: true"，表明。的静态成员常量，用于指示给定类型是否是成员函数指针。是一个类型特征（type trait），它提供了一个名为。，我们可以根据类型的属性进行条件编译或其他逻辑处理。在这个示例中，我们将使用boost库中的。的类，并在其中声明了一个成员函数。在主函数中，我们定义了一个名为。
boost function_traits
freemannnn的专栏
05-07 977
Expression Result function_traitsvoid (void)>::arity 值为0的整形常量表达式 function_traitslong (int)>::arity 值为1的整形常量表达式 function_traitslong (int, long, double,void*)>:
boost源码剖析之：泛型编程精灵type_traits(rev#2)
08-24 125
boost源码剖析之：泛型编程精灵type_traits(rev#2) 刘未鹏 C++的罗浮宫(http://blog.youkuaiyun.com/pongba) 动机 使用traits的动机一般有三种，分派、效率、使某些代码通过编译。 分派 下面有一个模板函数，假设一个动物收容组织提供了它，他们接受所有无家可归的可怜的小动物，于是他们向外界提供了一个函数接受注册。函数看起来像这样：...
续：增强boost中function_traits的能力
随.心.所.记
09-12 1716
上一篇说过，在function_traits里面加入成员函数类型traits的工作纯粹是体力活，那么原作者没有理由“忽略”这个方面——毕竟他已经做了绝大多数的体力活，这个type_traits库就是大智慧和大工作量“完美结合”的产物。 那么，why not？就这个问题我专门写信给作者John Maddock，他的回答让我不太理解了：I dont think this is quite t
function_traits
lishaoyu的专栏
11-28 1627
template struct function_traits { private: using call_type = function_traits ; public: using return_type = typename call_type::return_type; static const std::size_t arity = call_type::ar
再续：增强boost中function_traits的能力
随.心.所.记
09-12 2015
关于这个问题，John Maddock老大在新闻组里面给出了很详细的解答，虽然我还有些问题要问，不过得好好组织一下怎么说才行……可不要浪费网络资源哈~主要意思是，对于成员函数traits而言，一方面有const和volatile的麻烦事情，另一方面又有一个隐含的this参数不好处理（究竟是算一个入口参数还是不算？），最重要的是这种应用需求完全可以用其他方式替代。所以，John认为没有必要实现这样的
boost_1_44_0
01-06
Boost库，全称为"Boost C++ Libraries"，是C++编程语言中广泛使用的一个开源库。这个库由一系列高质量的、跨平台的、免费的C++库组成，它旨在提升C++的效率、功能和可移植性。"boost_1_44_0"是Boost库的一个特定版本...
boost_1_72_0 64位
12-13
Boost库是C++编程语言中的一个开源库集合，它提供了大量的高效、跨平台的库，以增强C++的标准库功能。Boost库在C++社区中广受赞誉，因其高质量、经过充分测试的代码以及对标准的贡献而闻名。在本案例中，"boost_1_72...
boost_1_58_0.zip
06-15
Boost库，全称为C++ Boost库，是一个广受欢迎的开源C++库集合，旨在提高C++程序员的效率和代码的可移植性。Boost库由Boost社区的开发者们精心设计和维护，它不仅提供了对C++标准库的补充，还引入了许多现代编程技术...
各种数据库之间的数据转换。
08-20
mysql oracle sql 。。。 各种数据库 之间的相互转换，语言可以设置为中文简体。它可以帮助你将数据库从一种格式转换为另外一个数据库格式,该工具大大减少了工作量、成本和风险转移。
function traits
刘捷的专栏
09-29 2052
我写的一个简单的 function traits，功能比 boost::unary_traits 和 boost::binary_traits 强，下面是其实现和一个简单的demo。这个function traits已经被我用在了一个C++ delegate 上，不过做了一些修改，但事实证明这个function_traits很有用。template struct function_traits;/
5) 函数特征functionTraits [原创,泛型编程,自由下载转载，需注明出处]
申晓龙的专栏
02-12 1147
前面已经有了类型特征，用于判断一个类型的各种属性。 函数也是程序设计中的一个重要概念，因此判断一个函数的各种属性也很重要。 这些属性包括一个函数的： 返回值，参数个数，每个参数的类型 如果是成员函数，还应该包括对象的类型。 这个文件支持了查询函数属性的功能，但是最多只支持5个参数的函数(成员函数的对象类型除外) #ifndef functorTraits_h__ #defin
C++组件扩展实现:函数特性function_traits
weixin_43698578的博客
06-28 675
C++组件扩展实现
c++11之function_traits
lq123的博客
07-28 3028
function_traits 例：int func(int a,string b); function_traits::function_type; //获取函数类型 int _cdecl(int, string) function_traits::return_type; //int function_traits::arity; //2 function_traits::arg_t
function 源码分析2--boost function的源码分析
10-27 1273
分析了boost function的源码实现
C++玩转模板之——函数萃取function traits
优快云1292248830的博客
08-21 1759
C++函数萃取function traits，获取可调用类型和成员函数类型的参数值、返回值等各种性质，以及对成员函数类型的限定移除及判别等。
Boost学习笔记之type_traits（一）
记录学习过程
05-10 677
//笔记 实现代码 仅摘取一部分 理解原理 不是完整的boost代码 //1.add_const // 依赖的头文件 // #include <boost/type_traits/add_const.hpp> or #include <boost/type_traits.hpp> // 实现原理 template <class T> struct add_const { typedef T const type; };.
Boost库中的Traits(is_array, is_const)
liqinghua1653的专栏
03-21 1640
Boost中的Traits十分完善，可分为几大类：1. Primary Type Categorisation(初级型别分类) 2. Secondary Type Categorisation(次级型别分类) 3. Type Properties(型别属性) 4. Relationships Between Types(型别间关系) 5. Transformations Bet
error: no matching function for call to ‘regex_match(std::string&, httplib::Match&, const boost::basic_regex<char, boost::regex_traits<char> >&)’ 4580 | x_match(req.path, req.matches, pattern))
最新发布
07-25
具体来说，错误信息中提到了`std::string`和`boost::basic_regex, regex_traits<char>>`（即`boost::regex`）类型。 根据错误信息，我们可以推断用户代码可能类似于： ```cpp std::string str = ...; boost::regex ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值