C++ 内存管理 基本部分

最新推荐文章于 2024-08-12 16:55:46 发布
最新推荐文章于 2024-08-12 16:55:46 发布
阅读量575 收藏
点赞数 1
分类专栏： C/C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/turbolove/article/details/127704965
版权

内存管理

基本体

分配内存和释放内存

方式

分配释放类别能否重载
malloc()free()c函数不可
newdeletec++表达式不可
::operator new()::operator delete()c++函数可
allocator::allocate()allocator::deallocate()c++标准库可自由设计并且搭配任何容器

示例

#include <complex>
#include <stdlib.h>
using namespace std;
int main()
{
    char *p = (char *)malloc(512);
    p[0] = 'c';
    free(p);

    complex<int> *p2 = new complex<int>;
    delete p2;

    void *p3 = ::operator new(512);
    ::operator delete(p3);

#ifdef __GNUC__
    void *p5 = allocator<int>().allocate(7);
    allocator<int>().deallocate((int *)p5,7);
#endif
    return 0;
}

new 和 delete

不能直接调用构造函数，但是可以直接调用析构函数

#include <stdlib.h>
#include <string>
#include <iostream>
using namespace std;

class MemoryTest
{
public:
    MemoryTest()
    {
        cout << "MemoryTest"<< endl;
    }
    ~MemoryTest()
    {
        cout << "~MemoryTest"<< endl;
    }
};

int main()
{
    // MemoryTest *str = new MemoryTest();
    // str->MemoryTest();
    MemoryTest str2;
    // str->~MemoryTest();
    str2.~MemoryTest();
    return 0;
}

如果类内有指针则会出现

错误

class MemoryTest
{
public:
    MemoryTest()
    {
        p = new string("123456");
        cout << *p << endl;
    }
    ~MemoryTest()
    {
        delete p;
    }

private:
    string *p;
};

int main()
{
    // MemoryTest *str = new MemoryTest();
    // str->MemoryTest();
    MemoryTest str2;
    // str->~MemoryTest();
    str2.~MemoryTest();
    return 0;
}

正确

#include <complex>
#include <stdlib.h>
#include <string>
#include <iostream>
using namespace std;

class MemoryTest
{
public:
    MemoryTest()
    {
        p = new string("123456");
        cout << *p << endl;
    }
    ~MemoryTest()
    {
        if(p)
        {
            delete p;
            p = nullptr;
        }
    }

private:
    string *p{nullptr};
};

int main()
{
    // MemoryTest *str = new MemoryTest();
    // str->MemoryTest();
    MemoryTest str2;
    // str->~MemoryTest();
    str2.~MemoryTest();
    return 0;
}

深拷贝和浅拷贝

#include <complex>
#include <stdlib.h>
#include <string>
#include <iostream>
using namespace std;

class A
{
public:
    A(int _data) : data(_data){}
    ~A(){
        cout << data << endl;
    }
private:
    int data;
};
int main()
{
    A a(5);
    A b = a;
    return 0;
}

错误

class A
{
public:
    A(int _size) : size(_size)
    {
        data = new int[size];
    } 
    A(){};
    ~A()
    {
        delete [] data;
    } 
private:
    int* data;
    int size;
};

int main()
{
    A a(5), b = a; 
}

正确

class A
{
public:
    A(int _size) : size(_size)
    {
        data = new int[size];
    }
    A(){};
    A(const A& _A) : size(_A.size)
    {
        data = new int[size];
    } 
    ~A()
    {
        delete [] data;
    } 
private:
    int* data;
    int size;
};

int main()
{
    A a(5), b = a; 
}

new[] 和 delete[]

#include <stdlib.h>
#include <string>
#include <iostream>
using namespace std;
class MemoryTest
{
public:
    MemoryTest():id_(0)
    {
        cout << this << "default MemoryTest id =" << id_ << endl;
    }
    MemoryTest(int id):id_(id)
    {
        cout << this << "default MemoryTest id =" << id_ << endl;
    }
    ~MemoryTest()
    {
        cout << this << "default ~MemoryTest id =" << id_ << endl;
    }

private:
    int id_;
};

int main()
{
    MemoryTest *str = new MemoryTest[3];
    delete[] str;
    int *p = new int[20];
    delete p; // 内置类型析构函数没有意义时候删除不会报错，但是不建议这么使用
    return 0;
}

调用构造函数修改

#include <stdlib.h>
#include <string>
#include <iostream>
using namespace std;

class MemoryTest
{
public:
    MemoryTest():id_(0)
    {
        cout << this << " default MemoryTest id =" << id_ << endl;
    }
    MemoryTest(int id):id_(id)
    {
        cout << this << " default MemoryTest id =" << id_ << endl;
    }
    ~MemoryTest()
    {
        cout << this << " default ~MemoryTest id =" << id_ << endl;
    }

private:
    int id_;
};

int main()
{
    MemoryTest *str = new MemoryTest[3];
    MemoryTest *tmp = str;

    for(int i = 0; i < 3; ++i)
        new (tmp++) MemoryTest(i);

    delete[] str;
    return 0;
}

placement new/placement delete

#include <stdlib.h>
#include <string>
#include <iostream>
using namespace std;

class MemoryTest
{
public:
    MemoryTest():id_(0)
    {
        cout << this << " default MemoryTest id =" << id_ << endl;
    }
    MemoryTest(int id):id_(id)
    {
        cout << this << " default MemoryTest id =" << id_ << endl;
    }
    ~MemoryTest()
    {
        cout << this << " default ~MemoryTest id =" << id_ << endl;
    }

private:
    int id_;
};

int main()
{
    char *buf = new char[sizeof(MemoryTest)*3];
    MemoryTest *test = new (buf)MemoryTest();
    delete[] buf;
    return 0;
}

重载 ::operator new / ::operator delete

#include <stdlib.h>
#include <string>
#include <iostream>
using namespace std;

void* myAlloc(size_t size)
{
    return malloc(size);
}
void myFree(void *pt)
{
    return free(pt);
}

class A
{
public:
    inline void * operator new (size_t size)
    {
        cout << "global new " << std::endl;
        return myAlloc(size);
    }
    inline void * operator new[] (size_t size)
    {
        cout << "global new[] " << std::endl;
        return myAlloc(size);
    }
    inline void operator delete (void *pt)
    {
        cout << "global delete " << std::endl;
        myFree(pt);
    }
    inline void operator delete[] (void *pt)
    {
        cout << "global delete[] " << std::endl;
        myFree(pt);
    }

};

int main()
{
    A *c = new A;
    delete c;
    A *c2 = new A[10];
    delete[] c2;
    return 0;
}

重载 new() / delete()

#include <stdlib.h>
#include <string>
#include <iostream>
using namespace std;

void* myAlloc(size_t size)
{
    return malloc(size);
}
void myFree(void *pt)
{
    return free(pt);
}

class Bad : public exception
{

};
class A
{
public:
    A()
    {
        cout << "A" << std::endl;
    }
    A(int i) : id_(i)
    {
        cout << "A(int i)" << std::endl;
        // 本来抛出异常应该调用析构函数，但是我这里程序会进行不下去，应该是编译器做了优化，暂时未查询原因
        // throw Bad{};
    }
    inline void * operator new (size_t size)
    {
        cout << "operator new (size_t size)" << std::endl;
        return myAlloc(size);
    }
    inline void * operator new (size_t size, void *start)
    {
        cout << "operator new (size_t size, void *start) " << std::endl;
        return myAlloc(size);
    }
    inline void * operator new (size_t size, long extra)
    {
        cout << "operator new (size_t size, long extra)" << std::endl;
        return myAlloc(size+extra);
    }
    inline void * operator new (size_t size, long extra, char init)
    {
        cout << "operator new (size_t size, long extra, char init) " << std::endl;
        return myAlloc(size+extra);
    }

    inline void operator delete (void *, size_t t)
    {
        cout << "operator delete (void *, size_t t) " << std::endl;
    }
    inline void operator delete (void *, void *)
    {
        cout << "operator delete (void *, void *) " << std::endl;
    }
    inline void operator delete (void *, long)
    {
        cout << "operator delete (void *, long) " << std::endl;
    }
    inline void operator delete (void *, long, char)
    {
        cout << "operator delete (void *, long, char) " << std::endl;
    }

    void myPrint()
    {
        std::cout << "test" << std::endl;
    }

private:
    int id_;
};

int main()
{
    string s = "ccc";
    A *a = new A;
    A *a1 = new (a)A;
    A *a2 = new (100)A;
    A *a3 = new (100,'a')A;
    A *a4 = new (100)A(1);
    A *a5 = new (100,'a')A(1);
    A *a6 = new (a)A(1);
    A *a7 = new A(1);
    return 0;
}

空间划分

#include <stdlib.h>
#include <string>
#include <iostream>
#include <valarray>

using namespace std;

class Screen
{
public:
    Screen(int x):i(x)
    {

    }
    int get(){return i;};

    void * operator new (size_t size)
    {
        Screen *p;
        if(!freeStore)
        {
            size_t chunk = screenChunk * size;
            freeStore = p = reinterpret_cast<Screen * >(new char[chunk]);
            for(;p != &freeStore[screenChunk-1];++p)
            {
                p->next = p+1;
            }
            p->next = 0;
        }
        p = freeStore;
        freeStore = freeStore->next;
        return p;
    }
    void operator delete (void *p,size_t size)
    {
        static_cast<Screen *>(p)->next = freeStore;
        freeStore = static_cast<Screen *>(p);
    }

private:
    Screen *next;
    static Screen *freeStore;
    static const int screenChunk;

    int i;
};
Screen *Screen::freeStore = 0;
const int Screen::screenChunk = 24;
int main()
{
    size_t const N = 100;
    Screen *p[N];
    for(int i = 0; i < N; ++i)
    {
        p[i] = new Screen(i);
    }

    for(int i = 0; i < 10; ++i)
    {
        cout << p[i] << endl;
    }
    for(int i = 0; i < N; ++i)
    {
        delete p[i];
    }
    return 0;
}

改造

#include <stdlib.h>
#include <string>
#include <iostream>
#include <valarray>

using namespace std;

class Airplane
{
private:
    struct AirplaneRep
    {
        unsigned long miles;
        char type;
    };
    union {
        AirplaneRep rep;
        Airplane *next;
    };
    static const int BLOCK_SIZE;
    static Airplane *headOfFreeList;
public:
    unsigned long getMiles(){return rep.miles;}
    char getType(){return rep.type;}
    void set(unsigned long m ,char t)
    {
        rep.miles = m;
        rep.type = t;
    }

public:
    void * operator new(size_t size)
    {
        // 为了防止继承造成的空间大小不一致问题
        if(size != sizeof(Airplane))
            return ::operator new(size);

        Airplane *p = headOfFreeList;
        if(p)
            headOfFreeList = p->next;
        else
        {
            Airplane *newBlock = static_cast<Airplane *>(::operator new (BLOCK_SIZE * sizeof(Airplane)));
            for(int i = 1; i < BLOCK_SIZE -1; ++i)
            {
                newBlock[i].next = &newBlock[i+1];
            }
            newBlock[BLOCK_SIZE -1].next = 0;
            p = newBlock;
            headOfFreeList = &newBlock[1];
        }
        return p;
    }
    void operator delete (void *dataObj,size_t size)
    {
        if(dataObj == 0) return;
        if(size != sizeof(Airplane))
        {
            ::operator delete(dataObj);
            return;
        }
        Airplane *carcass = static_cast<Airplane *>(dataObj);
        carcass->next = headOfFreeList;
        headOfFreeList = carcass;
    }
};

const int Airplane:: BLOCK_SIZE = 512;
Airplane *Airplane::headOfFreeList;
int main()
{
    cout << sizeof(Airplane) << endl;
    size_t const N = 100;
    Airplane *p[N];
    for(int i = 0; i < N; ++i)
    {
        p[i] = new Airplane;
    }
    p[1]->set(1000,'A');
    p[2]->set(1000,'B');
    p[3]->set(1000,'C');
    p[4]->set(1000,'D');
    p[5]->set(1000,'E');
    p[6]->set(1000,'F');
    p[7]->set(1000,'G');
    p[8]->set(1000,'H');
    p[9]->set(1000,'I');
    for(int i = 0; i < 10; ++i)
    {
        cout << p[i] << endl;
    }
    for(int i = 0; i < N; ++i)
    {
        delete p[i];c
    }
    return 0;
}

分配器

#include <stdlib.h>
#include <string>
#include <iostream>
#include <valarray>

using namespace std;

class Allocator
{
public:
    void *allocate(size_t size)
    {
        obj *p;
        if(!freeStore)
        {
            size_t chunk = CHUNK * size;
            freeStore = p = (obj*) malloc(chunk);
            for(int i = 0; i < CHUNK -1; ++i)
            {
                p->next = (obj*)((char *)p +size);
                p = p->next;
            }
            p->next = nullptr;
        }
        p =freeStore;
        freeStore = freeStore->next;
        return p;
    }
    void deallocate(void *p,size_t size)
    {
        ((obj*)p)->next = freeStore;
        freeStore = (obj*)p;
    }

private:
    struct obj
    {
        struct obj *next;
    };
    obj *freeStore = nullptr;
    const int CHUNK = 5;
};

class Foo
{
public:
    long L;
    string str;
    static Allocator myAlloc;
public:
    Foo(long l):L(l){}
    void * operator new(size_t size)
    {
        return myAlloc.allocate(size);
    }
    void operator delete (void * p, size_t size)
    {
        return myAlloc.deallocate(p,size);
    }
};
Allocator Foo::myAlloc;

int main()
{
    Foo *p[100];
    cout << sizeof(Foo) <<endl;
    for(int i =0; i< 19; i++)
    {
        p[i] = new Foo(i);
        cout << p[i] << " " << p[i]->L << endl;
    }
    cout << 0x633b40-0x633ae0 << " " << 0x633b68-0x633b40 << endl;
    for(int i =0; i< 19; i++)
    {
        delete p[i];
    }
    return 0;
}

使用宏替换

#include <stdlib.h>
#include <string>
#include <iostream>
#include <valarray>

using namespace std;

class Allocator
{
public:
    void *allocate(size_t size)
    {
        obj *p;
        if(!freeStore)
        {
            size_t chunk = CHUNK * size;
            freeStore = p = (obj*) malloc(chunk);
            for(int i = 0; i < CHUNK -1; ++i)
            {
                p->next = (obj*)((char *)p +size);
                p = p->next;
            }
            p->next = nullptr;
        }
        p =freeStore;
        freeStore = freeStore->next;
        return p;
    }
    void deallocate(void *p,size_t size)
    {
        ((obj*)p)->next = freeStore;
        freeStore = (obj*)p;
    }

private:
    struct obj
    {
        struct obj *next;
    };
    obj *freeStore = nullptr;
    const int CHUNK = 5;
};

#define DECLARE_POOL_ALLOC_1() \
public:                      \
    void * operator new(size_t size){  return myAlloc.allocate(size); }   \
    void operator delete (void * p, size_t size){  return myAlloc.deallocate(p,size);  }                        \
protected:                             \
    static Allocator myAlloc;

#define IMPLEMENT_POOL_ALLOC_1(ClassName) \
    Allocator ClassName::myAlloc;

class Foo
{
    DECLARE_POOL_ALLOC_1();
public:
    long L;
    string str;
public:
    Foo(long l):L(l){}

};
IMPLEMENT_POOL_ALLOC_1(Foo);

int main()
{
    Foo *p[100];
    cout << sizeof(Foo) <<endl;
    for(int i =0; i< 19; i++)
    {
        p[i] = new Foo(i);
        cout << p[i] << " " << p[i]->L << endl;
    }
    cout << 0x633b40-0x633ae0 << " " << 0x633b68-0x633b40 << endl;
    for(int i =0; i< 19; i++)
    {
        delete p[i];
    }
    return 0;
}

new_handler

new (nothrow)Foo; 检查是否成功

typedef void (*new_handler)();

new_handler set_new_handler(new_handler p) throw();

当内存溢出的时候，C++提供一个内存检查函数，让用户提供

  1. 让更多的内存可用

  2. 调用abort()和exit();

#include <stdlib.h>
#include <iostream>
#include <valarray>
#include <new>
#include <cassert>

using namespace std;

void noMoreMemory()
{
    cerr << "out of memory" << endl;
    abort(); // 不abort 的话会不断打印这个err
}

int main()
{
    set_new_handler(noMoreMemory);
    int *p = new int[10000000000000];
    assert(p);
    return 0;
}

default delete

#include <stdlib.h>
#include <iostream>
#include <valarray>
#include <new>
#include <cassert>

using namespace std;

class Foo
{
public:
    // static void *operator new(size_t size) = default;
    // static void *operator delete(void *,size_t size) = default;
    static void *operator new[](size_t size) = delete;
    static void operator delete [](void *,size_t size) = delete;

};
int main()
{
    Foo *foo = new Foo;
    delete foo;

//    Foo *foo2 = new Foo[100];
//    delete foo[];
    return 0;
}
turbolove
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++指针与内存管理.doc
07-28
在C++编程中，内存管理和指针的使用是至关重要的，因为它们直接影响程序的稳定性和...通过理解这些基本概念和注意事项，开发者能够更好地掌握C++中的指针操作和内存管理，避免常见的内存错误，提升代码质量和稳定性。
c++实现简易内存管理
06-30
内存管理和内存池是计算机科学中重要的概念，尤其是在C++编程中。C++作为一个低级语言，提供了对内存的直接操作，但同时也要求程序员手动管理内存，以避免内存泄漏和悬垂指针等问题。本篇文章将深入探讨如何使用C++...
C++ STL标准库：std::valarray 使用详解
超级大洋葱的博客
12-15 7957
文章目录1.简介2.代码示例3.成员函数3.1 构造函数 1.简介 valarray对象被设计用来保存一个值数组，并且可以轻松地对它们执行数学运算。它还允许特殊机制引用数组中元素的子集（请参见其运算符[]重载）。 大多数数学运算可以直接应用于valarray对象，包括算术和比较运算符，影响其所有元素。 valarray规范允许库通过几种效率优化来实现它，例如某些操作的并行化、内存回收或支持“引用时拷贝/写入时拷贝”优化。实现甚至可以取代valarray作为下面描述的标准函数的返回类型，前提是它们的行为方式是
操作系统---内存空间的分配与回收
m0_69216084的博客
04-22 917
1.给进程分配内存空间，操作系统需要记录哪些内存区域被分配出去了，哪些还空着2.当进程运行结束后，操作系统如何回收内存空间。
Linux服务器查看内存使用情况
爱琴孩的博客
09-28 1126
前言 在日常开发或者生产环境，我们经常需要查看linux服务的内存使用情况，所以能熟练敲出命令能便于我们快速定位问题，这里来和大家一起学习linux的常用查看内存命令。 free命令 free命令显示系统使用和空闲的内存情况，包括物理内存、交互区内存(swap)和内核缓冲区内存。 很清晰明白的显示出了总内存多少，已使用多少，还剩下多少。这里可以看到Swap的used已使用了811Mb，服务器上跑了一个下载音频的进程，物理内存已经不够用了，所以从磁盘中虚拟出一部分的内存。当然我们可以使用free.
c/c++函数间动态内存传递问题
iceshirley的专栏
05-09 898
我们经常能遇到这样一种问题，既是声明一个指针，然后想在相关的函数中对其进行分配空间。这样问题如果操作不当，不仅造成内存泄露，而且得不到相应的结果。先看以下例子void allocMemory(char *p)...{    p=(char *)malloc(sizeof(char)*128);}int main()...{    char *s=NULL;    allocMemory(s
[Linux]How to alloc memory (kmalloc) in Linux ISR
weixin_34362875的博客
09-25 93
2019独角兽企业重金招聘Python工程师标准>>> ...
C++内存管理
须知少日拏云志，曾许人间第一流。
10-21 6118
很多人总是听到栈、堆以及静态区之类的说法，但是始终没有一个完整的概念关于C++程序中内存区域的结构分布。这一期，我们来详细介绍一下C++程序中的内存管理。 我们首先看下图：注释：通常来说，我们创建的局部变量和函数中的参数就是放在栈中。而我们之前动态开辟的内存，其实就是开辟在了堆区中。而全局变量以及通过我们 static 设置为静态的数据都会放在数据段。我们可以知道，在C语言中我们用了malloc以及calloc来进行动态的开辟空间，用free来释放空间。那么，在C++中又是如何进行动态的内存管理的呢？
C / C++ 内存管理
热门推荐
bit_zyx的博客
06-22 1万+
目录 1、C / C++内存分布 2、C语言中动态内存管理方式 malloc / calloc / realloc / free 3、C++内存管理方式 new / delete 操作内置类型 new / delete 操作自定义类型 4、operator new与operator delete函数（重要点进行讲解） operator new与operator delete函数（重点） operator new......
C++内存管理学习资料.md
07-27
### C++内存管理学习资料概览 #### 一、引言 C++作为一种强大的编程语言，因其高效性和灵活性被广泛应用于各种领域。然而，这也带来了内存管理方面的挑战。本资料汇集了一系列关于C++内存管理的学习资源，旨在帮助...
C++内存管理经典分析
05-20
本文将深入探讨C++内存管理的经典分析，包括指针的应用、动态内存分配、内存泄漏和内存溢出等问题，帮助开发者避免常见的陷阱，提升编程水平。 一、指针的应用 指针是C++中的核心特性之一，它允许直接操作内存地址...
存储器管理
weixin_45010467的博客
06-17 126
//操作系统存储器管理 //首次适应算法,循环首次适应算法,最优适应算法,最坏适应算法 //4118080036 孙天雨 计算机科学与技术本科1班 #include "iostream" #include "stdlib.h" using namespace std; #define FREE 0 #define BUSY 1 #define MAX_LENGTH 1000 //数据结构 //空闲链表数据域 struct FreeNodeDataArea { int address; //该空
C++笔记5•内存管理•
最新发布
qq_64446190的博客
08-12 1005
内存管理
c++ error: ‘*’ does not name a type； did you mean ‘**’?
xiaozhi
08-08 517
c++ error: ‘*’ does not name a type； did you mean ‘**’?
STL中的迭代器失效（vector为例）
2302_80190394的博客
08-08 407
STL中的迭代器失效（vector为例）
C语言一维数组(含数组二分查找)
hdxbufcbjuhg的博客
08-09 1215
在⼀个升序的数组中查找指定的数字n，很容易想到的⽅法就是遍历数组，但是这种⽅法效率⽐较低。比如我们之前写的猜数字游戏，会生成一个随机数来让玩家猜，范围是1~100，那玩家会从1开始一个一个猜吗，不会吧，那样就太慢了，我们一般会从整体的一半开始猜，比如猜50，告诉你大了还是小了，这样只需要一步就可以排除庞大数字中的一半，比如假设猜1 ~ 10000，猜5000后就可以知道猜大了还是小了，直接排除了5000个数字，效率很快，这就是⼆分查找，也叫折半查找。
【C++】类的默认成员函数，构造函数、析构函数、拷贝构造函数、运算符重载
2402_82757055的博客
08-10 870
这篇我们继续学习C++类和对象部分，大概会说一下类的一些默认成员函数，构造函数、析构函数、拷贝构造函数、赋值运算符重载这些知识。
C语言断言进阶篇：全面总结与实战技巧
极客代码
08-10 456
断言是一种用于验证程序中某个条件是否为真的语句。如果条件为假，程序会触发一个错误，通常会导致程序终止。断言主要用于开发和测试阶段，以帮助开发者发现和修正错误。在某些情况下，默认的assert宏可能无法满足我们的需求。if (!abort();= NULL);在这个自定义断言宏中，我们输出了更多的错误信息，包括失败的断言表达式、函数名、文件名和行号，方便我们定位错误。本文系统且全面地总结了C语言中的断言机制，包括断言的定义、作用、实现以及在实战中的运用。
C++内存管理基石：primitives与实战应用
"C++内存管理机制笔记" 在这个C++内存管理机制的笔记中，我们将深入探讨C++语言中的内存管理基础知识，从宏观视角出发，逐步介绍从基础概念到高级实践的过程。首先，学习者需要具备使用C++标准库容器的经验，并熟悉...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

turbolove

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值