Lambda表达示学习笔记

最新推荐文章于 2020-09-21 21:27:27 发布
最新推荐文章于 2020-09-21 21:27:27 发布
阅读量1.4k 收藏 1
点赞数
文章标签： lambda functor iostream struct each action
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/feather_huo/article/details/2132099
版权
简介

Lambda表达式是函数式编程的入门，很多高级语言都提供了类似的功能。C＋＋的准标准库Boost提供了Lambda库来解决相关问题，lambda是否成为C＋＋0X的标准库也在讨论中，文章介绍了Boost Lambda库的使用并结合自己的理解对lambda表达式的实现进行了浅析。

Lambda表达式的使用和程序改进

所谓Lambda，就是快速的小函数生成。

何时使用Lambda表达式

在以下情况下可以考虑使用Lambda表达式：

u       将任意的表达式转换为兼容于标准库的函数对象。

u       在调用点提供未命名函数，提高代码可读性和可维护性。

u       在需要的时间和地点实现谓词。

Boost Lambda库的配置

头文件

核心部分

       “boost/lambda/lambda.hpp”

Bing函数，用于仿函数的参数绑定

       “boost/lambda/bind.hpp”

定义逻辑判断的表达式

       “boost/lambda/if.hpp”

“boost/lambda/loops.hpp”

“boost/lambda/switch.hpp”

定义为lambda表达式增加构造和析构函数以及new/delete函数的工具

“boost/lambda/construct.hpp”

定义lambda表达式提供类型转换运算符

“boost/lambda/cast.hpp”

定义lambda表达式提供异常处理的工具

“boost/lambda/exception.hpp”

定义嵌套函数调用的C＋＋标准库算法的lambda版本

“boost/lambda/alogrithm.hpp”

Hello Lambda

下面我们看一个程序员的入门示例：Hello Lambda

 //**************************************************************

#include <iostream>
#include "boost/lambda/lambda.hpp"
#include "boost/function.hpp"
/*
* 本文件是boost lambda库的示例文件
* 文件展示了最简单的lambda表达式的使用
* Compile : window g++
*         g++ -I%BOOST_PATH% Hello_Lambda.cpp -o ./Hello_Lambda.exe
*/
using namespace boost::lambda;

int main()
{
 (std::cout << _1 <<  _3 <<  _2 << "!/n")
  ("Hello" ,"lambda",".");

 boost::function<void(int,int,int)> f
  = std::cout << _1 << "*" << _2  << "+" << _3 << "= ?/n";

 f(1,2,3);

 system("pause"); 
}
 //******************************************************

本示例介绍了Lambda表达式的基本功能和Lambda的基本思想。

在示例中我们看到了和C＋＋常用语法所不同的语法，关键的变化有两点：

1.         就是把任意一句C＋＋表达式做为了函数对象。

2.         在Lambda表达式的使用中，程序用_1 _2 _3做为参数占位符，在Boost的Lambda库中提供了最多3个参数的占位符。并且在一个表达式中占位符可以多次使用。

Lamda_Bind

本示例介绍了Lambda表达式如何绑定到其他函数，类成员函数甚至式类成员数据上。

示例中首先建立了一个名值的Map，然后使用for_each算法输出相关数据。在for_each的处理中使用了Lambda表达式，可以看到在行27使用了_1占位符，实际执行的时候_1被map的迭代器替换，使用bind函数后使Map迭代器的first和second分布输出。

//****************************************************

#include <iostream>
#include <string>
#include <map>
#include "boost/lambda/lambda.hpp"
#include "boost/lambda/bind.hpp"
/*
* 本文件是boost lambda库的示例文件
* 文件展示了lambda 和bind 库结合使用的技术
* Compile : window g++
*         g++ -I%BOOST_PATH% lambda_bind.cpp -o ./lambda_bind.exe
*/
using namespace boost::lambda;

typedef std::map<int,std::string> Type;

int main()
{
 //定义测试用的MAP
 Type key_values;
 key_values[1]          =   "Fish";
 key_values[2]          =   "Bear";

 //A output with wrong
 std::cout << "What wrong with the following expression? /n"; 
 std::for_each(key_values.begin(),key_values.end(),
     std::cout << "key = " << bind(&Type::value_type::first, _1) << ",
      value = " << bind(&Type::value_type::second,_1) << '/n');
 
 std::cout << "...and why does this work as expected?/n"; 
 //A right output
 
 std::for_each(key_values.begin(),key_values.end(),
     std::cout << constant("key = ") << bind(&Type::value_type::first, _1) << ",
      value = " << bind(&Type::value_type::second,_1) << '/n');

 system("pause");
 return 0;
}

本程序的输出结果是：

但是在第一次输出的结果并没有得到我们的预期，而是少输出了”key = ”.而在我们使用了Constant(“key = ”)……后才正常预期输出。原因是使用函数constant后，改函数创建了无参数的函数对象，它仅仅保存了它的参数，然后在调用的时候返回它。这样使整个语句整合为一个Lambda表达式。

Lambda_function_compare

本示例代码展示了使用Lambda表达式带来的代码的可读性和可维护性的优化。

通过上述例子看出使用STL的仿函数的代码维护需要训练有素的专业人员才可以方便的读懂仿函数的用法。

//********************************************************

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
#include "boost/lambda/lambda.hpp"
#include "boost/lambda/bind.hpp"
/*
* 本文件是boost lambda库的示例文件
* 文件展示了使用STL库的仿函数合使用lambda表达式的不同
* Compile : window g++
*         g++ -I%BOOST_PATH% lambda_function_compare.cpp -o ./lambda_function_compare.exe
*/
using namespace boost::lambda;

int main()
{
 //定义测试用的vector
 std::vector<int> vec(3);
 vec[0]         =  12;
 vec[1]         =  10;
 vec[2]         =  8;

 //使用STL 仿函数写法
 std::transform(vec.begin(),vec.end(),vec.begin(),
     std::bind1st(std::plus<int>(),4));
 //输出查看
 std:: for_each(vec.begin(),vec.end(),std::cout << _1 << " " );

 //使用lambda表达示
 std::transform(vec.begin(),vec.end(),vec.begin(),_1 -= 4);
 std:: for_each(vec.begin(),vec.end(), std::cout << _1 << " " );

 system("pause");
 return 0;  
}

Lambda_control

本示例展示了在Lambda表达式中使用控制语句的示例。从本示例可以看出，使用Lambda库提供的关键字模仿了C＋＋的关键字，在表达式中实现了控制语句的功能。

Lambda控制语句包括if switch case for循环等三大类控制语句。本例展示了if的使用。

 //***************************************

#include <functional>
#include <string>
#include "boost/lambda/lambda.hpp"
#include "boost/lambda/bind.hpp"
#include "boost/lambda/if.hpp"
/*
* 本文件是boost lambda库的示例文件
* 文件展示了使用STL库的仿函数合使用lambda表达式的不同
* Compile : window g++
*         g++ -I%BOOST_PATH% lambda_control.cpp -o ./lambda_control.exe
*/
using namespace boost::lambda;

int main()
{
 //定义测试用的vector
 std::vector<std::string> vec;
 vec.push_back("Lambda");
 vec.push_back("expressions");
 vec.push_back("really");
 vec.push_back("rock");

 std:: for_each(vec.begin(),vec.end(), if_then_else(
     bind(&std::string::size,_1) <= 6u,
     std::cout << _1 << '/n',
     std::cout << constant("Skip./n")));

 system("pause");
 return 0;  
}

Lambda表达式的实现分析

下面以一个赋值运算符的的Lambda表达式来说明实现的技术分析。

问题分析一

我们首先要分析以下两个问题：

_1是什么？

_1 = 2是在做什么？

 

首先毫无疑问的是，在等号运算符前面的_1支持运算符。那么_1就是对象。第二这个对象一定是重载了operator =（int）

那么动工的第一步是实现一个能够范型的进行赋值的函数对象类：

其次，实现_1的占位符的功能

这样就完成了一个简单的Lambda表达式的功能。这样的功能在示例中的简单语句中使用没有问题。

见例子：lambda_AssignmentImitate_simple.cpp

 //**********************************

/*
* 本示例实现了支持复制运算符的lambda表达式运算
*    Compile : window g++
*        g++  : g++ -I%BOOST_PATH% lambda_AssignmentImitate_simple.cpp -o ./lambda_AssignmentImitate_simple.exe
*/
#include <iostream>
#include <stdlib.h>
#include <list>
#include <algorithm>

using namespace std;

/*
* Functor，实现复制运算的功能
*/
 template < typename T >
class  assignment
{
 T value;
public :
 assignment( const  T &  v) : value(v) 
 {
 }
 
 template < typename T2 >
 T2 &   operator ()(T2  & rhs)  const   
 { 
  return  rhs  =  value;
 }
} ;

/*
* 处理holder的功能
*/
class  holder
{
public :
 template < typename T >
 assignment < T >   operator = ( const  T &  t)  const
 {
  return  assignment < T > (t);
 }  
} ;

/*
* 使用中的符号
*/
static  holder _1;

/*
*  打印输出
*/
void print(int i)
{
 cout << i << " ";
 cout << endl;
}
 

int main(int argc, char *argv[])
{
 list<int> listT;
 listT.push_back(1);
 listT.push_back(2);

 for_each(listT.begin(), listT.end(), _1 = 3);
 for_each(listT.begin(), listT.end(), print);

 system("PAUSE"); 
 return 0;
}

问题分析二

下面有两个新的问题：

1.      在实际的Lambda表达式中，操作大部分情况下是多次的，比如_1 = 1 ＝3这样的链式操作。

2.      把_1和functor和常量不统一形式存在，在链式操作中需要分别处理，会导致代码的重复，增加代码难度。

下面介绍了解决这两个问题的思路。

首先解决常量问题，加入下面代码：

对于holder重载operator()并增加对常量的处理

同时修改Assignment的处理，为了处理链式问题，在assignment中增加了对等号的处理

这里需要注意的是在assignment的operateor()重载的时候使用了语句

return m_o (t) = r(0);

本例中r的参数是0 是可以正确运行的，原因是联等式处理的都是常数_1 = 1= 2,但是对于_1 = _1 *4这样的时候就会出错。正确的写法是：

return m_o (t) = r(t);

这样的处理的原因是仿函数r可能代表的是相关运算符的仿函数也有可能处理的是常量的仿函数。

完整的代码可以参考lambda_AssignmentImitate_multi.cpp。

问题分析三

到此为止本例已经可以实现连等，但是这时候有个问题是如果按照这样的实现方式，如果要求实现 _1 = _1 *5 我们要在assinment中实现对operator*的重载，假设有10中运算符，那么我们需要实现10×10的函数，这个对编程来说是个巨大的挑战。

这时候我们想起了一个原则：FTSE (The Fundamental Theorem of Software Engineering) : We can solve any problem by introducing an extra level of indirection.

软件工程的基本的理论就是用新增的层次来解决问题.那么我们看如何增加这个对函数运算符进行适配的层次。

假设我们写好个各种运算符的仿函数，我们如何把它添加到制定的类中？在面向对象的最根本的方法就是继承，当然继承是运行期的多态，我们同时利用模板的推演能力加入编译期的多态。

对于指定的functor我们用这样的声明：

然后在picker中增加对所有运算符的转发，这个时候的返回值的处理就相对复杂

但统一的返回值处理了运算的链式，并实现了转发功能，当然这个都是模板函数，参数输入是十分多样的，不同的参数类型会导致函数实作数量的爆炸。好在没有调用的模板函数不会被实作出来。

然后我们在实现operator*的处理。

这时整体处理的思路就很清晰：

1.      functor专心模拟操作符的行为，并实现一个result_1来告诉别人自己的返回类型。

2.      picker专心负责操作符之间的产生关系，由它来联系操作符合functor。

3.      picker<functor>构成了实际参与操作的对象。

 

完整的代码可以参考lambda_AssignmentImitate_all.cpp

    //*******************************************************

/*
* 本示例实现了支持复制运算符的lambda表达式运算
*    Compile : window g++
*         g++ -I%BOOST_PATH% lambda_AssignmentImitate_all.cpp -o ./lambda_AssignmentImitate_all.exe
*     by huoyanwen
*/
#include <iostream>
#include <stdlib.h>
#include <list>
#include <algorithm>

using namespace std;
/*
* 实现萃取功能的metafunction
*/
template < typename T >
struct   ref
{
 typedef T &  reference;
} ;
//用偏特化处理对引用类型的引用萃取，
//因为c++ 不支持T&&
template < typename T >
struct   ref<T &>
{
 typedef T &  reference;
} ;
/*
* 用来屏蔽常数和变量的区别
*/

template < typename Tp >
class  constant_t
{
 const  Tp t;
public :
 template<typename T>
 struct  result_1
 {
  typedef T &  result;
 } ;
 constant_t( const  Tp &  t) : t(t)  {}

 template < typename T >
 const  Tp &   operator ()( const  T &  r)  const
 {
  return  t;
 }
} ;


template < class  Action > class  picker;

template<typename T > 
struct  picker_maker
{
 typedef  picker< constant_t<T> >  result;
} ;
 
template<typename T> 
struct  picker_maker<picker<T>   >
{
 typedef  picker<T>  result;
} ;
/*
* Functor，实现复制运算的功能
*/
template < typename Op, typename Right>
class  assignment
{
 Op m_o;
 Right r;
public :
 template <typename T>
 struct  result_1
 {
  typedef typename  ref<typename Op::result_1<T>::result >::reference result;
 } ;
 
 assignment( const  Op &  l,  const  Right &  r) :m_o(l), r(r)
 {
 } 

 template< typename T > //typename
 typename result_1<T>::result operator()(const T&  t)  const
 {  
  return  m_o(t)  =  r(t);
 } 
};

template < typename Op,typename Right >
class  multiply
{
 Op m_o;
 Right r;
public :
 template <typename T>
 struct  result_1
 {
  typedef  typename Op::result_2<T>::result  result;
 } ;
 
 multiply( const  Op &  l,  const  Right &  r) :m_o(l), r(r)
 {  
 }
 template< typename T > //typename
 typename result_1<T>::result operator()(const T&  t)  const
 {   
  return   m_o(t) *r(t); 
 } 
} ;

template < class  Action >
class  picker :  public  Action
{
public : 
 picker( const  Action &  act) : Action(act) 
 {
 }  

 template < typename Right >
 picker <assignment < Action, typename picker_maker<Right >::result > >   operator = ( const  Right &  rt)  const
 {
  typedef assignment<Action, typename picker_maker<Right >::result > AssigOp;
  
  AssigOp o =  AssigOp(*this , picker_maker<Right >::result(rt));
  
  return  picker<AssigOp >(o);
 }

 template < typename Right >
 picker <multiply< Action, typename picker_maker<Right >::result > >   operator*( const  Right &  rt)  const
 {
  typedef multiply<Action, typename picker_maker<Right >::result > AssigOp;
  
  AssigOp o =  AssigOp(*this , picker_maker<Right >::result(rt));
  
  return  picker<AssigOp >(o);
 }
 
 // all the operator overloaded
} ;

/*
* 处理holder的功能
*/
class  holder
{
public : 
 template<typename T>
 struct  result_1
 {
  typedef T&  result;
 }; 
 template<typename T>
 struct  result_2
 {
  typedef const T  result;
 };
 /*
 * 功能是把const转换为非const
 */
 template<typename T >
 T &   operator()( const  T &  r)  const
 {
  return  (T&)r;
 }
};

/*
* 使用中的符号
*/
typedef picker<holder> Holder_type;
Holder_type _1 = Holder_type(holder() );

/*
*  打印输出
*/
void print(int i)
{
 cout << i << " ";
 cout << endl;
}
 

int main(int argc, char *argv[])
{
 list<int> listT;
 listT.push_back(1);
 listT.push_back(2);

 for_each(listT.begin(), listT.end(),  _1 =  (_1 * 2));
 for_each(listT.begin(), listT.end(), print);

 system("PAUSE"); 
 return 0;
}

 

 
feather_huo
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Lambda表达式笔记
月月鸟的博客
11-03 116
文章目录Lambda表达式笔记 Lambda表达式 Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。 Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。 使用 Lambda 表达式可以使代码变的更加简洁紧凑。 语法 (parameters) -> expression //或 (parameters) ->{ statements; } 特征 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。 可选的参数圆括号：一个参数无需
lambda表达式（学习笔记）
ycyne的博客
06-03 797
lambda表达式使用前提 java当中使用lambda表达式的前提是，必须有“函数式接口” 函数接口概念:有且仅有一个抽象方法的接口。 如何才能检测当前接口是不是函数式接口？ 用一个固定的格式写在public interface之前一行即可 @FunctionalInterface lambda表达式要想使用，一定要有函数式接口的推断环境。 要么通过方法的参数类型来确定是哪个函数式接口。 要么通过赋值操作来确定是哪个函数式接口。 lambda的格式就是为了将抽象方法，翻译成以下三点
Python学习(13)--Lambda表达式和switch语句的实现
遇见离殇的博客
01-10 3620
1.Lambda表达式定义匿名函数          在Python中,Lambda表达式是用来快速定义一个最小函数,这个函数小到什么程度呢,小到只有一行代码,一条语句,在Python中有时候我们为了提高程序的可读性,或者一个功能块小到我们并不需要定义一个函数来实现它的时候就用到了Lambda表达式,那么什么又是Lambda表达式呢?下面我们通过一个代码例子来了解下: def f(x,y)
C++ switch-case语句应用经验讲解
wmnmtm的专栏
11-23 581
在C++编程语言中，存在着一些判断语句，比如if，C++ switch-case语句等等。我们在这篇文章中会针对C++ switch-case语句的基本使用方法进行详细的介绍，希望能给大家带来一些帮助。C++实现WPF动画具体操作方法详解C++中文字符相关应用方法详解C++虚构函数给我们带来哪些好处C++位操作基本含义详解C++ Endian具体操作方法讲解if语句处理两个分支,处理多个分支时需使...
java 多态替代switch表达式+lambda表达式
guohao_Kwok的博客
07-10 4249
精选30+云产品，助力企业轻松上云！>>> 原代码：...
boost中Function和Lambda的使用
weixin_34384915的博客
11-06 163
1 Boost.Function Boost.Function位于 #include <boost/function.hpp> 之中，其提供了类似函数指针的功能。但是这个“函数指针”不但能够指向普通的函数而且还能够指向函数对象或者成员函数。我们可以将其当作对函数指针功能的扩展。下面是它的一个使用示例： #include<iostream> #include...
Beyond the C++ Standard Library: An Introduction to Boost -- Library 10.2 Usage(上)
02-23 1769
用法与其它许多 Boost 库一样，这个库完全定义在头文件中，这意味着你不必构建任何东西就可以开始使用。但是，知道一点关于 lambda 表达式的东西肯定是有帮助的。接下来的章节会带你浏览一下这个库，还包括如何在 lambda 表达式中进行异常处理！这个库非常广泛，前面还有很多强大的东西。一个 lambda 表达式通常也称为匿名函数(unnamed function)。它在需要的时 候进行声明
lambda-notes:Lambda 表达式学习笔记
05-14
Java 8 Lambda表达式学习笔记，摘自书籍 ，笔记内只举了实例，没有进行过多的解释与剖析，可以通过IDE进入Java 8 的相关源码进行查看理解，查看主要知识储备包括： 接口定义 Java 8 default关键字 泛型 匿名内部类 ...
Lambda表达式学习教程
11-06
学习Lambda表达式时，理解如何将代码块转化为函数对象、如何捕获上下文变量（包括局部变量和final变量）以及如何处理异常都是重要的知识点。 标签“表达式”暗示了教程可能涉及Lambda表达式在不同上下文中的用法，...
Python学习笔记之lambda表达式用法详解
12-26
本文实例讲述了Python学习笔记之lambda表达式用法。分享给大家供大家参考，具体如下： Lambda 表达式 使用 Lambda 表达式创建匿名函数，即没有名称的函数。lambda 表达式非常适合快速创建在代码中以后不会用到的函数...
Lambda表达式.md
06-11
Lambda表达式.md。这是个人的学习笔记，有需要自行下载
Boost.Lambda 用法详解（三）
郁闷阳光的专栏
05-15 802
Lambda 表达式中的类型转换 在 lambda 表达式中有四种特殊的"转型操作符"[7] 来进行类型的转换：ll_dynamic_cast, ll_static_cast, ll_reinterpret_cast, 和 ll_const_cast. 这些名字与对应的C++关键字不一样，因为它们不能被重载。要使用这些类型转换，就要包含头文件 "boost/lambda/casts.hpp
Lambda表达式
南宫封清的博客
09-21 343
Lambda表达式语法：[capture ] ( params ) mutable exception attribute -> return-type { body } 其中capture为定义外部变量是否可见(捕获)，若为空，则表示不捕获所有外部变量，即所有外部变量均不可访问，= 表示所有外部变量均以值的形式捕获，在body中访问外部变量时，访问的是外部变量的一个副本，类似函数的值传递，因此在body中对外部变量的修改均不影响外部变量原来的值。& 表示以引用的形式捕获，后面加上需要捕获的
b050闲置图书分享-springboot+vue+elementui.zip（可运行源码+sql文件+文档）
07-23
本次开发的闲置图书分享平台实现了收货地址管理、字典管理、公告管理、留言板管理、图书管理、图书收藏管理、图书评价管理、图书订单管理、用户管理、管理员管理等功能。系统用到了关系型数据库中王者MySql作为系统的数据库，有效的对数据进行安全的存储，有效的备份，对数据可靠性方面得到了保证。并且程序也具备程序需求的所有功能，使得操作性还是安全性都大大提高，让闲置图书分享平台更能从理念走到现实，确确实实的让人们提升信息处理效率。 管理图书的数据，此页面主要实现图书的增加、修改、删除、查看的功能。公告信息管理页面提供的功能操作有：新增公告，修改公告，删除公告操作。公告类型管理页面显示所有公告类型，在此页面既可以让管理员添加新的公告信息类型，也能对已有的公告类型信息执行编辑更新，失效的公告类型信息也能让管理员快速删除。
《大学生职业生涯规划与就业指导》大一阶段课程作业
最新发布
07-24
《大学生职业生涯规划与就业指导》大一阶段课程作业
开题报告潮汕特产直销系统 已通过开题答辩的.doc
07-23
随着互联网的高速发展，人们的生活方式发生了翻天覆地的变化，在过去，人们想要购买很远地方的东西会非常麻烦，因为是通信和交通都不是十分的方便，而现在网络购物成为了人们日常生活中不可或缺的一部分。在这样的背景下，互联网与传统行业的融合已经成为了一种不可阻挡的趋势。对于中国特色的潮汕特产来说，这一趋势也带来了巨大的变革和发展机遇[1]。
Python性能优化：掌握性能分析工具的实战指南
07-23
Python是一种广泛使用的高级编程语言，由Guido van Rossum于1989年底发明，第一个公开发行版发行于1991年。Python的设计哲学强调代码的可读性和简洁的语法（尤其是使用空格缩进来区分代码块，而不是使用大括号或关键词）。这使得Python被认为是一种易于学习的语言，同时具备强大的功能，适合初学者和经验丰富的程序员。 Python的主要特点包括： 1. **易于学习**：Python有相对较少的关键字，结构简单，和一个明确定义的语法。 2. **易于阅读**：Python代码定义的清晰度使得它像可执行伪代码。 3. **易于维护**：Python的成功在于它的源代码是相当容易维护的。 4. **广泛的标准库**：Python的标凑库很庞大，包含用于互联网通信、网络通信、数据压缩、加密、系统管理等的模块。 5. **跨平台**：Python可以在多种操作系统上运行，包括但不限于Windows、Mac OS X、Linux等。 6. **解释型语言**：Python是一种解释型语言，这意味着开发过程中没有编译步骤。 7. **动态类型系统**：Python不会在编写
Android学习系列之gradle实战
07-23
Android学习系列之gradle实战
Java 8 Lambda表达式与函数式接口学习笔记
"这份996视频学习笔记主要关注Java 8的新特性，包括lambda表达式、Stream API、Try-with-resource、Guava库的使用、线程池的管理和Lombok工具的介绍，以及验证框架的基本概念。" 在Java 8中，引入了lambda表达式，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值