tinyxml2源码分析-4

最新推荐文章于 2023-05-12 16:09:43 发布
最新推荐文章于 2023-05-12 16:09:43 发布
阅读量758 收藏 1
点赞数 1
分类专栏： tinyxml2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qiukongjian/article/details/52693814
版权

接下来分析写文件，这个简单，使用visitor设计模式来实现，visitor接口如下，注意Element的visit接口，传入了XMLAttribute指针 来遍历Attribute

class XMLVisitor
{
public:
    virtual ~XMLVisitor() {}

    /// Visit a document.
    virtual bool VisitEnter( const XMLDocument& /*doc*/ )			{
        return true;
    }
    /// Visit a document.
    virtual bool VisitExit( const XMLDocument& /*doc*/ )			{
        return true;
    }

    /// Visit an element.
    virtual bool VisitEnter( const XMLElement& /*element*/, const XMLAttribute* /*firstAttribute*/ )	{
        return true;
    }
    /// Visit an element.
    virtual bool VisitExit( const XMLElement& /*element*/ )			{
        return true;
    }

    /// Visit a declaration.
    virtual bool Visit( const XMLDeclaration& /*declaration*/ )		{
        return true;
    }
    /// Visit a text node.
    virtual bool Visit( const XMLText& /*text*/ )					{
        return true;
    }
    /// Visit a comment node.
    virtual bool Visit( const XMLComment& /*comment*/ )				{
        return true;
    }
    /// Visit an unknown node.
    virtual bool Visit( const XMLUnknown& /*unknown*/ )				{
        return true;
    }
};
然后给XMLNode增加接口， 

 virtual bool Accept( XMLVisitor* visitor ) const = 0;
子类实现： 

bool XMLText::Accept( XMLVisitor* visitor ) const
{
    TIXMLASSERT( visitor );
    return visitor->Visit( *this );
}

bool XMLComment::Accept( XMLVisitor* visitor ) const
{
    TIXMLASSERT( visitor );
    return visitor->Visit( *this );
}
bool XMLDeclaration::Accept( XMLVisitor* visitor ) const
{
    TIXMLASSERT( visitor );
    return visitor->Visit( *this );
}
bool XMLUnknown::Accept( XMLVisitor* visitor ) const
{
    TIXMLASSERT( visitor );
    return visitor->Visit( *this );
}
bool XMLElement::Accept( XMLVisitor* visitor ) const
{
    TIXMLASSERT( visitor );
    if ( visitor->VisitEnter( *this, _rootAttribute ) ) {
        for ( const XMLNode* node=FirstChild(); node; node=node->NextSibling() ) {
            if ( !node->Accept( visitor ) ) {
                break;
            }
        }
    }
    return visitor->VisitExit( *this );
}
bool XMLDocument::Accept( XMLVisitor* visitor ) const
{
    TIXMLASSERT( visitor );
    if ( visitor->VisitEnter( *this ) ) {
        for ( const XMLNode* node=FirstChild(); node; node=node->NextSibling() ) {
            if ( !node->Accept( visitor ) ) {
                break;
            }
        }
    }
    return visitor->VisitExit( *this );
}

为了输出一份漂亮的xml，我们需要保存int _depth;来决定使用多少个空格来对齐。

visitor适合类型结构固定的情况，接下来就是实现Visitor模式，使用c语言变参函数完成prit函数，在windows平台，首先使用_vscprintf获取format后字符长度，缓冲区增加，使用vsnprintf_s将结果输出到buffer中，_buffer是DynArray< char, 20 >类型，暂时可以理解为std::vector<char>，

void XMLPrinter::Print( const char* format, ... )
{
    va_list     va;
    va_start( va, format );

    if ( _fp ) {
        vfprintf( _fp, format, va );
    }
    else {
        const int len = TIXML_VSCPRINTF( format, va );
        // Close out and re-start the va-args
        va_end( va );
        TIXMLASSERT( len >= 0 );
        va_start( va, format );
        TIXMLASSERT( _buffer.Size() > 0 && _buffer[_buffer.Size() - 1] == 0 );
        char* p = _buffer.PushArr( len ) - 1;	// back up over the null terminator.
		TIXML_VSNPRINTF( p, len+1, format, va );
    }
    va_end( va );
}
有了Printf函数,我们就可以方便的打印文档，先看Text,_textDepth正常情况下是-1,只有输出Text时，才置为_depth-1; 

void XMLPrinter::PushText( const char* text, bool cdata )
{
    _textDepth = _depth-1;

    SealElementIfJustOpened();
    if ( cdata ) {
        Print( "<![CDATA[%s]]>", text );
    }
    else {
        PrintString( text, true );
    }
}
首先确定Element关闭了： 

void XMLPrinter::SealElementIfJustOpened()
{
    if ( !_elementJustOpened ) {
        return;
    }
    _elementJustOpened = false;
    Print( ">" );
}
至于PrintString，则是为了打印转义字符: 

void XMLPrinter::PrintString( const char* p, bool restricted )
{
    // Look for runs of bytes between entities to print.
    const char* q = p;

    if ( _processEntities ) {
        const bool* flag = restricted ? _restrictedEntityFlag : _entityFlag;
        while ( *q ) {
            TIXMLASSERT( p <= q );
            // Remember, char is sometimes signed. (How many times has that bitten me?)
            if ( *q > 0 && *q < ENTITY_RANGE ) {
                // Check for entities. If one is found, flush
                // the stream up until the entity, write the
                // entity, and keep looking.
                if ( flag[(unsigned char)(*q)] ) {
                    while ( p < q ) {
                        const size_t delta = q - p;
                        // %.*s accepts type int as "precision"
                        const int toPrint = ( INT_MAX < delta ) ? INT_MAX : (int)delta;
                        Print( "%.*s", toPrint, p );//特殊用法，toPrint制定字符串的宽度
                        p += toPrint;
                    }
                    bool entityPatternPrinted = false;
                    for( int i=0; i<NUM_ENTITIES; ++i ) {//找到相应的转义字符，输出
                        if ( entities[i].value == *q ) {
                            Print( "&%s;", entities[i].pattern );
                            entityPatternPrinted = true;
                            break;
                        }
                    }
                    if ( !entityPatternPrinted ) {
                        // TIXMLASSERT( entityPatternPrinted ) causes gcc -Wunused-but-set-variable in release
                        TIXMLASSERT( false );
                    }
                    ++p;
                }
            }
            ++q;
            TIXMLASSERT( p <= q );
        }
    }
    // Flush the remaining string. This will be the entire
    // string if an entity wasn't found.
    TIXMLASSERT( p <= q );
    if ( !_processEntities || ( p < q ) ) {
        Print( "%s", p );
    }
}
XMLDeclaration,需要文件BOM头就输出， 
void XMLPrinter::PushHeader( bool writeBOM, bool writeDec )
{
    if ( writeBOM ) {
        static const unsigned char bom[] = { TIXML_UTF_LEAD_0, TIXML_UTF_LEAD_1, TIXML_UTF_LEAD_2, 0 };
        Print( "%s", bom );
    }
    if ( writeDec ) {
        PushDeclaration( "xml version=\"1.0\"" );
    }
}

PushDeclaration：

void XMLPrinter::PushDeclaration( const char* value )
{
    SealElementIfJustOpened();
    if ( _textDepth < 0 && !_firstElement && !_compactMode) {
        Print( "\n" );
        PrintSpace( _depth );
    }
    _firstElement = false;
    Print( "<?%s?>", value );
}

XMLAttribute:

void XMLPrinter::PushAttribute( const char* name, const char* value )
{
    TIXMLASSERT( _elementJustOpened );
    Print( " %s=\"", name );
    PrintString( value, false );
    Print( "\"" );
}

XMLComment:

void XMLPrinter::PushComment( const char* comment )
{
    SealElementIfJustOpened();
    if ( _textDepth < 0 && !_firstElement && !_compactMode) {
        Print( "\n" );
        PrintSpace( _depth );
    }
    _firstElement = false;
    Print( "<!--%s-->", comment );
}
Declaration: 

void XMLPrinter::PushDeclaration( const char* value )
{
    SealElementIfJustOpened();
    if ( _textDepth < 0 && !_firstElement && !_compactMode) {
        Print( "\n" );
        PrintSpace( _depth );
    }
    _firstElement = false;
    Print( "<?%s?>", value );
}
XMLUnknown 
void XMLPrinter::PushUnknown( const char* value )
{
    SealElementIfJustOpened();
    if ( _textDepth < 0 && !_firstElement && !_compactMode) {
        Print( "\n" );
        PrintSpace( _depth );
    }
    _firstElement = false;
    Print( "<!%s>", value );
}
EnterElement: 

void XMLPrinter::OpenElement( const char* name, bool compactMode )
{
    SealElementIfJustOpened();
    _stack.Push( name );

    if ( _textDepth < 0 && !_firstElement && !compactMode ) {
        Print( "\n" );
    }
    if ( !compactMode ) {
        PrintSpace( _depth );
    }

    Print( "<%s", name );
    _elementJustOpened = true;
    _firstElement = false;
    ++_depth;
}
Exit Element: 

void XMLPrinter::CloseElement( bool compactMode )
{
    --_depth;
    const char* name = _stack.Pop();

    if ( _elementJustOpened ) {
        Print( "/>" );
    }
    else {
        if ( _textDepth < 0 && !compactMode) {
            Print( "\n" );
            PrintSpace( _depth );
        }
        Print( "</%s>", name );
    }

    if ( _textDepth == _depth ) {
        _textDepth = -1;
    }
    if ( _depth == 0 && !compactMode) {
        Print( "\n" );
    }
    _elementJustOpened = false;
}

这样visitor模式基本代码都编码完毕：

bool XMLPrinter::VisitEnter( const XMLDocument& doc )
{
    _processEntities = doc.ProcessEntities();
    if ( doc.HasBOM() ) {
        PushHeader( true, false );
    }
    return true;
}


bool XMLPrinter::VisitEnter( const XMLElement& element, const XMLAttribute* attribute )
{
    const XMLElement* parentElem = 0;
    if ( element.Parent() ) {
        parentElem = element.Parent()->ToElement();
    }
    const bool compactMode = parentElem ? CompactMode( *parentElem ) : _compactMode;
    OpenElement( element.Name(), compactMode );
    while ( attribute ) {
        PushAttribute( attribute->Name(), attribute->Value() );
        attribute = attribute->Next();
    }
    return true;
}


bool XMLPrinter::VisitExit( const XMLElement& element )
{
    CloseElement( CompactMode(element) );
    return true;
}


bool XMLPrinter::Visit( const XMLText& text )
{
    PushText( text.Value(), text.CData() );
    return true;
}


bool XMLPrinter::Visit( const XMLComment& comment )
{
    PushComment( comment.Value() );
    return true;
}

bool XMLPrinter::Visit( const XMLDeclaration& declaration )
{
    PushDeclaration( declaration.Value() );
    return true;
}


bool XMLPrinter::Visit( const XMLUnknown& unknown )
{
    PushUnknown( unknown.Value() );
    return true;
}
给XMLDocument增加函数SaveFile 

XMLError XMLDocument::SaveFile( FILE* fp, bool compact )
{
    // Clear any error from the last save, otherwise it will get reported
    // for *this* call.
	SetError(XML_SUCCESS, 0, 0);
    XMLPrinter stream( fp, compact );
    Print( &stream );
    return _errorID;
}XMLError XMLDocument::SaveFile( const char* filename, bool compact )
{
    FILE* fp = callfopen( filename, "w" );
    if ( !fp ) {
        SetError( XML_ERROR_FILE_COULD_NOT_BE_OPENED, filename, 0 );
        return _errorID;
    }
    SaveFile(fp, compact);
    fclose( fp );
    return _errorID;
}
至此，xml存储也分析完毕。

接下来对内存池和DynArray分析，首先DynArray和vector的代码差不多，如果分配的内存到头，则将需求的内存*2作为新的内存，复制，并将原来的内存释放。

template <class T, int INITIAL_SIZE>
class DynArray
{
public:
    DynArray() {
        _mem = _pool;//将指针指向预先分配的内存
        _allocated = INITIAL_SIZE;
        _size = 0;
    }

    ~DynArray() {
        if ( _mem != _pool ) {
            delete [] _mem;
        }
    }

    void Clear() {
        _size = 0;
    }

    void Push( T t ) {
        TIXMLASSERT( _size < INT_MAX );
        EnsureCapacity( _size+1 );
        _mem[_size++] = t;
    }
<span style="white-space:pre">	</span>//push Array，多分配count个内存，并将内存地址返回
    T* PushArr( int count ) {
        TIXMLASSERT( count >= 0 );
        TIXMLASSERT( _size <= INT_MAX - count );
        EnsureCapacity( _size+count );
        T* ret = &_mem[_size];
        _size += count;
        return ret;
    }

    T Pop() {
        TIXMLASSERT( _size > 0 );
        return _mem[--_size];
    }

    void PopArr( int count ) {
        TIXMLASSERT( _size >= count );
        _size -= count;
    }

    bool Empty() const					{
        return _size == 0;
    }

    T& operator[](int i)				{
        TIXMLASSERT( i>= 0 && i < _size );
        return _mem[i];
    }

    const T& operator[](int i) const	{
        TIXMLASSERT( i>= 0 && i < _size );
        return _mem[i];
    }

    const T& PeekTop() const            {
        TIXMLASSERT( _size > 0 );
        return _mem[ _size - 1];
    }

    int Size() const					{
        TIXMLASSERT( _size >= 0 );
        return _size;
    }

    int Capacity() const				{
        TIXMLASSERT( _allocated >= INITIAL_SIZE );
        return _allocated;
    }

    const T* Mem() const				{
        TIXMLASSERT( _mem );
        return _mem;
    }

    T* Mem()							{
        TIXMLASSERT( _mem );
        return _mem;
    }

private:
    DynArray( const DynArray& ); // not supported
    void operator=( const DynArray& ); // not supported
 
    void EnsureCapacity( int cap ) {
        TIXMLASSERT( cap > 0 );
        if ( cap > _allocated ) {//如果大于容量
            TIXMLASSERT( cap <= INT_MAX / 2 );
            int newAllocated = cap * 2;//(⊙o⊙)…内存池常用分配办法
            T* newMem = new T[newAllocated];
            memcpy( newMem, _mem, sizeof(T)*_size );	// 只能是POD类型
            if ( _mem != _pool ) {
                delete [] _mem;
            }
            _mem = newMem;
            _allocated = newAllocated;
        }
    }

    T*  _mem;//指向内存的指针
    T   _pool[INITIAL_SIZE];//预先分配的内存
    int _allocated;		// capacity
    int _size;	// 当前使用个数
};

MemPoolT，如果内存分配了，只有等析构才能回收所有的内存，对于一般应用而言，对的

template< int ITEM_SIZE >
class MemPoolT : public MemPool
{
public:
    MemPoolT() : _root(0), _currentAllocs(0), _nAllocs(0), _maxAllocs(0), _nUntracked(0)	{}
    ~MemPoolT() {
        Clear();
    }
    
    void Clear() {
        // Delete the blocks.
        while( !_blockPtrs.Empty()) {
            Block* b  = _blockPtrs.Pop();
            delete b;
        }
        _root = 0;
        _currentAllocs = 0;
        _nAllocs = 0;
        _maxAllocs = 0;
        _nUntracked = 0;
    }

    virtual int ItemSize() const	{
        return ITEM_SIZE;
    }
    int CurrentAllocs() const		{
        return _currentAllocs;
    }

    virtual void* Alloc() {
        if ( !_root ) {//如果链表首元素为空
            // Need a new block.
            Block* block = new Block();
            _blockPtrs.Push( block );

            Item* blockItems = block->items;
            for( int i = 0; i < ITEMS_PER_BLOCK - 1; ++i ) {
                blockItems[i].next = &(blockItems[i + 1]);
            }
            blockItems[ITEMS_PER_BLOCK - 1].next = 0;
            _root = blockItems;
        }
        Item* const result = _root;
        TIXMLASSERT( result != 0 );
        _root = _root->next;

        ++_currentAllocs;
        if ( _currentAllocs > _maxAllocs ) {
            _maxAllocs = _currentAllocs;
        }
        ++_nAllocs;
        ++_nUntracked;
        return result;
    }
    
    virtual void Free( void* mem ) {
        if ( !mem ) {
            return;
        }
        --_currentAllocs;
        Item* item = static_cast<Item*>( mem );
#ifdef DEBUG
        memset( item, 0xfe, sizeof( *item ) );
#endif
        item->next = _root;
        _root = item;
    }
    void Trace( const char* name ) {
        printf( "Mempool %s watermark=%d [%dk] current=%d size=%d nAlloc=%d blocks=%d\n",
                name, _maxAllocs, _maxAllocs * ITEM_SIZE / 1024, _currentAllocs,
                ITEM_SIZE, _nAllocs, _blockPtrs.Size() );
    }

    void SetTracked() {
        --_nUntracked;
    }

    int Untracked() const {
        return _nUntracked;
    }

	// This number is perf sensitive. 4k seems like a good tradeoff on my machine.
	// The test file is large, 170k.
	// Release:		VS2010 gcc(no opt)
	//		1k:		4000
	//		2k:		4000
	//		4k:		3900	21000
	//		16k:	5200
	//		32k:	4300
	//		64k:	4000	21000
    // Declared public because some compilers do not accept to use ITEMS_PER_BLOCK
    // in private part if ITEMS_PER_BLOCK is private
    enum { ITEMS_PER_BLOCK = (4 * 1024) / ITEM_SIZE };//内存页在x86下为4K，这样个数的Item正好够一个物理页

private:
    MemPoolT( const MemPoolT& ); // not supported
    void operator=( const MemPoolT& ); // not supported
    //注意为单向列表，union是为了节约内存
    union Item {
        Item*   next;
        char    itemData[ITEM_SIZE];
    };
    struct Block {
        Item items[ITEMS_PER_BLOCK];
    };
    DynArray< Block*, 10 > _blockPtrs;//相当于管理页的指针，内存是一页一页的添加。提前分配10个页面
    Item* _root;//单向链表首元素

    int _currentAllocs;
    int _nAllocs;
    int _maxAllocs;
    int _nUntracked;
};







走调的鱼
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
tinyxml2 源码分析（二）
ml143的专栏
03-28 735
tinyxml源码分析（二）主要分析XMLPrinter的实现和内存管理。
tinyxml2实际运用的一类场景
寒芒的博客
05-20 501
在某些情况下我们接口无法满足或者很难满足我们的一些需求，特别是有时候跨语言性的交互对复杂对象的传递 我们在玩手机游戏的时候，有时候在新手指导里面我们经常看到这样一个句子 小伙伴们经过装备强化可以变得更加厉害哟 当需要突出高亮 “装备强化”四个字   而且这种突出性的文字你不知道是具体哪一段或者一句话中有多少这样的高亮文字 比如：   攻打试练塔可以更多的得到水晶，来购买紫色
推荐一个优秀的c++源代码，TinyXml2
weixin_30491641的博客
05-26 570
项目主页：http://grinninglizard.com/tinyxml2docs/index.html tinyxml2.h /* Original code by Lee Thomason (www.grinninglizard.com) This software is provided 'as-is', without any express...
TinyXML2源代码及工程
12-22
TinyXML2源代码及工程，读写轻便有效率，接口易使用
C++ —— Tinyxml2在Vs2017下相关使用1（附源码）
wx微信公众号“码农总动员”，获取更多编程知识
05-12 341
TinyXML2是一个简单，小巧，高效，C++XML解析器，可以很容易地集成到其他程序中。TinyXML-2解析一个XML文档，并从中构建一个 可以读取、修改和保存的文档对象模型 （DOM）。XML代表“可扩展标记语言”。这是一个通用目的 用于描述任意数据的人类和机器可读标记语言。为存储应用程序数据而创建的所有随机文件格式都可以 全部替换为 XML。一个解析器可以解决所有问题。
tinyxml2源码及示例
10-13
TinyXML2是一个轻量级的XML解析库，主要由C++编写，旨在提供简单、高效的方式来读取和写入XML文档。它适用于各种平台，包括桌面系统和移动系统，如Android。这个库的设计目标是小巧且易于理解，使得开发者能够快速地...
tinyXml2源码
09-21
TinyXML2是一个小型、快速且易于使用的C++库，用于解析和操作XML文档。这个库的设计目标是简单、小巧，适合嵌入式系统或者任何需要轻量级XML处理的项目。 TinyXML2相较于其前身TinyXML，进行了许多优化，减少了内存...
yolov4-tiny火焰检测源码
09-14
《YOLOv4-tiny火焰检测源码解析与应用》 YOLO（You Only Look Once）是一种基于深度学习的目标检测框架，因其实时性高、准确率优秀而广受青睐。YOLOv4-tiny是YOLO系列的一个轻量级版本，优化了计算效率，适合在资源...
Tinyxml解析源码
08-18
TinyXML的源码分析可以从以下几个方面入手： 1. **解析流程**：TinyXML通过`TiXmlDocument`类作为入口，加载XML文件。它首先读取文件内容，然后通过`TiXmlElement`类解析XML元素，`TiXmlAttribute`处理属性，`...
tinyxml解析工具修复内存泄漏
05-06
这个tinyxml是在部门产品应用过程中发现存在内存泄漏的问题，通过代码分析，解决了在xml使用结束时，内存清理不彻底而导致的内存泄漏问题。电驴源码中使用的tinyxml也存在这个问题。不知最新版有没有修复。
tinyxml2+示例代码+介绍文档
09-26
资源包含2015.9.23从官网下载的tinyxml2的源码和自己编写的示例代码还有介绍文档，容易上手。官网的示例代码和文档晦涩难懂，才自己整理。
tinyxml2最新版本（来自github）
08-17
tinyxml2最新版本__20170817 （来自github）
tinyxml2源码分析-1
09-25 1129
换一种方式来对源码分析，从零开始“写”一个tinyxml2。提前郑重声明，本博客所有大tinyxml代码都直接copy自tinyxml源码。 在开始分析源码前，如下图所示，是tinyxml2的各个主要类型，XMLAttribute其实是一个单向链表，放在后面实现。 tinyxml2把xml文档建立成一棵DOM树，具体实现用的是firstchild–nextsiblingtree，如
C++ 本地使用tinyxml2解析Xml文件
给大佬递杯卡布奇诺的博客
09-24 2324
c++ 移植tinyxml操作xml
c/c++操作xml库-Tinyxml2入门及高级用法
Blueeyedboy521的博客
05-07 4808
一、概念 TinyXML2是一个开源、简单、小巧、高效的C++ XML解析器，它只有一个.h文件和一个.cpp文件组成，可以轻松集成到其它程序中。它解析XML文档并从中构建可以读取、修改和保存的文档对象模型(Document Object Model, DOM)。它不能解析DTD(Document Type Definitions, 文档类型定义)或XSL(eXtensible Stylesheet Language, 扩展样式表语言)。在TinyXML2中，XML数据被解析为可以浏览和操作的C++对象，然
tinyxml2/tinyxml2(可以用来读xml等)
sssssNian的专栏
05-23 1940
#ifndef TINYXML2_INCLUDED #define TINYXML2_INCLUDED #include "platform/CCPlatformConfig.h" #include "platform/CCPlatformMacros.h" #if defined(ANDROID_NDK) || defined(__BORLANDC
TinyXML2 入门教程
热门推荐
Dablelv 的博客专栏。
09-26 3万+
TinyXML2是simple、small、efficient开源的C++ XML文件解析库，可以很方便的应用到现有的项目之中。非常适合存储简单数据，配置文件，对象序列化等数据量不是很大的操作。TinyXML2详细介绍与源码获取方法详见：TinyXML2官网。
tinyxml2源码分析-2
09-25 1111
我们实现了XMLNode，接下来我们实现XMLText class XMLText : public XMLNode { friend class XMLDocument; public: virtual XMLText* ToText(){ return this; } virtual const XMLText* ToText() const{ return this;
tinyxml2源码分析-3
09-26 991
有了所有的子节点，可以开始编写LoadFile的代码了,XMLError是个枚举类型，一般而言，先定义一个枚举，同时定义XML_SUCCESS=0，因为成功不需要理由，失败者总是需要借口。等到编码到后期再添加错误码。 XMLError XMLDocument::LoadFile( const char* filename ) { Clear(); FILE* fp = cal
tinyxml2 源码分析
最新发布
06-03
下面是对 tinyxml2 源码的一些分析： 1. 文件结构 tinyxml2 的源码包括以下文件： - tinyxml2.h：包含 tinyxml2 的 API。 - tinyxml2.cpp：包含 tinyxml2 的实现代码。 - xmltest.cpp：包含 tinyxml2 的测试代码...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值