C++ Primer 学习笔记 第十九章 特殊工具与技术

最新推荐文章于 2023-05-13 18:31:51 发布
最新推荐文章于 2023-05-13 18:31:51 发布
阅读量971 收藏
点赞数
文章标签： c++ c语言 visual studio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/HELLOWORLD2424/article/details/123727158
版权
本文探讨了C++中的内存管理技术，包括自定义new和delete操作符、显式析构函数调用、dynamic_cast的使用及RTTI类型识别等功能。此外，还介绍了枚举类型、数据成员指针的应用、函数成员的使用、通过函数表实现多态行为的方法，以及如何将string成员函数转换为可调用对象。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

728

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
#include <bitset>
#include <regex>
#include <random>
#include <ctime>
#include <iomanip>
#include <exception>
using namespace std;


void *operator new(size_t size){
    if(void *mem= malloc(size)){
        return mem;
    } else{
        throw bad_alloc();
    }
}

void operator delete(void *mem) noexcept{
    free(mem);
}

int main(int argc,char** argv){
    string *sp = new string("dfs");
    delete sp;

    return 0;
}

19.1

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
#include <bitset>
#include <regex>
#include <random>
#include <ctime>
#include <iomanip>
#include <exception>
using namespace std;


void *operator new(std::size_t n){
    cout << "new(size_t)" << endl;
    if (void *mem= malloc(n))
        return mem;
    else
        throw bad_alloc();
}

void operator delete(void *mem) noexcept{
    cout << "delete(void*)" << endl;
    free(mem);
}


int main(int argc,char** argv){
    using namespace std;
    int *a = new int(486);
    cout << a << " " << *a << endl;
    delete a;
    return 0;
}

729 显式的析构函数调用

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
#include <bitset>
#include <regex>
#include <random>
#include <ctime>
#include <iomanip>
#include <exception>
using namespace std;



int main(int argc,char** argv){
    string *sp = new string("a value");
    sp->~string();

    return 0;
}

731 dynamic_cast运算符

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
#include <bitset>
#include <regex>
#include <random>
#include <ctime>
#include <iomanip>
#include <exception>
using namespace std;


class Base{
public:
    virtual void fuc(){};

};

class Derived:public Base{
public:


};



int main(int argc,char** argv){

    Base *bp = new Derived;

    if (Derived *p = dynamic_cast<Derived*>(bp)){
        cout << "Base* -> Derived*" << endl;
    } else{
        cout << "error" << endl;
    }

    Derived d;
    const Base &b1 = d;
    const Derived &d1 = dynamic_cast<const Derived&>(b1);

    return 0;
}

19.5

    A *pa = new C;
    C &c = dynamic_cast<C&>(*pa);

733 使用RTTI

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
#include <bitset>
#include <regex>
#include <random>
#include <ctime>
#include <iomanip>
#include <exception>
using namespace std;


class Base{
    friend bool operator=(const Base&, const Base&);

public:
protected:
    virtual bool equal(const Base&) const;
};

class Derived:public Base{
public:
protected:
    bool equal(const Base&) const;
};

bool operator==(const Base &lhs, const Base &rhs){
    return typeid(lhs)==typeid(rhs) && lhs.equal(rhs);
}


int main(int argc,char** argv){
    Derived *dp = new Derived;
    Base *bp = dp;

    if (typeid(*bp)== typeid(*dp)){
        cout << "*bp == *dp" << endl; // *bp == *dp
    }
    if (typeid(*bp) == typeid(Derived)){
        cout << "*bp==Derived" << endl; // "*bp==Derived"
    }



    return 0;
}

735

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
#include <bitset>
#include <regex>
#include <random>
#include <ctime>
#include <iomanip>
#include <exception>
using namespace std;


class Base{
    friend bool operator=(const Base&, const Base&);

public:
protected:
    virtual bool equal(const Base&) const;
};

class Derived:public Base{
public:
protected:
    bool equal(const Base&) const;
};

bool operator==(const Base &lhs, const Base &rhs){
    return typeid(lhs)==typeid(rhs) && lhs.equal(rhs);
}

bool Derived::equal(const Base &rhs) const {
    auto r = dynamic_cast<const Derived&>(rhs);
}

bool Base::equal(const Base &rhs) const {

}



int main(int argc,char** argv){
    Derived *dp = new Derived;
    Base *bp = dp;

    if (typeid(*bp)== typeid(*dp)){
        cout << "*bp == *dp" << endl; // *bp == *dp
    }
    if (typeid(*bp) == typeid(Derived)){
        cout << "*bp==Derived" << endl; // "*bp==Derived"
    }



    return 0;
}

typeid使用方法

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
#include <bitset>
#include <regex>
#include <random>
#include <ctime>
#include <iomanip>
#include <exception>
using namespace std;

class Derived{

};


int main(int argc,char** argv){
    int arr[10];
    cout << typeid(42).name() <<endl; // int

    Derived d;
    cout << typeid(d).name() << endl; // class Derived

    return 0;
}

typeid

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
#include <bitset>
#include <regex>
#include <random>
#include <ctime>
#include <iomanip>
#include <exception>
using namespace std;

class Derived{

};


int main(int argc,char** argv){
    int arr[10];
    cout << typeid(42).name() <<endl; // int

    Derived d;
    cout << typeid(d).name() << endl; // class Derived


    return 0;
}

738 枚举类型

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
#include <bitset>
#include <regex>
#include <random>
#include <ctime>
#include <iomanip>
#include <exception>
using namespace std;


int main(int argc,char** argv){
    enum color {red='a', yellow, green};
    // enum stoplight {red, yellow, green}; error redefinition
    enum class peppers {red, yellow, green};
    color eyes = green;
    cout << typeid(eyes).name() << endl;
    color hair = color::red;
    peppers p2 = peppers::red;
    cout << typeid(peppers).name() << endl;

    enum class intTypes{
        charTyp=8, shortTyp=16, intTyp=16,
        longTyp=32, long_longTyp=64
    };

    constexpr intTypes charbits = intTypes::charTyp;
//    open_modes om = 2;
//    om = open_modes::inputs;
    int j = color::red;
    cout << j << endl; // 97 a的ASCII码

    // 指定enum的大小
    enum intValues:unsigned long long{
        charTyp=255, shortTyp=63335
    };

    enum class intValues1:int;
//    enum intValues1:long;




    return 0;
}

739

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
#include <bitset>
#include <regex>
#include <random>
#include <ctime>
#include <iomanip>
#include <exception>
using namespace std;


enum Tokens {INLINE=128, VIRTUAL=129};
void ff(Tokens);
void ff(int);

void newf(unsigned char c){
    cout << c << endl;
};
void newf(int);



int main(int argc,char** argv){
    Tokens curTok = INLINE;
    ff(128);
    ff(INLINE);
    ff(curTok);

    unsigned char uc = VIRTUAL;
//    newf(VIRTUAL);
    newf(uc);
    return 0;
}

740 数据成员指针

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
#include <bitset>
#include <regex>
#include <random>
#include <ctime>
#include <iomanip>
#include <exception>
using namespace std;


class Screen{
public:
    typedef std:: string::size_type pos;
    char get_cursor() const {return contents[cursor];}
    char get() const;
    char get(pos ht, pos wd) const;

    std::string contents;
    pos cursor;
    pos height, width;
    
};


int main(int argc,char** argv){
    // screen类指针
    const Screen* pi;
    // 指向screen类string成员
    const string Screen::*pdata;
    pdata = &Screen::contents;
    // 等价于上面
    auto pdata1 = &Screen::contents;

    Screen myScreen, *pScreen = &myScreen;
    // 解引用获得成员
    auto s = myScreen.*pdata;
    s = pScreen->*pdata;
    return 0;
}

741 使用一个成员函数来外露类里面的数据

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
#include <bitset>
#include <regex>
#include <random>
#include <ctime>
#include <iomanip>
#include <exception>
using namespace std;


class Screen{
public:
    typedef std:: string::size_type pos;
    char get_cursor() const {return contents[cursor];}
    char get() const;
    char get(pos ht, pos wd) const;

    static const std::string Screen::*data(){
        return &Screen::contents;
    };

private:
    std::string contents = "hello";
    pos cursor;
    pos height, width;

};


int main(int argc,char** argv){
    Screen s;
    const string Screen::*data = Screen::data();
    cout << s.*data << endl;
    
    return 0;
}

743 函数成员

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
#include <bitset>
#include <regex>
#include <random>
#include <ctime>
#include <iomanip>
#include <exception>
using namespace std;


class Screen{
public:
    typedef std:: string::size_type pos;
    char get_cursor() const {return contents[cursor];}
    char get() const;
    char get(pos ht, pos wd) const{
        return 'l';
    };
    static const std::string Screen::*data(){
        return &Screen::contents;
    };

private:
    std::string contents = "hello";
    pos cursor;
    pos height, width;

};

using Action = char (Screen::*)(Screen::pos, Screen::pos) const;

Screen& action(Screen& s, Action=&Screen::get){
    return s;
}

int main(int argc,char** argv){
    // 定义
    char (Screen::*pmf2)(Screen::pos, Screen::pos) const;
    pmf2 = &Screen::get;
    // 调用
    Screen myScreen, *pScreen = &myScreen;
    char c1 = (pScreen->*pmf2)(1,  2);
    cout << c1 << endl;
    
    
    Action get = &Screen::get;
    
    action(myScreen);
    action(myScreen, get);
    action(myScreen, &Screen::get);

    return 0;
    
}

744 函数表

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
#include <bitset>
#include <regex>
#include <random>
#include <ctime>
#include <iomanip>
#include <exception>
using namespace std;


class Screen{
public:
    using Action = Screen& (Screen::*)();
    enum Directions {HOME, FORWARD, BACK, UP, DOWN};
    Screen& move(Directions);
    Screen& home();
    Screen& forward();
    Screen& back();
    Screen& up(){
        cout <<"up" << endl;
        return this->down();
    };
    Screen& down();

private:
    static Action Menu[];
};

// 函数表
Screen::Action Screen::Menu[] = {
        &Screen::home,
        &Screen::forward,
        &Screen::back,
        &Screen::up,
        &Screen::down,
};

Screen& Screen::move(Directions cm) {
    return (this->*Menu[cm])();
}



int main(int argc,char** argv){
    Screen myScreen;
    myScreen.move(Screen::UP);
    return 0;
}

746 将string的成员函数转换成可调用对象

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
#include <bitset>
#include <regex>
#include <random>
#include <ctime>
#include <iomanip>
#include <exception>
using namespace std;




int main(int argc,char** argv){
    auto f = mem_fn(&string::empty);
    string s = "";
    cout << f(s) << endl; // 1

    auto f2 = bind(&string::empty, placeholders::_1);
    cout << f2(s) << endl; // 1

    
    return 0;

}

749 union的定义与赋值

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
#include <bitset>
#include <regex>
#include <random>
#include <ctime>
#include <iomanip>
#include <exception>
using namespace std;


union Token{
    char cval;
    int ival;
    double dval;
};


int main(int argc,char** argv){

    Token first_token = {'a'};
    Token last_token;
    Token *pt = new Token;

    last_token.cval = 'z';
    last_token.ival = 'a';
    pt->ival = 42;


    return 0;

}

匿名的union

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
#include <bitset>
#include <regex>
#include <random>
#include <ctime>
#include <iomanip>
#include <exception>
using namespace std;




int main(int argc,char** argv){
    union {
        char cval;
        int ival;
        double dval;
    };

    cval = 'z';
    ival = 'a';
    ival = 42;
    cout << ival << endl;


    return 0;

}

753 使用类管理union

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
#include <bitset>
#include <regex>
#include <random>
#include <ctime>
#include <iomanip>
#include <exception>
using namespace std;


class Token{
public:
    Token():tok(INT), ival(0) {}
    Token(const Token &t):tok(t.tok){copyUnion(t);}
    Token &operator=(const Token&);
    ~Token(){if (tok==STR) sval.~string();}
    Token &operator=(const std::string&);
    Token &operator=(char);
    Token &operator=(int);
    Token &operator=(double);
private:
    enum {INT, CHAR, DBL, STR} tok;
    union {
        char cval;
        int ival;
        double dval;
        std::string sval;
    };
    void copyUnion(const Token&);
};


Token &Token::operator=(int i) {
    if (tok==STR) sval.~string();
    ival = i;
    tok = INT;
    return *this;
}

Token &Token::operator=(double d) {
    if (tok==STR) sval.~string();
    dval = d;
    tok = DBL;
    return *this;
}


Token &Token::operator=(char c){
    if (tok==STR) sval.~string();
    cval = c;
    tok = CHAR;
    return *this;
}

Token &Token::operator=(const std::string &s) {
    if (tok==STR)
        sval = s;
    else
        new(&sval) string(s);
    tok = STR;
    return *this;
}

void Token::copyUnion(const Token &t) {
    switch (t.tok){
        case Token::INT:ival=t.ival; break;
        case Token::CHAR:cval=t.cval; break;
        case Token::DBL:dval=t.dval; break;
        case Token::STR:new(&sval) string(t.sval); break;
    }
}

Token &Token::operator=(const Token &t) {
    if (tok==STR && t.tok!=STR) sval.~string();
    if (tok==STR && t.tok==STR)
        sval = t.sval;
    else
        copyUnion(t);
    tok = t.tok;
    return *this;
}



int main(int argc,char** argv){

    Token t1, t2;
    t1 = "hello";
    t2 = t1;
    Token t3(t1);
    return 0;

}

局部类

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
#include <bitset>
#include <regex>
#include <random>
#include <ctime>
#include <iomanip>
#include <exception>
using namespace std;


int a, val;
void foo(int val){
    static int si;
    enum Loc{a=1024, b};
    struct Bar{
        Loc locVal;
        int barVal;
        void fooBar(Loc l=a){
//            barVal = val;
            barVal = ::val;
            barVal = si;
            locVal = b;
        }
    };
}


int main(int argc,char** argv){

    foo(32);

    return 0;

}
HELLOWORLD2424
关注
C++ Primer（5e）第11章习题
weixin_42916038的博客
03-31 203
11.1 map下标是关键字，不必是整数，而vector下标是整数；从map中提取一个元素，会得到一个pair类型对象。 11.5 当定义一个map时，必须既指明关键字类型又指明值类型；而定义一个set时，只需指定关键字类型。 11.6 set不能重复，而list可以重复 11.8 #include<iostream> #include<string> #include&l...
C++ Primer 第五版 ——《第十五章 》面向对象程序设计 （多态与继承）学习笔记
TAOTAO
02-16 1737
目录 OPP：概述 定义基类 定义派生类 派生类中的虚函数 、override 关键字（530P） 派生类到基类的类型转换 （530P） 派生类的构造函数 （531P） 在派生类中使用继承其基类的成员 （531P） 继承与静态成员 （ 532P ） 派生类的声明需要注意的地方 （532P） 被用作基类的类需要注意的地方 （533P） 通过 final 来 禁止类被继承 类型...
C++小练习
weixin_42542629的博客
06-28 123
#include <iostream> #include <string> #include <vector> #include <algorithm> using namespace std; class Box { private: double m_height; double m_breadth; double m_length; public: void setHeight(double height) { m_height = h
c++ primer第十章部分练习
ss15706299023的博客
12-18 358
练习10.9 #include<iostream> #include<vector> #include<algorithm> #include<string> using namespace std; int main() { using namespace std; void elimDups(vector<string> &amp...
C++ Primer 学习笔记 第七章 类
HELLOWORLD2424的博客
07-23 929
233 定义类 #include<iostream> #include<vector> #include<string> using namespace std; struct Sales_data { string bookNo; unsigned units_sold = 0; double revenue = 0; string isbn() const { return bookNo; }; Sales_data& combi
算法基础课2021-8-21
supreme567的博客
08-22 516
#include <iostream> #include <cstring> #include <algorithm> using namespace std; int n; int st[10000]; int vis[10]; typedef pair<int, int> PII; PII way[10]; int path[10][10]; int c[10][10]; void dfs(int x){ if(x>n){
C++ Primer第五版 第十三章---练习题答案（学习笔记）
m0_51248838的博客
09-26 790
1.
C++ Primer+第四版学习笔记：核心概念与关键点解析
"C++Primer+中文版(第四版)学习笔记" 这篇学习笔记涵盖了C++编程语言的多个核心概念和重要知识点，旨在帮助读者深入理解C++ Primer+第四版的内容。以下是笔记中的主要学习点： 1. C++程序的起点是main函数，它是每...
C++ Primer 第四版学习笔记：核心概念与关键点解析
"C++ Primer 中文版（第四版）学习笔记包含了C++编程的基础知识，如程序结构...以上知识点仅涵盖部分C++ Primer学习笔记中的内容，完整的笔记将更深入地探讨每个主题，提供示例代码和解释，帮助学习者逐步精通C++编程。
《C Primer Plus》学习笔记—第14章
chaofeng426的博客
03-16 896
结构，初始化结构，结构成员，访问结构； 结构数组，内存，嵌套结构； 结构指针，传递结构信息，malloc()函数分配空间； 复合字面量； 结构内容存到文件中； 成员运算符.和结构运算符->； 枚举类型，enum； typedef； 函数指针
C++ Primer学习随便——第20章iostream
aapx76947的博客
02-18 272
头文件 <iostream> 一. 对终端的操作 相关头文件#include <iostream> 1. 输入istream 2. 输出ostream 3. iostream继承istream和ostream 所以它具有输入输出功能。 为了方便这个库定义了下列三个标准流对象： 1. cin 代表标准输入istream类对象一般地cin使我们能够从用户终端读入数据...
C++ Primer习题解答 Chapter11
cmiao-me
02-26 377
11-3 #include<iostream> #include<vector> #include<string> #include<cctype> #include<iterator> #include<stdexcept> #include<map> #include<cctype> #includ...
《C++大学教程》学习笔记（十四）
qq_32925781的博客
02-19 672
《C++大学教程》学习笔记（十四） 为了在C++ 中执行文件处理，必须包含头文件&lt; iostream &gt;和&lt; fstream &gt;。C++ 没有在文件上强加任何结构，所以程序员必须自己设计文件结构来满足应用程序的需要。 本章主要讨论了 顺序文件 和 随机存取文件 。 1.顺序文件 1.1创建并打开文件 要想创建并打开一个文件，可以通过下面这句语句： ofstream...
C++ Primer 学习笔记 第十八章 用于大型程序的工具
HELLOWORLD2424的博客
03-25 306
18.5 #include <iostream> #include <vector> #include <string> #include <list> #include <iterator> #include <memory> #include <fstream> #include <algorithm> #include <functional> #include <map> #inc
C++语法学习笔记七十三：算法概述、内部处理、使用范例
哲学天空的博客
08-31 309
实例代码： #include <iostream> #include <vector> #include <algorithm> #include <map> #include <list> #include <unordered_set> using namespace std; namespace _nmsp1 { //一：算法概述：理解为函数模板(全局函数/全局函数模板)； //比如：查找，排序等等；数十甚至上百个算法；
C++标准库头文件解释
yjj1123456的博客
05-13 1万+
是C++标准库中的头文件，它提供了许多用于处理字符串的函数和操作。头文件，我们可以使用上述函数和操作来处理字符串，执行各种字符串相关的任务，如复制、连接、比较、查找等。是C++标准库中的头文件，它提供了许多常用的算法函数，用于对数据进行排序、查找、变换和操作等操作。头文件，我们可以使用上述函数和操作来对数据进行各种常见的算法处理，如排序、查找、统计、变换等。是C++编程语言中的一个预处理指令，用于包含 C-style 字符串处理函数的头文件。是C++标准库中的头文件，它包含了输入输出流的定义，包括了。
大一下C++学习记录-C Primer Plus版本
C___137的博客
03-17 1198
依据：《C Prime Plus》
cpp primer 习题 11.16
在水一方
01-10 158
#include &lt;iostream&gt; #include &lt;cstdlib&gt; #include &lt;fstream&gt; #include &lt;string&gt; #include &lt;iterator&gt; #include &lt;algorithm&gt; using namespace std; int main() { str...
c++容器vector使用方法总结
weixin_34259559的博客
04-19 317
for(vector<string>::iterator i=a.begin();i!=a.end();i++) 要使用迭代器 iterator使用vexctor容器必须包含”vector”头文件,然后创建一个vector容器对象(方式很多种,这里就不一一介绍了,具体看实例 :D),然后我们对vector容器初始化赋值(可以使用push_back在容器尾端加入元素),如果我们要对vec...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值