C++核心编程（三）

最新推荐文章于 2022-12-19 22:36:14 发布
最新推荐文章于 2022-12-19 22:36:14 发布
阅读量98 收藏
点赞数
分类专栏： C++编程基础 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34963430/article/details/115906296
版权

1. 运算符重载

概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型

1.1 加号运算符重载

作用：实现两个自定义数据类型相加的运算

class Person
{
public:
	//成员函数重载+号
	Person operator+ (Person &p)
	{
		Person temp;
		temp.m_A = this->m_A + p.m_A;
		temp.m_B = this->m_B + p.m_B;
		return temp;
	}
	 
	int m_A;
	int m_B;
	
}
//全局函数重载+号
Person operator+(Person &p1 , Person &p2)
{
	Person temp;
	temp.m_A = p1.m_A + p2.m_A;
	temp.m_B = p1.m_B + p2.m_B;
	return temp;	
}
//函数重载版本
Person operator+(Person &p1 , int num)
{
	Person temp;
	temp.m_A = p1.m_A + num;
	temp.m_B = p1.m_B + num;
	return temp;
}

void test01()
{
	Person p1;
	p1.m_A = 10;
	p1.m_B = 10;
	Person p2;
	p2.m_A = 10;
	p2.m_B = 10;
	//成员函数本质调用
	//Person p3 = p1.operator+(p2);
	//全局函数本质调用
	//Person p3 = operator+(p1,p2);
	Person p3 = p1 + p2;	//简化形式
	//运算符重载也可以发生函数重载
	Person p4 = p1 + 10;
	cout << "p3的m_A" << p3.m_A << endl;
	cout << "p3的m_B" << p3.m_B << endl;
	cout << "p4的m_A" << p4.m_A << endl;
	cout << "p4的m_B" << p4.m_B << endl;
}

int main()
{
	test01();
	system("pause");
	return 0;
}

总结：

  • 对于内置的数据类型的表达式的运算符是不可能改变的
  • 不要滥用运算符重载

1.2 左移运算符重载

作用：可以输出自定义数据类型

class Person
{
	friend ostream & operator<<(ostream &cout , Person &p);
	
public:
	Person(int a , int b)
	{
		m_A = a;
		m_B = b;
	}

	//利用成员函数重载 左移运算符
	//p.operator<<(cout)简化形式p<<cout
	//根据这个简化形式，一般不会利用成员函数重载<<运算符 ，因为无法实现cout在左侧
	void operator<<( cout )
	{
	}
private:
	int m_A;
	int m_B;
};
//只能利用全局函数重载左移运算符
ostream & operator<<(ostream &cout , Person &p)	//链式编程，可以无限往后追加
{
	cout << "m_A = " << p.m_A << "m_B = " << p.m_B;
	return cout;
}

void test01()
{
	Person p(10 , 10);

	cout << p <<"Hello World" << endl;
}

int main()
{
	test01();
	system("pause");
	return 0;
}

1.3 递增运算符重载

class MyInteger
{
	friend ostream& operator<<(ostream &cout ,MyInteger myint );
public:
	MyInteger()
	{
		m_Num = 0;
	}
	
	//重载前置++运算符
	MyInteger& operator++()	//如果返回类型 是值返回，则会将返回结果拷贝一份，所以链式编程返回引用，这样就一直对一个数据进行操作
	{
		m_Num++;
		//将自身做返回
		return *this;
	}
	
	//重载后置++运算符
	//这个int代表占位参数，可以用于区分前置和后置递增
	MyInteger operator++(int)	//后置递增返回值，因为如果返回引用，返回的是一个局部对象，局部对象在函数操作结束后就释放了
	{
		//先 记录当时结果
		MyInteger temp = *this;
		//后 递增
		m_Num++;
		//最后将记录结果做返回
		return temp;
	}
private:
	int m_Num;
};
//重载左运算符(只能全局)
ostream& operator<<(ostream &cout ,MyInteger myint )
{
	cout << myint.m_Num;
	return cout;
}

void test01()
{
	MyInteger myint;
	cout << ++(++myint) <<endl;
	cout << myint << endl;
}

void test02()
{
	MyInteger myint;
	cout << myint++ <<endl;
	cout << myint << endl;
}
int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}

1.4 赋值运算符重载

C++编译器至少给一个类添加4个函数

  • 默认构造函数（无参，函数体为空）
  • 默认析构函数（无参，函数体为空）
  • 默认拷贝构造函数，对属性进行值拷贝
  • 赋值运算符operator=，对属性进行值拷贝

如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题

class Person
{
public:
	Person(int age)
	{
		m_Age = new int(age);
	}
	~Person()
	{
		if(m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;	
		}
	}
	//重载运算符
	Person & operator=(Person &p)
	{
		//编译器提供浅拷贝
		m_Age = p.m_Age;
		
		//应该先判断是否有属性在堆区，如果有先释放干净，然后再深拷贝
		if(m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
		m_Age = new int(*p.m_Age)
		return *this;
	}

	int *m_Age;
};

void test01()
{
	Person p1(18);
	Person p2(20);
	Person p3(30);
	p2 = p1;	//赋值运算，如果不用深拷贝会造成堆区内存重复释放
	p3 = p2 = p1;	//链式编程
	cout << *p1.m_Age << endl;
	cout << *p2.m_Age << endl;
}

int main()
{
	test01();
	system("pause");
	return 0;
}

1.5 关系运算符重载

class Person
{
public:
	Person(string name , int age)
	{
		m_Name = name;
		m_Age = age;
	}
	//重载==运算符
	bool operator==(Person &p)
	{
		if(this->m_Name == p.m_Name && this->m_Age == p.m_Age)
		{
			return true;
		}
		return false;
	}
	bool operator!=(Person &p)
	{
		if(this->m_Name != p.m_Name || this->m_Age != p.m_Age)
		{
			return true;
		}
		return false;
	}

	string m_Name;
	int m_Age;
};
void test01()
{
	Person p1("Tom" , 18);
	Person p2("Jerry" , 18);
	if(p1 == p2)
	{
		cout << "p1 和 p2是相等的" <<endl;
	}
	else
	{
		cout << "p1 和 p2是不相等的" <<endl;
	}

	if(p1 != p2)
	{
		cout << "p1 和 p2是不相等的" <<endl;
	}
	else
	{
		cout << "p1 和 p2是相等的" <<endl;
	}
}

int main()
{
	test01();
	system("pause");
	return 0;
}

1.6 函数调用运算符重载

  • 函数调用运算符（）也可以重载
  • 由于重载后使用的方式非常像函数的调用，因此称为仿函数
  • 仿函数没有固定写法，非常灵活
class MyPrint
{
public:
	//重载函数调用运算符
	void operator()(string test)
	{
		cout << test << endl;
	}

};

void MyPrint02(string test)
{
	cout << test << endl;
}

void test01()
{
	MyPrint myPrint;
	myPrint("Hello World");	//由于使用起来非常类似函数调用，因此叫仿函数
	MyPrint02("Hello World");
}
//仿函数非常灵活，没有固定写法
//加法类
class MyAdd
{

public:
	int operator()(int num1 , int num2)
	{
		return num1 + num2;
	}
};

void test02()
{
	MyAdd myAdd;
	int ret = myAdd(100 , 100);
	cout << ret << endl;

	//匿名函数对象
	cout << MyAdd()(100 , 100) << endl;
}

int main()
{
	test01();
	system("pause");
	return 0;
}

2. 继承

我们发现，定义某些类的时候，下级别的成员除了拥有上一级的共性，还有自己的特性。

2.1 继承的基本语法

例如我们看很多网站都有公共的头部公共的底部，只有中心内容不同。接下来我们分别利用普通写法和继承写法来实现网页中的内容，看一下继承的意义以及好处

//普通实现页面
//Java页面类
class Java
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...(公共头部)" << endl;
	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
	}
	void left()
	{
		cout << "Java , Python , C++ ...(公共分类列表)" << endl;
	}
	void content()
	{
		cout << "Java学科视频" << endl; 
	}
};
//Python和C++页面类
//除了content不一样，其余的全复制(重复代码太多)
void test01()
{
	cout << "Java下载视频页面如下：" << endl;
	Java ja;
	ja.header();
	ja.footer();
	ja.left();
	ja.content();
	cout << "---------------------------------" <<endl;
	/*
	cout << "Python下载视频页面如下：" << endl;
	Python py;
	py.header();
	py.footer();
	py.left();
	py.content();
	cout << "---------------------------------" <<endl;
	cout << "C++下载视频页面如下：" << endl;
	Cpp c;
	c.header();
	c.footer();
	c.left();
	c.content();	
	*/
}

//继承实现页面
class BasePage
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...(公共头部)" << endl;
	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
	}
	void left()
	{
		cout << "Java , Python , C++ ...(公共分类列表)" << endl;
	}
};
//JAVA
class Java: public BasePage
{
public:
	void content()
	{
		cout << "Java学科视频" << endl; 
	}
};
//Python
class Python: public BasePage
{
public:
	void content()
	{
		cout << "Python学科视频" << endl; 
	}
};
//C++
class Cpp: public BasePage
{
public:
	void content()
	{
		cout << "C++学科视频" << endl; 
	}
};
  • 继承的好处：减少重复的代码
  • 语法：class 子类 : 继承方式 父类
  • 子类 也称为 派生类
  • 父类 也称为 基类

2.2 继承方式

  • 公共继承：父类中公共到子类还是公共，保护到子类还是保护
  • 保护继承：父类中公共和保护到子类都是保护
  • 私有继承：父类中公共和保护到子类都是私有
class Base1
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};

class Son1 :public Base1
{
public:
	void func()
	{
		m_A = 10;	//父类中公共到子类还是公共
		m_B = 10;	//父类中保护到子类还是保护
		m_C= 10；	//报错，父类中私有，子类访问不到
	}
};
class Base2
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son2 :protected Base2
{
	public:
	void func()
	{
		m_A = 10;	//父类中公共到子类变成保护
		m_B = 10;	//父类中保护到子类还是保护
		m_C= 10；	//报错，父类中私有，子类访问不到
	}
};

class Base3
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son3 :private Base3
{
	public:
	void func()
	{
		m_A = 10;	//父类中公共到子类变成私有
		m_B = 10;	//父类中保护到子类变成私有
		m_C= 10；	//报错，父类中私有，子类访问不到
	}
};

class GrandSon3 :public Son3
{
public:
	void func()
	{
		m_A = 10;	//报错，父类中私有，子类访问不到
		m_B = 10;	//报错，父类中私有，子类访问不到
		m_C= 10；	//报错，父类中私有，子类访问不到
	}
};

void test01()
{
	Son1 s1;
	s1.m_A = 100;
	s1.m_B = 100;	//报错，保护权限类外访问不到
}

void test02()
{
	Son2 s2;
	s1.m_A = 100; //报错，保护权限类外访问不到	
}

void test03()
{
	Son3 s3;
	s1.m_A = 100; //报错，保护权限类外访问不到	
}

2.3 继承中的对象模型

class Base
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};

class Son : public Base
{
public:
	int m_D;
};
//利用开发人员命令提示工具查看对象模型
//跳转盘符	F：
//跳转文件路径	cd	具体路径下
//查看命令
//cl /d1 reportSingleClassLayout类名 "文件名"
void test01()
{
	cout << sizeof(Son) << endl;	//16
	//父类中所有非静态成员属性都会被子类继承下去
	//父类中私有成员属性  是被编译器给隐藏了，因此是访问不到，但是确实被继承下去了
}
int main()
{
	test01();
	system("pause");
	return 0;
}

2.4 继承中构造和析构顺序

子类继承父类后，当创建子类对象，也会调用父类的构造函数，那么父类和子类的构造和析构顺序谁先谁后？

class Base
{
public:
	Base()
	{
		cout << "Base的构造函数" << endl;
	}
	~Base()
	{
		cout << "Base的析构函数" << endl;
	}
};

class Son : public Base
{
public:
	Son()
	{
		cout << "Son的构造函数" << endl;
	}
	~Son()
	{
		cout << "Son的析构函数" << endl;
	}
};

test01()
{
	Son s; //先构造父类再构造子类，先析构子类再析构父类
}
int main()
{
	test01();
	system("pause");
	return 0;
}

2.5 继承同名成员处理方式

  • 访问子类同名成员，直接访问即可
  • 访问父类同名成员，需要加作用域
class Base
{
public:
	Base()
	{
		m_A = 100;
	}

	void func()
	{
		cout << "Base --func()调用" << endl;
	}

	void func(int a)
	{
		cout << "Base --func(int a)调用" << endl;
	}

	int m_A;
}

class Son : public Base
{
public:
	Son()
	{
		m_A = 200;
	}

	void func()
	{
		cout << "Son --func()调用" << endl;
	}
	
	int m_A;
}

void test01()
{
	Son s;
	cout << " Son  m_A = " << s.m_A <<endl;			//200
	cout << " Base  m_A = " << s.Base::m_A <<endl;
	
}

void test02()
{
	Son s;
	s.func();	//子类
	s.Base::func();		
	s.func(100);	//报错，如果子类出现和父类同名的成员函数，子类的同名成员函数会隐藏掉父类中所有的同名成员函数
	s.Base::func(100);	//加了作用域，正确
}

int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}

总结：

  • 子类对象可以直接访问到子类中同名成员
  • 子类对象加作用域可以访问到父类同名成员
  • 当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数

2.6 继承同名静态成员处理方式

  • 访问子类同名成员，直接访问即可
  • 访问父类同名成员，需要加作用域
class Base
{
public:
	static int m_A;
	static void func()
	{
		cout << "Base static void func()" << endl;
	}
};
int Base::m_A = 100;	//类内声明，类外初始化

class Son : public Base
{
public:
	static int m_A;
	static void func()
	{
		cout << "Son static void func()" << endl;
	}
};
int Son::m_A = 200;

void test01()
{
	//通过对象访问
	Son s;
	cout << "son  m_A = " << s.m_A << endl;
	cout << "Base m_A = " << s.Base::m_A << endl;	
	//通过类名
	cout << "通过类名访问 son m_A" << Son::m_A << endl;
	//第一个:: 代表通过类名方式访问   第二个::代表访问父类作用域下
	cout << "通过类名访问 base m_A" << Son::Base::m_A << endl;
}

void test02()
{
	Son s;
	s.func();
	s.Base:func();

	Son::func();
	Son::Base::func();
}

int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}

2.7 多继承语法

C++允许一个类继承多个类
语法：class 子类 : 继承方式 父类1 , 继承方式 父类2 ...
多继承可能会引发父类中有同名成员出现，需要加作用域区分
C++实际开发中不建议用多继承

class Base1
{
public:
	Base1()
	{
		m_A = 100;
	}
	int m_A;
};
class Base2
{
public:
	Base2()
	{
		m_A = 200;
	}
	int m_A ;
};
 
class Son :public Base1 , public Base2
{
public:
	Son()
	{
		m_C = 300;
		m_D = 400;
	}
	int m_C;
	int m_D;
};

void test01()
{
	Son s;
	cout << "sizeof Son = " << sizeof(Son) << endl;		//16
	//当父类中出现同名成员，需要加作用域
	cout << "Base1 m_A = " << s.Base1::m_A << endl;
	cout << "Base2 m_A = " << s.Base2::m_A << endl;
}

int main()
{
	test01();
	system("pause");
	return 0;
}

2.8 菱形继承

概念：

  • 两个派生类继承同一个基类
  • 又有某个类同时继承这两个派生类
  • 这种继承称为菱形继承，或者钻石继承

带来的问题：

  • 羊继承了动物的数据，驼也继承了动物的数据，当羊驼使用数据时，就会产生二义性
  • 羊驼继承自动物的数据继承了两份，其实只需要一份
class Animal
{
public:
	int m_Age;
};
//利用虚继承 解决菱形继承的问题
//在继承之前加上关键字virtual 
//Animal类称为 虚基类
class Sheep :virtual public Animal
{
};
class Tuo : virtual public Animal
{
};
class SheepTuo : public Sheep , public Tuo{};

void test01()
{
	SheepTuo st;
	st.Sheep::m_Age = 18;
	st.Tuo::m_Age = 28;
	//当菱形继承，两个父类拥有相同数据，需要加以作用域区分
	cout<< "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
	cout<< "st.Tuo::m_Age = " << st.Tuo::m_Age << endl;
	cout<< "st.m_Age = " << st.m_Age << endl;
	//这份数据我们知道，只有一份就可以，菱形继承导致数据有两份，资源浪费
}

int main()
{
	test01();
	system("pause");
	return 0;
}
太卷了
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++ 继承与重载
Economic_shark的博客
02-03 797
继承概述 1: has-a模式: 一个对象包含另外的一个对象，那么这个叫做has-a模式,汽车有车轮对象; 2: is-a模式: 比如我们编写了一个猫的对象，后面我们要开发一个猫的特例, 波斯猫; 波斯猫 is a 猫; 3: has-a的模式我们可以通过类包含其他的类来实现; 4: is-a模式: c++有继承机制，来实现; 5: 波斯猫 is a 猫，所以编写波斯猫代码的时
C++ 覆盖方法和重载方法
Roninzhz的博客
11-29 296
/* 关于从基类继承来的方法和属性的保护： class Pig:public Animal{....} C++不仅允许你对在类里定义的方法和属性实施访问控制， 还允许你控制子类可以访问基类里的那些方法和属性 public: 是在告诉编译器： 继承的方法和属性的访问级别不发生任何改变 public 仍可以被所有代码访问 protected 只能由基类的子类访问 private 只能由基类本身访问 protected: 把基类的访问级别改为protected 如果原来是pu
[c++基础]运算符重载，共有数据保护，静态成员
qq_26304333的博客
03-21 564
1.    运算符重载 一般情况下，单目运算符最好重载为类的成员函数；双目运算符则最好重载为类的友元函数。 当运算符重载为类的成员函数时，函数的参数个数比原来的操作个数要少一个；当重载为类的友元函数时，参数个数与原操作数个数相同。 2.   共用数据的保护 （1）常对象（为了防止成员函数修改常对象中数据成员的值） 类名 const  对象名[（实参
「地表最强」C++核心编程（八）类和对象--运算符重载
B_White的博客
12-19 232
C++运算符重载
C++学习笔记（十一）运算符重载、继承
yanzhiwen2的博客
03-19 571
1.运算符重载 //运算符重载：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。 1.1加号运算符重载 //对于内置的数据类型，编译器知道如何进行运算 //作用：实现两个自定义数据类型相加的运算 //语法： 返回值类型 operator+(参数列表）{}； //注意顺序，一定要先定义重载加号再调用 //总结： //1.对于内置的数据类型的表达式的运算符是不可能改变的 //2.不...
C++核心编程.md
11-21
C++核心编程.md、C++核心编程.md、C++核心编程.md 一提到这个名字相信有需要的小伙伴瞬间就能明白了，打开的话用typora这个软件，特别好，不认识名字的朋友也不要紧 这就是一个C++编程文档，很实用的，里边有一些C++...
黑马程序员，C++核心编程
04-17
黑马程序员，C++核心编程
C++核心编程.pdf
最新发布
07-10
C++核心编程.pdf
C++ 核心编程学习笔记
07-02
C++这门语言语法和细节特别多，为了方便日后回忆记了些笔记。
【C++】 运算符重载
m0_73351338的博客
11-23 2047
运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。
C++运算符重载的理解
qq_46087622的博客
11-04 3009
运算符重载概念： 对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。 一、加号运算符的重载 作用：实现两个自定义数据类型相加的运算 示例： class Person { public: Person() {}; Person(int a, int b) { this->m_A = a; this->m_B = b; } //成员函数实现 + 号运算符重载 Person operator+(const Person& p) { Person temp; temp.m_A
C++学习（运算符重载）p121~p126
m0_55006160的博客
12-29 303
1.加号运算符重载 > 总结1：对于内置的数据类型的表达式的的运算符是不可能改变的 > 总结2：不要滥用运算符重载 2.左移运算符重载
c++中的构造函数注意事项
qq_35426012的博客
09-07 605
匿名对象构造后直接析构 #include using namespace std; class person { public: person() { cout << "默认构造" << endl; } person(int a) { cout << "有参构造" << endl; } person(const person& p)//拷贝构造函数参数必须是引用
C++ 继承中构造和析构对象（面试题可能问）
qq_40214464的博客
09-29 121
# include<iostream> # include<string> using namespace std; class Base { public: Base() { cout << "Base构造函数" << endl; } ~Base() { cout << "Base析构函数" << endl; } }; class Son :public Base { public: Son() {...
c++加号+运算符重载（运算符重载时必须依托类来实现）。（加减乘除这四个原理一致，举一反三即可）。
admin的博客
12-23 389
作用：实现n个自定义数据类型相加的运算 重载分为两种：1.类内成员函数 2.全局函数重载 这俩的区别就是写成类内的可以少传一个对象，而全局函数必须把所有的对象参数都写上。 1.类内。 #include <iostream> #include<string> using namespace std; class person; class person { public: int m_a; int m_b; int m_c; person(int a, int b,int c
派生类构造对象时,构造函数执行顺序
weixin_30302609的博客
07-23 195
先调用基类构造函数,再调用派生类构造函数 123456789101112131415161718 classBase{public: Base() { cout << "Base()" << endl;}};classDerived : publicBase{public: Derived() { cout << "Derived...
MyInt的简单实现
weixin_34393428的博客
03-11 282
#include <iostream> using namespace std; class CMyInt{ private: int value; public: CMyInt(int x):value(x){} CMyInt():value(0){} //++i CMyInt & operator+...
c++函数重载与运算符重载
捡起一束光的博客
09-26 406
文章目录函数重载运算符重载 重载：同一件事情可能因为场景不同，我们需要有不同的处理方式,比如2维求距离和3维求距离 函数重载 相同名字，不同参数的函数 注意:函数重载只看参数个数和类型 C++允许我们对函数进行重载。用不同的参数来区分重载的函数 编译器会判断我们传入的参数来寻找正确的函数，这个过程叫重载决策 利用函数重载我们可以写适应不同输入的函数，简化我们的函数的调用过程 重载不需要特别...
C++核心编程指南中文版：开源与修订指南
"C++核心编程指南中文版"是一本由Bjarne Stroustrup和Herb Sutter合著的权威指南，该书在2016年2月15日发布，处于早期草稿阶段，可能存在错误和不规范格式。作为开源项目，它遵循MIT版权授权，允许用户自由复制、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值