C++提供的智能指针 unique_ptr、shared_ptr、weak_ptr

最新推荐文章于 2024-10-05 21:10:28 发布
最新推荐文章于 2024-10-05 21:10:28 发布
阅读量1k 收藏 21
点赞数 20
分类专栏： # C++ 设计模式和设计原则 文章标签： c++ 智能指针 unique_ptr shared_ptr weak_ptr
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/flyfish1986/article/details/140735290
版权

C++提供的智能指针 unique_ptr、shared_ptr、weak_ptr

flyfish

C++提供的智能指针 unique_ptr、shared_ptr、weak_ptr

曾经的代码是这样写的

delete 用于释放通过 new 分配的单个对象。
delete[] 用于释放通过 new[] 分配的数组。

单个对象的分配和释放 ：

int* p = new int;  // 分配单个int对象
delete p;         // 释放单个int对象

数组的分配和释放 ：

int* arr = new int[10];  // 分配包含10个int的数组
delete[] arr;            // 释放数组

示例

#include <iostream>

class MyClass {
public:
    MyClass() { std::cout << "MyClass created" << std::endl; }
    ~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
};

int main() {
    // 分配和释放单个对象
    MyClass* obj = new MyClass;
    delete obj;

    // 分配和释放数组
    MyClass* arr = new MyClass[3];
    delete[] arr;

    return 0;
}

C++标准库提供了几种智能指针

  • std::unique_ptr ：独占所有权智能指针（Unique Ownership Smart Pointer）

  • std::shared_ptr ：共享所有权智能指针（Shared Ownership Smart Pointer）

  • std::weak_ptr ：弱引用智能指针（Weak Reference Smart Pointer）

1. std::unique_ptr

std::unique_ptr 是一种独占所有权的智能指针，意味着同一时间只有一个 std::unique_ptr 拥有某个对象的所有权。它在离开作用域时会自动释放所管理的对象。
使用场景 ：
独占所有权：当一个对象只能有一个所有者时，使用 std::unique_ptr。
高效转移所有权：通过 std::move 可以高效地转移 std::unique_ptr 的所有权。
示例代码 ：

#include <memory>
#include <iostream>

class MyClass {
public:
    MyClass() { std::cout << "MyClass created" << std::endl; }
    ~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
};

int main() {
    std::unique_ptr<MyClass> ptr1 = std::make_unique<MyClass>();
    // std::unique_ptr<MyClass> ptr2 = ptr1; // 错误：无法复制
    std::unique_ptr<MyClass> ptr2 = std::move(ptr1); // 合法：转移所有权
    return 0;
}

2. std::shared_ptr

std::shared_ptr 是一种共享所有权的智能指针，意味着多个 std::shared_ptr 可以同时指向同一个对象。对象的生存期由引用计数（reference count）管理，当最后一个 std::shared_ptr 被销毁时，引用计数归零，对象也被销毁。
使用场景 ：
共享所有权：当多个对象需要共享同一资源时，使用 std::shared_ptr。
示例代码 ：

#include <memory>
#include <iostream>

class MyClass {
public:
    MyClass() { std::cout << "MyClass created" << std::endl; }
    ~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
};

int main() {
    std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();
    std::shared_ptr<MyClass> ptr2 = ptr1; // 合法：共享所有权
    std::cout << "Reference count: " << ptr1.use_count() << std::endl; // 引用计数为2
    return 0;
}

3. std::weak_ptr

std::weak_ptr 是一种不控制对象生存期的智能指针，它指向一个由 std::shared_ptr 管理的对象，但不增加引用计数。std::weak_ptr 主要用于解决循环引用问题。
使用场景 ：
弱引用：当需要访问一个由 std::shared_ptr 管理但不应该延长其生存期的对象时，使用 std::weak_ptr。
防止循环引用：在某些数据结构（如双向链表、图）中使用，以避免循环引用导致的内存泄漏。
示例代码 ：

#include <memory>
#include <iostream>

class MyClass {
public:
    MyClass() { std::cout << "MyClass created" << std::endl; }
    ~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
    std::weak_ptr<MyClass> ptr; // 使用 weak_ptr 打破循环引用
};

int main() {
    std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();
    std::shared_ptr<MyClass> ptr2 = std::make_shared<MyClass>();
    
    // 使用 lock() 方法来从 weak_ptr 获取 shared_ptr
    ptr1->ptr = ptr2; // ptr1->ptr 仍然是 weak_ptr，但这里存储的是 ptr2 的 shared_ptr
    ptr2->ptr = ptr1; // ptr2->ptr 也是 weak_ptr，但这里存储的是 ptr1 的 shared_ptr
    
    // 这里需要将 weak_ptr 转换成 shared_ptr，以便可以访问 MyClass 的成员
    if (auto lockedPtr1 = ptr1->ptr.lock()) {
        std::cout << "ptr1's ptr is locked and points to: " << lockedPtr1.get() << std::endl;
    } else {
        std::cout << "ptr1's ptr is expired." << std::endl;
    }
    
    if (auto lockedPtr2 = ptr2->ptr.lock()) {
        std::cout << "ptr2's ptr is locked and points to: " << lockedPtr2.get() << std::endl;
    } else {
        std::cout << "ptr2's ptr is expired." << std::endl;
    }
    
    return 0;
}

输出

MyClass created
MyClass created
ptr1's ptr is locked and points to: 000001E5FCA463B0
ptr2's ptr is locked and points to: 000001E5FCA467D0
MyClass destroyed
MyClass destroyed

循环引用 （写一个错误的例子和正确的例子）

循环引用（cyclic reference）发生在两个或多个对象互相持有对方的引用，导致这些对象无法被正确释放。这种情况通常会导致内存泄漏。使用 std::shared_ptr 管理对象时，容易出现循环引用问题。

循环引用示例 错误的例子

以下是一个简单的循环引用示例：

#include <iostream>
#include <memory>

class B; // 前向声明

class A {
public:
    std::shared_ptr<B> ptrB;
    ~A() { std::cout << "A destroyed" << std::endl; }
};

class B {
public:
    std::shared_ptr<A> ptrA;
    ~B() { std::cout << "B destroyed" << std::endl; }
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();

    a->ptrB = b;
    b->ptrA = a;

    return 0; // 循环引用导致 A 和 B 不会被正确释放
}

创建了两个类 A 和 B，并且它们之间存在循环引用。A 类包含一个指向 B 类的 std::shared_ptr，而 B 类也包含一个指向 A 类的 std::shared_ptr。这会导致循环引用问题，使得 A 和 B 的实例都无法被正确销毁，因为它们互相保持着对彼此的引用。，a 和 b 互相持有对方的 shared_ptr，导致引用计数永远不会归零，从而导致内存泄漏。

循环引用示例 正确的例子

解决循环引用：使用 std::weak_ptr``std::weak_ptr 是一种不增加引用计数的智能指针，可以打破循环引用。以下是修正后的示例：

#include <iostream>
#include <memory>

class B;

class A {
public:
    std::shared_ptr<B> ptrB;
    ~A() { std::cout << "A destroyed" << std::endl; }
};

class B {
public:
    std::weak_ptr<A> ptrA; // 使用 weak_ptr 打破循环引用
    ~B() { std::cout << "B destroyed" << std::endl; }
};

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();

    a->ptrB = b;
    b->ptrA = a;

    return 0; // A 和 B 会被正确释放
}

输出

A destroyed
B destroyed

对于 std::vector 存储的原始指针，需要手动遍历并调用 delete 释放内存

如果 std::vector 存储的是通过 new 分配的原始指针，必须手动释放这些对象。可以通过循环遍历 vector 来删除所有指针指向的对象，然后清空 vector。

示例
#include <vector>
#include <iostream>

class MyClass {
public:
    MyClass() { std::cout << "MyClass created" << std::endl; }
    ~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
};

int main() {
    std::vector<MyClass*> vec;
    vec.push_back(new MyClass());
    vec.push_back(new MyClass());

    // 释放内存
    for (MyClass* ptr : vec) {
        delete ptr;
    }
    vec.clear();

    return 0;
}

在这个例子中，手动遍历 vector，对每个指针调用 delete 来释放内存，然后清空 vector。std::vector 中装智能指针

对于 std::vector 存储的智能指针，智能指针会自动管理对象的生命周期

如果 std::vector 存储的是智能指针（如 std::unique_ptr 或 std::shared_ptr），智能指针会自动管理对象的生命周期，当 vector 被销毁时，智能指针会自动释放所管理的对象，无需手动释放。

#include <vector>
#include <memory>
#include <iostream>

class MyClass {
public:
    MyClass() { std::cout << "MyClass created" << std::endl; }
    ~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
};

int main() {
    std::vector<std::unique_ptr<MyClass>> vec;
    vec.push_back(std::make_unique<MyClass>());
    vec.push_back(std::make_unique<MyClass>());

    // 当 vec 被销毁时，存储的 unique_ptr 会自动释放 MyClass 对象
    return 0;
}

输出

MyClass created
MyClass created
MyClass destroyed
MyClass destroyed

在这个例子中，std::unique_ptr 会在 vector 作用域结束时自动释放内存。使用 std::shared_ptr

#include <vector>
#include <memory>
#include <iostream>

class MyClass {
public:
    MyClass() { std::cout << "MyClass created" << std::endl; }
    ~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
};

int main() {
    std::vector<std::shared_ptr<MyClass>> vec;
    vec.push_back(std::make_shared<MyClass>());
    vec.push_back(std::make_shared<MyClass>());

    // 当 vec 被销毁时，存储的 shared_ptr 会自动管理 MyClass 对象的生命周期
    return 0;
}

输出

MyClass created
MyClass created
MyClass destroyed
MyClass destroyed

在这个例子中，std::shared_ptr 会在 vector 作用域结束时自动释放内存，只要没有其他 shared_ptr 仍然指向相同的对象。

enable_shared_from_this 和 shared_from_this

enable_shared_from_this 和 shared_from_this 提供了一种安全生成 shared_ptr 的方式
std::enable_shared_from_this 是一个帮助类，允许对象安全地生成指向自身的 std::shared_ptr。
安全地创建 shared_ptr：通过 enable_shared_from_this，可以确保在类成员函数中安全地生成指向当前对象的 shared_ptr，避免多次创建不同的 shared_ptr 导致的问题。

#include <iostream>
#include <memory>

class MyClass : public std::enable_shared_from_this<MyClass> {
public:
    std::shared_ptr<MyClass> getSharedPtr() {
        return shared_from_this();
    }
    ~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
};

int main() {
    std::shared_ptr<MyClass> obj = std::make_shared<MyClass>();
    std::shared_ptr<MyClass> obj2 = obj->getSharedPtr();

    std::cout << "obj use count: " << obj.use_count() << std::endl;  // 输出 2
    std::cout << "obj2 use count: " << obj2.use_count() << std::endl; // 输出 2

    return 0;
}

输出

obj use count: 2
obj2 use count: 2
MyClass destroyed

expired 的作用

expired 是 std::weak_ptr 类中的一个成员函数，用来检查 weak_ptr 指向的对象是否已经被销毁。std::weak_ptr 是一种不拥有对象的指针，它可以观察一个由 std::shared_ptr 管理的对象，但不会影响对象的生命周期。
expired 返回一个布尔值，如果 std::weak_ptr 指向的对象已经被销毁（引用计数为零），它返回 true；否则返回 false。

使用 expired 检查对象是否仍然存在
使用 expired 可以检查 std::weak_ptr 指向的对象是否仍然存在。如果对象已经被销毁，可以避免对一个无效的对象进行操作。

示例代码
以下是一个使用 std::weak_ptr 和 expired 的示例，展示了如何避免循环引用和检查对象的有效性

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass() { std::cout << "MyClass created" << std::endl; }
    ~MyClass() { std::cout << "MyClass destroyed" << std::endl; }
    std::weak_ptr<MyClass> ptr; // 使用 weak_ptr 打破循环引用
};

int main() {
    {
        // 创建两个 shared_ptr
        auto ptr1 = std::make_shared<MyClass>();
        auto ptr2 = std::make_shared<MyClass>();

        // 互相引用对方的 shared_ptr
        ptr1->ptr = ptr2;
        ptr2->ptr = ptr1;

        // 检查 ptr1 和 ptr2 指向的对象是否仍然存在
        if (ptr1->ptr.expired()) {
            std::cout << "ptr1's ptr is expired." << std::endl;
        } else {
            std::cout << "ptr1's ptr is still valid." << std::endl;
        }

        if (ptr2->ptr.expired()) {
            std::cout << "ptr2's ptr is expired." << std::endl;
        } else {
            std::cout << "ptr2's ptr is still valid." << std::endl;
        }
    } // 这里 ptr1 和 ptr2 超出作用域，被销毁

    // 此时 ptr1 和 ptr2 所指向的对象已经被销毁
    // 所有 MyClass 对象都已经被销毁，析构函数已经被调用

    return 0;
}

std::shared_ptr ：引用计数是线程安全的，但对对象的访问和修改需要额外的同步

当需要多个线程共享对象的所有权，确保对象在有线程使用时不会被销毁，不存在循环引用的风险，多线程里可以用std::shared_ptr。

例子

#include <iostream>
#include <memory>
#include <thread>
#include <vector>

void threadFunction(std::shared_ptr<int> sharedPtr) {
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    std::cout << "Value: " << *sharedPtr << std::endl;
}

int main() {
    std::shared_ptr<int> sharedPtr = std::make_shared<int>(42);
    
    std::vector<std::thread> threads;
    for (int i = 0; i < 10; ++i) {
        threads.push_back(std::thread(threadFunction, sharedPtr));
    }
    
    for (auto& t : threads) {
        t.join();
    }
    
    return 0;
}

td::unique_ptr：不是线程安全的，不能在多个线程之间共享

std::unique_ptr 不是线程安全的。因为 std::unique_ptr 不能被复制，只能被移动，这意味着同一时间只能有一个线程拥有该指针的所有权。如果需要在多个线程中共享所有权，应该使用 std::shared_ptr。

std::weak_ptr ：调用 lock 方法是线程安全的，但对对象的访问和修改需要额外的同步

当需要避免循环引用，线程只需要观察对象的生命周期，而不需要拥有对象，需要临时访问对象，而不需要延长对象的生命周期，多线程中用std::weak_ptr。

#include <iostream>
#include <memory>
#include <thread>
#include <vector>

void threadFunction(std::weak_ptr<int> weakPtr) {
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    if (auto sharedPtr = weakPtr.lock()) {
        std::cout << "Value: " << *sharedPtr << std::endl;
    } else {
        std::cout << "Object has been destroyed." << std::endl;
    }
}

int main() {
    std::shared_ptr<int> sharedPtr = std::make_shared<int>(42);
    std::weak_ptr<int> weakPtr = sharedPtr;

    std::vector<std::thread> threads;
    for (int i = 0; i < 10; ++i) {
        threads.push_back(std::thread(threadFunction, weakPtr));
    }

    for (auto& t : threads) {
        t.join();
    }

    sharedPtr.reset(); // 销毁对象

    return 0;
}
西笑生
关注
专栏目录
C++11中的智能指针unique_ptr、shared_ptr和weak_ptr详解
dvlinker的技术专栏
05-28 3万+
详细讲解C++11中引入的智能指针unique_ptr、shared_ptr和weak_ptr。
C++11 新特性 ⑥ | 智能指针 unique_ptr、shared_ptr 和 weak_ptr
热门推荐
dvlinker的技术专栏
09-10 2万+
详细讲解C++11中的智能指针 unique_ptr、shared_ptr 和 weak_ptr。
C++11：智能指针 unique_ptr、shared_ptr、weak_ptr 介绍
weixin_57663528的博客
05-22 1075
了解智能指针的发展史，unique_ptr、shared_ptr、weak_ptr等智能指针的详细介绍
C++ 智能指针 shared_ptr、unique_ptr、weak_ptr
m0_50313114的博客
05-25 257
weak_ptr是为了配合shared_ptr而引入的一种智能指针，因为它不具有普通指针的行为，没有重载operator*和->,它的最大作用在于协助shared_ptr工作，像旁观者那样观测资源的使用情况。使用weak_ptr的成员函数use_count()可以观测资源的引用计数，另一个成员函数expired()的功能等价于use_count()==0,但更快，表示被观测的资源 (也就是shared_ptr的管理的资源)已经不复存在。//放弃指针的控制权，返回裸指针，并将unique_ptr自身置为空。
C++智能指针 unique_ptr、shared_ptr和weak_ptr区别
qq_41979948的博客
03-21 835
C++智能指针是一种RAII（资源获取即初始化）的技术，用于管理动态分配的内存，并避免内存泄漏。C++智能指针包括三种类型：unique_ptr、shared_ptr和weak_ptr。它们之间的区别在于所有权的管理方式和内存的释放时间。unique_ptr是一种独占型指针，即同一时刻只能有一个unique_ptr指向一个对象。unique_ptr适用于需要管理单个对象的情况，当unique_ptr被销毁时，它所占用的内存也会随之被释放。
C++ 中的智能指针 unique_ptr 和 shared_ptr
将~军的博客
08-28 394
独占所有权，不允许复制，只能通过移动转移所有权。适用于独占资源管理。：共享所有权，通过引用计数管理资源，适用于多个对象共享资源的场景。：非所有权弱引用，防止循环引用，用于需要弱引用的场景，如观察者模式。：已废弃，建议使用代替。
C++智能指针之shared _ptr、weak_ptr、unique_ptr
king_weng的博客
12-15 792
一、class shared_ptr shared_ptr具有共享式拥有的概念。即多个shared_ptr可以指向相同的对象，该对象和其相关资源会在“最后一个引用被销毁”时释放。 1、shared_ptr的初始化： （1）直接使用初始化 shared_ptr<string> str(new string("name")); shared_ptr<strin...
C++ 智能指针unique_ptr、shared_ptr、weak_ptr详解（包含代码示例）
Warren++的博客
05-19 1182
C++ 智能指针unique_ptr、shared_ptr、weak_ptr详解（包含代码示例）
掌握C++智能指针：shared_ptr、unique_ptr 和 weak_ptr 详解
m0_72877724的博客
06-15 1023
它只支持移动语义，不支持拷贝语义，以此确保其唯一性。智能指针通过RAII（资源获取即初始化）机制，能更好地管理堆内存，减少上述问题的发生。C++11中引入了智能指针的概念，以便更好地管理堆内存。通过这些示例和解释，希望你能更清楚地理解和使用 C++ 智能指针，包括。多个智能指针可以共享同一个对象，该对象的生命周期由最后一个引用它的。是一种不控制对象生命周期的智能指针。的所有权只能通过移动语义转移，不支持拷贝。独占其指向的对象，即同一时刻只能有一个。管理的对象，但不会增加其引用计数。
C++智能指针（shared_ptr&&unique_ptr&&weak_ptr）
weixin_49962210的博客
05-21 579
循环引用问题通常发生在两个或更多的对象相互持有对方的智能指针，形成一个闭环，导致即使所有外部引用都消失，这些对象的引用计数也无法降为0，进而无法自动释放内存。内部维护一个引用计数，每次拷贝构造或赋值增加计数，对象被销毁时减少计数，计数归零时自动释放内存。实例，同时增加对象的引用计数，从而确保在接下来的使用过程中对象不会被意外释放。访问对象，就有可能遇到悬挂引用的问题，即引用指向的内存已经被释放。离开作用域或被重置时，对象会被自动删除，实现自动资源管理。管理的对象时，必须确保该对象仍然有效，即没有被销毁。
C++11新特性之智能指针(shared_ptr/unique_ptr/weak_ptr)
09-01
总的来说，C++11的智能指针提供了更安全、更易于管理内存的方式，减少了内存泄漏和悬挂指针的风险。`shared_ptr`适合需要多个智能指针共享同一对象的情况，`unique_ptr`适用于独占所有权的资源管理，而`weak_ptr`则...
C++ unique_ptr weak_ptr shared_ptr auto_ptr智能指针.doc
07-23
在 C++ 中，有四种智能指针：auto_ptr、unique_ptr、shared_ptr 和 weak_ptr，每种智能指针都有其特点和使用场景。 一、auto_ptr auto_ptr 是 C++98 中引入的智能指针，它可以自动释放动态分配的内存。但是，auto_...
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 889
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
c++primer第十三章 类继承
weixin_48442204的博客
10-01 946
编译器警告：代码的含义新定义的函数覆盖了原来的的函数，是的showperks（）不接受参数。简而言之，重新定义继承的方法并不是重载。如果在派生类中重新定义函数，将不是使用相同的函数特征标覆盖基类声明，而是隐藏同名的基类方法，不管参数特征标如何。这引出了两条经验规则:第一，如果重新定义继承的方法，应确保与原来的原型完全相同，但如果返回类型是基类引用或指针，则可以修改为指向派生类的引用或指针(这种例外是新出现的)。
[c语言]一句话讲清循环中break和continue的作用与区别
2303_77060768的博客
09-29 151
1.两者的作用break和contuinue都只能在循环中使用，都用来停止循环。​​​​​​​2.两者的区别break在循环中只要遇到break，就直接永久终止当前循环，开始执行当前循环之外的代码。在循环中只要遇到continue，就结束本次循环，继续进行下一次循环。
第 21 章 一条记录的多幅面孔——事务的隔离级别与 MVCC
weixin_45740473的博客
10-02 911
并发的事务在运行过程中会出现一些可能的引发一致性问题SQL 标准中有4种隔离级别版本链ReadView。
C++：图的最短路径问题
han2205277149的博客
10-04 715
最短路径问题是图的一个比较典型的应用问题。例如，给定某公路网的n个城市以及这些城市之间相通公路的距离，能否找到城市A到城市B之间一条距离最近的通路呢？如果将城市用顶点表示城市间的公路用边表示，公路的长度作为边的权值，这个问题就归结为在网图中求顶点A和顶点B的最短路径。
【C++】stack和queue的使用及注意事项
wangnaisheng的专栏
09-28 661
【C++】stack和queue的使用及注意事项
C - Separated Lunch
最新发布
m0_74304371的博客
10-05 214
C - Separated Lunch(KEYENCE Programming Contest 2024 (AtCoder Beginner Contest 374))
C++智能指针详解：unique_ptr, weak_ptr, shared_ptr, auto_ptr
"本文主要介绍了C++中的四种智能指针：auto_ptr、unique_ptr、shared_ptr和weak_ptr，包括它们的使用方式、工作机制以及可能存在的缺陷。智能指针是为了解决C++中动态内存管理和指针操作可能导致的问题，如内存泄漏...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

西笑生

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

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

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

打赏作者

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

抵扣说明：

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

余额充值