不改原始类结构，不改变原始函数调用，加上有引用计数的智能指针

最新推荐文章于 2020-03-20 16:14:16 发布
最新推荐文章于 2020-03-20 16:14:16 发布
阅读量729 收藏
点赞数
分类专栏： 基础知识 文章标签： 类 智能指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/flyback/article/details/9014497
版权

如果在设计之初没有考虑使用智能指针，有可能在程序所有的地方都是直接使用类的裸指针，在后来再使用智能指针就有可能引入别的问题，大库和函数语义的改变，这样会导致不可知的错误，所以这里尝试提供一个不改变原始类结构的智能指针。


假定现在有类CTestClass, 原来的使用方法是CTestClass * pTClass = new CTestClass(xxxx);

在函数调用中使用CTestClass的指针, 如: HRESULT Process(CTestClass * pClass);


这时我们要在整个设计中使用智能指针，在短平快的指导思想下，不如自己设计一个，一方面可以学习智能指针的思想理论，令一方面还可以直接结合实际，让理论为自己产生价值。


当然，学习首先是拿来,

        在使用了ComPtr之后，发现，虽然ComPtr虽然好用，但是它需要操作的类是继承自IUnknown的，而且每一个这样的类都需要实现IUnknown的3个方法，即使在你不需要QueryInterface的时候也是如此。

       转而使用Chrome开源代码中的 scoped_refptr,这个自然也是需要操作的类继承自RefCounted, 而且还要把Chrome代码中的base拿来用。

    Boost库就不能考虑了。


那么,什么才是合适的设计呢, 如下定义:

1. 短小精干

2. 不改变或尽量少改变已有的接口, 实现中也只能做相对少的修改


在原来的设计中, 大量的使用了如下操作

	1. CTestClass * pClass = new CTestClass(....);
	2. returntype Procedure(..., pClass, ...)
	3. CTestClass * ReturnProcedure(...)
	4. pClass2 = pClass
	5. pClass->xxxxx()


统计一下比较多的操作是

	1. CTestClass * ReturnProcedure(...)
	2. pClass2 = pClass;
	3. pClass->xxxxx();

所以先设计满足条件的测试程序

首先是测试的类

class CTestClass
{
public:
	CTestClass(){ATLTRACE(_T(__FUNCTION__) _T("\n"));}
	virtual ~CTestClass(){ATLTRACE(_T(__FUNCTION__) _T("\n"));}
	void Do(LPCTSTR lpszText){ATLTRACE(_T(__FUNCTION__) _T(" %s\n"), lpszText);}

};

class CTestClass2
{
	int m_nSize;
public:
	CTestClass2(int nSize):m_nSize(nSize){ATLTRACE(_T(__FUNCTION__) _T("\n"));}
	virtual ~CTestClass2(){ATLTRACE(_T(__FUNCTION__) _T(" %d\n"), m_nSize);}
	void Do(LPCTSTR lpszText){ATLTRACE(_T(__FUNCTION__) _T(" %s\n"), lpszText);}

};

然后是测试程序 

	CAutoSmartPtr<CTestClass> aspTest;

 	CTestClass * pClass = aspTest;

 	pClass->Do(_T("class test"));
 	CAutoSmartPtr<CTestClass> aspTest2 = aspTest;

 	aspTest2->Do(_T("aspTest2->Do"));

	struct foo
	{
		static void run(CTestClass * ptc, void ** pp)
		{
 			CAutoSmartPtr<CTestClass> ssptc(ptc);
 			ssptc->Do(_T("run"));
 			CAutoSmartPtr<CTestClass2> ss2(1000);
 			ss2.CopyTo(pp);
		}
	};

	CAutoSmartPtr<CTestClass2> asp2;
	foo::run(aspTest2, &asp2);

	CAutoSmartPtr<CTestClass2> aspTest3(300);
	aspTest3->Do(_T("aspTest3->Do"));


因为CTestClass * ReturnProcedure(....) 并不能确定是一个引用类指针的操作(如ReturnProcedure()->xxxx())还是一个把该引用赋值给一个指针，所以，在修改的时候需要观察原程序确定的意义。

智能指针设计如下

template<typename T>
class CAutoSmartPtr
{
	class TFollowClass:public T
	{
	private:
		long m_ref;		
	public:		
		void addref(){m_ref++;}
		void releaseref()
		{
			if(!((--m_ref) > 0)) delete this;
		}

		TFollowClass():m_ref(0){}		
		virtual ~TFollowClass(){}

		template<typename A1>
		TFollowClass(A1 a1):m_ref(0),T((A1)a1){}

		template<typename A1,typename A2>
		TFollowClass(A1 a1, A2 a2):m_ref(0),T((A1)a1,(A2)a2){}

		template<typename A1,typename A2, typename A3>
		TFollowClass(A1 a1, A2 a2, A3 a3):m_ref(0),T((A1)a1,(A2)a2,(A3)a3){}

		template<typename A1,typename A2, typename A3, typename A4>
		TFollowClass(A1 a1, A2 a2, A3 a3):m_ref(0),T((A1)a1,(A2)a2,(A3)a3, (A4)a4){}

		template<typename A1,typename A2, typename A3, typename A4, typename A5>
		TFollowClass(A1 a1, A2 a2, A3 a3):m_ref(0),T((A1)a1,(A2)a2,(A3)a3, a4, a5){}
	};
protected:		

	TFollowClass * pshareptr;		
	void ptrrelease()
	{
		if(pshareptr)	pshareptr->releaseref();
	}
	void ptraddref()
	{
		if(pshareptr)	pshareptr->addref();
	}
public:

	CAutoSmartPtr():pshareptr(NULL){}
	~CAutoSmartPtr(){ptrrelease();}
	CAutoSmartPtr(CAutoSmartPtr & src):pshareptr(src.pshareptr){ptraddref();}

	template<typename A1>
	CAutoSmartPtr(A1 a1)	
	{
		pshareptr = new TFollowClass(a1);
		ptraddref();
	}

	template<typename A1, typename A2>
	CAutoSmartPtr(A1 a1, A2 a2):
	pshareptr(NULL)
	{
		pshareptr = new TFollowClass(a1, a2);
		ptraddref();
	}

	template<typename A1, typename A2, typename A3>
	CAutoSmartPtr(A1 a1, A2 a2, A3 a3):
	pshareptr(NULL)
	{
		pshareptr = new TFollowClass(a1, a2, a3);
		ptraddref();
	}

	template<typename A1, typename A2, typename A3, typename A4>
	CAutoSmartPtr(A1 a1, A2 a2, A3 a3, A4 a4 ):
	pshareptr(NULL)
	{
		pshareptr = new TFollowClass(a1, a2, a3, a4);
		ptraddref();
	}

	template<typename A1, typename A2, typename A3, typename A4, typename A5>
	CAutoSmartPtr(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5):
	pshareptr(NULL)
	{
		pshareptr = new TFollowClass(a1, a2, a3, a4, a5);
		ptraddref();
	}

	CAutoSmartPtr & operator = (CAutoSmartPtr & src)
	{
		ptrrelease(); 
		pshareptr = src.pshareptr; 
		ptraddref();
		return *this;
	}
	CAutoSmartPtr & operator = (void *pSrc)
	{		
		ptrrelease(); 
		pshareptr = static_cast<TFollowClass *>(pSrc); 
		if(pshareptr)
			pshareptr->addref();
		return *this;
	}

	CAutoSmartPtr(T * pSrc):pshareptr(static_cast<TFollowClass *>(pSrc))
	{		
		if(pshareptr)
			pshareptr->addref();
	}
	

	void CopyTo(void ** pp)
	{
		*pp = (void*)pshareptr;

		if(pshareptr)
			pshareptr->addref();
	}
	operator bool ()
	{
		return !!pshareptr->p;
	}
	void ** operator &()
	{		
		ptrrelease();
		return (void**)&pshareptr;
	}
	T& operator * (){return *(static_cast<T*>(pshareptr));}
	operator T*(){return static_cast<T*>(pshareptr);}
	T* operator ->(){return static_cast<T*>(pshareptr);}
	bool operator !(){return (pshareptr == NULL);}
	bool operator <(T*pT){return static_cast<T*>(pshareptr) < pT;}
	bool operator >(T*pT){return static_cast<T*>(pshareptr) > pT;}
	bool operator != (T*pT) {return static_cast<T*>(pshareptr) != pT;}
	bool operator == (T*pT) {return static_cast<T*>(pshareptr) == pT;}
	
};

注意，因为这个智能指针在初始化的时候生成的是一个继承自原始类的指针，其实方法和让操作类继承自引用计数是一样的，但是这里的表现形式不同，不需要去修改原始类的代码

  • 在所有使用new CTestClass的地方替换成 CAutoSmartPtr<CTestClass>(....),它有和CTestClass一样的初始化列表
  • 在所有给指针赋值的地方都换成CopyTo
    原来的是
      
    CTestClass * pClass = new CTestClass;
CTestClass * pClass2 = GetPointer();
CTestClass * GetPointer()
{
...
return pClass;
}

    现在是
CAutoSmartPtr<CTestClass> pClass;
CAutoSmartPtr<CTestClass> pClass2;
GetPointer(&pClass2);
CTestClass * GetPointer(void ** ppClass)
{
    CAutoSmartPtr<CTestClass> spClass;
    spClass.CopyTo(ppClass); // 这里的引用计数已经被加1了
    return spClass;
}

    让CAutoSmartPtr接近类的语义的代价就是pClass一开始就是一个CTestClass的实例, 而不像其他的智能指针那样一开始是NULL，必须显示的给他赋值,如:
    xxx::scope_ptr<CTestClass> spClass = new CTestClass,
    所以CAutoSmartPtr的 & 操作会先释放一次原来类的实例

    可以修改一个和其他智能指针一样的语义的实现
    去掉几个的实现
    template<typename A1>
	CAutoSmartPtr(A1 a1)	
	{
		pshareptr = new TFollowClass(a1);
		ptraddref();
	}

    // 加上
static CAutoSmartPtr CreateInstance()  // 无参数的初始化
{
	pshareptr = new TFollowClass(a1);
	ptraddref();
}
// 加上几个
template<typename A1>
static CAutoSmartPtr CreateInstance(A1 a1) // 参数初始化
{
	pshareptr = new TFollowClass(a1);
	ptraddref();
}

    初始化的时候改成

    CAutoSmartPtr<CTestClass> spClass = CAutoSmartPtr<CTestClass>::CreateInstance(); // 没有参数的情况
CAutoSmartPtr<CTestClass> spClass = CAutoSmartPtr<CTestClass>::CreateInstance(3); // 1参数的情况 CTestClass(int x)



    完成的程序
    template<typename T>
class CAutoSmartPtr
{
	class TFollowClass:public T
	{
	private:
		long m_ref;		
	public:		
		void addref(){m_ref++;}
		void releaseref()
		{
			if(!((--m_ref) > 0)) delete this;
		}

		TFollowClass():m_ref(0){}		
		virtual ~TFollowClass(){}

		template<typename A1>
		TFollowClass(A1 a1):m_ref(0),T((A1)a1){}

		template<typename A1,typename A2>
		TFollowClass(A1 a1, A2 a2):m_ref(0),T((A1)a1,(A2)a2){}

		template<typename A1,typename A2, typename A3>
		TFollowClass(A1 a1, A2 a2, A3 a3):m_ref(0),T((A1)a1,(A2)a2,(A3)a3){}

		template<typename A1,typename A2, typename A3, typename A4>
		TFollowClass(A1 a1, A2 a2, A3 a3):m_ref(0),T((A1)a1,(A2)a2,(A3)a3, (A4)a4){}

		template<typename A1,typename A2, typename A3, typename A4, typename A5>
		TFollowClass(A1 a1, A2 a2, A3 a3):m_ref(0),T((A1)a1,(A2)a2,(A3)a3, a4, a5){}
	};
protected:		

	TFollowClass * pshareptr;		
	void ptrrelease()
	{
		if(pshareptr)	pshareptr->releaseref();
	}
	void ptraddref()
	{
		if(pshareptr)	pshareptr->addref();
	}
	
public:
	CAutoSmartPtr():pshareptr(NULL){}
	~CAutoSmartPtr(){ptrrelease();}
	CAutoSmartPtr(CAutoSmartPtr & src):pshareptr(src.pshareptr){ptraddref();}

	// 加上
	static CAutoSmartPtr CreateInstance()  // 无参数的初始化
	{
		return CAutoSmartPtr(new TFollowClass);		
	}
	// 加上几个
	template<typename A1>
	static CAutoSmartPtr CreateInstance(A1 a1) // 参数初始化
	{
		return CAutoSmartPtr(new TFollowClass(a1));		
	}	

	template<typename A1, typename A2>
	static CAutoSmartPtr CreateInstance(A1 a1, A2 a2)
	{
		return CAutoSmartPtr(new TFollowClass(a1, a2));	
	}

	template<typename A1, typename A2, typename A3>
	static CAutoSmartPtr CreateInstance(A1 a1, A2 a2, A3 a3)
	{
		return CAutoSmartPtr(new TFollowClass(a1, a2, a3));	
	}

	template<typename A1, typename A2, typename A3, typename A4>
	static CAutoSmartPtr CreateInstance(A1 a1, A2 a2, A3 a3, A4 a4 )
	{
		return CAutoSmartPtr(new TFollowClass(a1, a2, a3, a4));	
	}

	template<typename A1, typename A2, typename A3, typename A4, typename A5>
	static CAutoSmartPtr CreateInstance(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
	{
		return CAutoSmartPtr(new TFollowClass(a1, a2, a3, a4, a5));	
	}

	CAutoSmartPtr & operator = (CAutoSmartPtr & src)
	{
		ptrrelease(); 
		pshareptr = src.pshareptr; 
		ptraddref();
		return *this;
	}
	CAutoSmartPtr & operator = (void *pSrc)
	{		
		ptrrelease(); 
		pshareptr = static_cast<TFollowClass *>(pSrc); 
		if(pshareptr)
			pshareptr->addref();
		return *this;
	}

	CAutoSmartPtr(T * pSrc):pshareptr(static_cast<TFollowClass *>(pSrc))
	{		
		if(pshareptr)
			pshareptr->addref();
	}
	

	void CopyTo(void ** pp)
	{
		*pp = (void*)pshareptr;

		if(pshareptr)
			pshareptr->addref();
	}
	operator bool ()
	{
		return !!pshareptr->p;
	}
	void ** operator &()
	{		
		return (void**)&pshareptr;
	}
	T& operator * (){return *(static_cast<T*>(pshareptr));}
	operator T*(){return static_cast<T*>(pshareptr);}
	T* operator ->(){return static_cast<T*>(pshareptr);}
	bool operator !(){return (pshareptr == NULL);}
	bool operator <(T*pT){return static_cast<T*>(pshareptr) < pT;}
	bool operator >(T*pT){return static_cast<T*>(pshareptr) > pT;}
	bool operator != (T*pT) {return static_cast<T*>(pshareptr) != pT;}
	bool operator == (T*pT) {return static_cast<T*>(pshareptr) == pT;}
	
};

    测试
    CAutoSmartPtr<CTestClass> aspTest = CAutoSmartPtr<CTestClass>::CreateInstance();

 	CTestClass * pClass = aspTest;
// 
 	pClass->Do(_T("class test"));
 	CAutoSmartPtr<CTestClass> aspTest2 = aspTest;
// 
 	aspTest2->Do(_T("aspTest2->Do"));

	struct foo
	{
		static void run(CTestClass * ptc, void ** pp)
		{
 			CAutoSmartPtr<CTestClass> ssptc(ptc);
 			ssptc->Do(_T("run"));
 			CAutoSmartPtr<CTestClass2> ss2 = CAutoSmartPtr<CTestClass2>::CreateInstance(1000);
 			ss2.CopyTo(pp);
		}
	};

	CAutoSmartPtr<CTestClass2> asp2;
	foo::run(aspTest2, &asp2);
// 
// 	
// 
	CAutoSmartPtr<CTestClass2> aspTest3 = CAutoSmartPtr<CTestClass2>::CreateInstance(300);
	aspTest3->Do(_T("aspTest3->Do"));

	CAutoSmartPtr<CTestClass2> aspTest4 = CAutoSmartPtr<CTestClass2>::CreateInstance(40);

    输出
    CTestClass::CTestClass
CTestClass::Do class test
CTestClass::Do aspTest2->Do
CTestClass::Do run
CTestClass2::CTestClass2
CTestClass2::CTestClass2
CTestClass2::Do aspTest3->Do
CTestClass2::CTestClass2
CTestClass2::~CTestClass2 40
CTestClass2::~CTestClass2 300
CTestClass2::~CTestClass2 1000
CTestClass::~CTestClass



魔芋
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 引用计数技术及智能指针的简单实现
12-22
辅助类将引用计数和原始指针存储在一个单独的类中，而句柄类则包含一个辅助类对象，通过它来间接管理内存。在辅助类的实现中，需要确保在正确的时间增加和减少引用计数，并在引用计数为0时释放内存。此外，为了使...
c++：智能指针shared_ptr
Kobe51920的博客
01-30 303
先前的文章我们讲过了智能指针的概念等一系列问题，下面我们直接来看智能指针 1.带有引用计数的智能指针 （Shared_ptr）同时也是强智能指针 所谓的引用计数，就是有多少个智能指针对象管理这个堆内存。引用计数的作用是做所有对象共享的。 不可以写为普通的成员变量，要写成静态的成员变量 我们用一个引用计数管理器来实现Shared_ptr智能指针： 设计思路： 将引用计数管理器设计...
智能指针之share_ptr源码剖析以及线程安全测试
weixin_30596343的博客
08-10 241
shared_ptr的实现 看了一下stl的源码，shared_ptr的实现是这样的: shared_ptr模板类有一个__shared_count类型的成员，_M_refcount来处理引用计数的问题。__shared_count也是一个模板类，它的内部有一个指针_M_pi。所有引用同一个对象的shared_ptr都共用一个_M_pi指针。 当一个shared_ptr拷贝复制时，...
C++智能指针——share_ptr详解
热门推荐
yj_android_develop的博客
03-30 1万+
前言 std::shared_ptr是在c++11中引入的一种智能指针，其特点是它所指向的资源具有共享性，即多个shared_ptr可以指向同一份资源。在c++中使用shared_ptr需要包含头文件。 共享指针是靠引用计数的方式来实现共享的功能，其中引用计数可以通过智能指针与引用计数详解文章了解。 std::shared_ptr常用函数介绍 std::shared_ptr的初始化有两种方法：...
C++智能指针实现（包含拷贝构造，赋值函数，引用解引用重载）
03-22
智能指针实际上是一个封装了原始指针的对象，它拥有一个内部的引用计数，用于跟踪有多少个智能指针指向同一块内存。当智能指针被销毁或赋值给其他智能指针时，这个引用计数会被相应地增加或减少。当引用计数变为零时...
混用智能指针和引用计数类型的指针示例
12-13
`RefCountedPtr.h`可能包含了一个自定义的引用计数指针类，它可能实现了类似于`std::shared_ptr`的功能，但是使用了不同的引用计数机制。这种自定义的指针类型可能用于特定的场景，比如在不支持C++11的旧项目中实现...
smartptr——基于自动引用计数的智能指针
10-14
智能指针相信大家听说过吧，我理解的智能指针，既是一个C++模板类，重载了指针操作符（->）和（*）操作符，而使它的实例可以"用指针的形式去调用"。 它可以接管任意类型的指针，所以你只需要放心大胆的new出任意对象...
C++中智能指针如何设计和使用
12-26
智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象共享同一指针。每次创建类的新对象时，初始化指针并将引用计数置为1；当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与...
OPC 技术文档之 OPCENUM.EXE 使用方法(vc)
魔芋的专栏
08-17 1万+
在制作OPC Client 的程序的时候,常常需要浏览目标服务器的所有OPC Server方法有两个: 一是通过 IOPCAutoServer 的GetOPCServers方法得到(这个比较简单,这里不讨论)。 二是通过 OPCEnum.exe 提供的 IOPCServerList 接口的 EnumClassesOfCategories 方法实现。俺在搜索 www.google.com 的时候似乎
OPC 技术文档之 IOPCBrowseServerAddressSpace 的使用(vc)
魔芋的专栏
08-20 5216
在制作 OPC Client 的时候通常需要浏览OPC Serve的所有已经定义的item名称（当然OPC Server必须支持这个选项），如果用VC的话就要使用到IOPCBrowseServerAddressSpace接口，那么，下面是提取item目录结构的一个自制的递归函数。void TryBrowseBranch(IOPCBrowseServerAddressSpace *pBSAS, LP
在Swift中的ASCII到字符转换的问题
魔芋的专栏
09-07 4651
我们在C++里处理字符通常是这样的char a = 'A' // A = 65 printf("'%c' = %d", a + 1, a + 1) // 'B' = 66这在号称吸收C/C++所有优势特性的Swift里面是行不通的,因为 Character 和 Int 不能进行计算操作，会报错var c:Character = "A" c + 1 // 这里是错误的Xcode 会告诉你 Binar
论UITableViewController被status bar覆盖的问题(IOS SDK 8.3)
魔芋的专栏
06-17 3198
通常我们做一个UITableViewController(以下简称tvc)直接打开，在没有NavigationController的时候都会是这样 问题是，你要加一个UINavigationController吗？还是像别人一样不用UITableViewControler而是在main storyboard 里面造一个UIViewController + UITableView 下移20px?告诉
Excel(XLSX/XLS)文件内容导入WEB表单,纯前端无需服务器支持,开源Chrome扩展 v0.0.8，附下载，附github链接(2021/5/8更)
魔芋的专栏
03-20 3189
起因 老婆从事的是售后的工作，常年需要把售前工程师和销售的一些实施的数据录入到他们的工作平台上。 最开始我看在眼里，焦虑在心上，我心想，你这完全是人力无价值的搬运工的(excel到网页表单)工作，你们公司难道不能把录入这一部分的工作开放给更前线的人或者提供一个excel导入的工具吗？老婆摇摇头说，这个事已经提了n年了，以她这工作岗位在公司里的重要程度，还不足以让开发工程师紧着她做事，他们还有“更重...
批量修改图形文件的对比度和锐度,python 2.7
魔芋的专栏
02-19 3020
电子书里漫画看不清?你还在用photoshop一页一页的来处理吗?python可以帮你大忙
文石(onyx boox M92)电纸书(linux) 下写绘图板程序Mypainter.oar
魔芋的专栏
01-25 2535
过了n久，才开始玩,资料好难找，不过还是在github里找到了，做了一个绘图板程序,使用着比电纸书自带的好用多了，有换灰度，换笔触宽度的功能，笔触比出厂自带的程序流畅多了，暂时没有保存图片的功能 http://download.csdn.net/detail/flyback/159561 欢迎提意见和建议
WTL的CScrollContainer
魔芋的专栏
04-28 1574
CScrollContainer,CScrollWindowImpl,CScrollImpl你要闹哪样?在带滚动窗口中动态创建控件的实例
ini文件另一种读取办法
魔芋的专栏
05-31 1289
Windows下的ini文件的读取可以使用系统提供的api来实现 GetPrivateProfileString GetPrivateProfileInt ... 实际应用中, 如果不使用一种统一的方法来包装一下会让源代码看起来很乱。 所以,需要设计一个方便，美观，直观的配置文件操作类！ 原则是代码好看，容易维护 需求: 直观的调用形式 实现潜规则 满足
运行时流程图
魔芋的专栏
01-09 1091
最近做了一个运行时流程图抓取工具，自己赞一个，太有用了 然后产生dot语法 用工具生成图片
如何访问html网页中的帧对象
魔芋的专栏
12-17 791
如果用webbrowser的document去获取IFrame这个对象，随后一定会得到accessdenied的错误，为什么？找了一下，据说是不能跨域访问...终于有一天，试了一下，在OnDocumentComplete事件里面返回的dispatch就是iframe的IHTMLWindow2对象，在那里可以操作所有的对象，然后，你想做什么就随你了，不知道如果这个时候保存了这个IHTMLWi
C++智能指针实现与引用计数解析
而当智能指针对象析构或被赋值时，会减少引用计数，如果计数减至0，就会自动调用`delete`来释放对象。 智能指针的实现通常包括以下几个关键组件： 1. **构造函数**：初始化指向动态对象的指针，并设置引用计数为1...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值