自上而下的语法分析：LL(1)文法分析

最新推荐文章于 2024-06-10 20:06:32 发布
最新推荐文章于 2024-06-10 20:06:32 发布
阅读量1.8k 收藏 45
点赞数 4
分类专栏： 编译原理 C/C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42534724/article/details/109923136
版权

自上而下的语法分析：LL(1)文法分析

1．实验内容及要求

（1）根据给定文法，先求出First和Follow集合，构造预测分析表
（2）根据预测分析表分析给定表达式是否是该文法识别的正确的算术表达式（要求输出归约过程）
（3）假如给定表达式文法为：
E->TE’;
E’->+TE’|e;
T->FT’;
T’->*FT’|e;
F->(E)|i;
(4) 分析的句子可为:
(i+i)*i和i+i)*i

2.运行结果
在这里插入图片描述
在这里插入图片描述
3.实验代码

// QX.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <fstream>
#include <string>
using namespace std;


static int Len = 0;//记录文件中产生式的个数
static string Gen[50][50];//记录消除左递归后的产生式
static int Gen_num[50];//消除左递归后每个产生式中句子的个数

static char Vt[50];//记录终结符
static int len_vt = 0;//终结符的个数
static string Vn[50];//非终结符数组，因为存在E‘  所以需要设置为string类型
static int len_vn = 0;//非终结符的个数

static string First[50][50];//记录first集
static int len_first = 0;
static int num_Fi[50];

static string Follow[50][50];//记录follow集
static int len_follow = 0;
static int num_Fo[50];

static string Ana_Table[50][50] = { "" };
static char V[50];

static int arrx[50];//follow集中包含的元素

static int Mer[50][50];//记录first和follow的表格

bool IsVt(char c) {//判断是否为终结符/e(空集)
	for (int i = 0; i < len_vt; i++) {
		if (c == Vt[i] || c == 'e') {
			return true;
		}
	}
	return false;
}
bool IsVn(string s) {//判断是否为非终结符
	for (int i = 0; i < len_vn; i++) {
		if (s == Vn[i]) {
			return true;
		}
	}
	return false;
}
void Pretreatment(string arr[]) {//预处理程序
	for (int i = 0; i < Len; i++) {//遍历每行产生式
		int npc = 0;
		for (int j = 0; j < arr[i].length(); j++) {//遍历一行产生式的每个字符
			if (arr[i][j] == '-') {
				Gen[i][Gen_num[i]++] = arr[i].substr(npc, j - npc);
				Vn[len_vn++] = arr[i].substr(npc, j - npc);//取出非终结符
				npc = j + 2;
			}
			else if (arr[i][j] == '|' || arr[i][j] == ';') {
				Gen[i][Gen_num[i]++] = arr[i].substr(npc, j-npc);
				npc = j + 1;
			}
		}
	}

//取出终结符
	for (int i = 0; i < Len; i++) {
		for (int j = 1; j < Gen_num[i]; j++) {
			for (int k = 0; k < Gen[i][j].length(); k++) {
				if (Gen[i][j][k] != '\'' && !IsVt(Gen[i][j][k]) && !IsVn(Gen[i][j].substr(k, 1))) {
					Vt[len_vt++] = Gen[i][j][k];
				}
			}
			
		}
	}
}


bool Is(char c, int n) {
	for (int i = 0; i < num_Fi[n]; i++) {
		if (First[n][i][0] == c) {
			return true;
		}
	}
	return false;
}
void Cre_First() {//构建first集
	for (int i = 0; i < Len; i++) {
		First[len_first][num_Fi[len_first]++] = Gen[i][0];
		for (int j = 1; j < Gen_num[i]; j++) {
			if (Gen[i][j][0] != Gen[i][0][0] && !Is(Gen[i][j][0], i)) {//P->Q.. && Q不在P的first集中
				First[len_first][num_Fi[len_first]++] += Gen[i][j][0];
			}
		}
		len_first++;
	}
	int flag = 1;
	while (flag) {
		flag = 0;
		for (int i = 0; i < len_first; i++) {
			string arr[50];
			int len = 0;
			for (int j = 1; j < num_Fi[i]; j++) {
				if (IsVt(First[i][j][0])) {
					arr[len++] = First[i][j];
				}
				else {
					string str = First[i][j];
					for (int k = 0; k < len_first; k++) {
						if (str._Equal(First[k][0])) {
							for (int p = 1; p < num_Fi[k]; p++) {
								arr[len++] = First[k][p];
							}
							break;
						}
					}
				}
			}
			num_Fi[i] = 1;
			for (int j = 0; j < len; j++) {
				First[i][num_Fi[i]++] = arr[j];
			}
		}
		for (int i = 0; i < len_first; i++) {
			int npc = 0;
			for (int j = 1; j < num_Fi[i]; j++) {
				if (!IsVt(First[i][j][0])) {
					flag = 1;
					npc = 1;
					break;
				}
			}
			if (npc == 1) {
				break;
			}
		}
	}
	cout << "\n==========first集合:============\n" << endl;
	for (int i = 0; i < len_first; i++) {
		cout << "FIRST(" << First[i][0] << "):";
		for (int j = 1; j < num_Fi[i]; j++) {
			cout << First[i][j] << " ";
		}
		cout << endl;
	}
}

//=============求解follow用到
int FindSub(string c) {//follow中对应的下标
	for (int i = 0; i < Len; i++) {
		if (c._Equal(Gen[i][0])) {
			return i;
		}
	}
	return -1;
}
int FindSub_Vt(char c) {//找到终结符在终结符数组中的下标
	if (c == '#') {
		return len_vt;
	}
	for (int i = 0; i < len_vt; i++) {
		if (c == Vt[i])
			return i;
	}
	return -1;
}
void PrintFollow(bool arry[][50]) {//输出follow集
	cout << "\n==========follow集合:============\n" << endl;
	for (int i = 0; i < Len; i++) {
		cout << "follow(" << Gen[i][0] << "): ";
		Follow[len_follow][num_Fo[len_follow]++] = Gen[i][0];
		for (int j = 0; j < len_vt + 1; j++) {
			if (j == len_vt) {
				cout << "#" << " ";
				Follow[len_follow][num_Fo[len_follow]++] = "#";
			}
			else if (arry[i][j] == true) {
				cout << Vt[j] << " ";
				Follow[len_follow][num_Fo[len_follow]++] = Vt[j];
			}
		}
		len_follow++;
		cout << endl;
	}
	for (int i = 0; i < Len; i++) {
		for (int j = 0; j < len_vt + 1; j++) {
			if (arry[i][j] == true) {
				arrx[j] = 1;
			}
		}
	}
}
bool Exit_Fi(int n, char c) {
	string str(1, c);
	for (int i = 1; i < num_Fi[n]; i++) {
		if (str == First[n][i]) {
			return true;
		}
	}
	return false;
}
bool Exit_F0(int n, char c) {
	string str(1, c);
	for (int i = 1; i < num_Fo[n]; i++) {
		if (str == Follow[n][i]) {
			return true;
		}
	}
	return false;
}

void Print(bool arry[][50]) {
	cout << "\n\n=================First集 & Follow集=================\n";
	cout << "\t\t";
	char arr[50];

	for (int i = 0; i < len_vt; i++) {
		arr[i] = Vt[i];
	}
	arr[len_vt] = '#';
	arr[len_vt + 1] = 'e';//上表头有len+2元素
	for (int i = 0; i < len_vt + 2; i++) {
		cout << arr[i] << "\t";
	}
	cout << endl;
	for (int i = 0; i < len_first; i++) {
		cout << "First(" << First[i][0] << ")" << "\t";
		for (int j = 0; j < len_vt + 2; j++) {
			if (Exit_Fi(i, arr[j])) {
				cout << 1 << "\t";
			}
			else {
				cout << "-" << "\t";
			}
		}
		cout << endl;
	}
	for (int i = 0; i < len_first; i++) {
		cout << "Follow(" << First[i][0] << ")" << "\t";
		for (int j = 0; j < len_vt + 2; j++) {
			if (Exit_F0(i, arr[j])) {
				cout << 1 << "\t";
			}
			else {
				cout << "-" << "\t";
			}
		}
		cout << endl;
	}
}

void Cre_Follow() {//2020-5-27 终于写出来了，
	bool arry[50][50];
	for (int i = 0; i < Len; i++) {
		for (int j = 0; j < len_vt + 1; j++) {
			arry[i][j] = false;
		}
	}
	arry[0][len_vt] = true;
	for (int i = 0; i < Len; i++) {
		for (int j = 1; j < Gen_num[i]; j++) {
			int len = Gen[i][j].length();
			for (int k = 1; k < len; k++) {
				if (IsVt(Gen[i][j][k]) && !IsVt(Gen[i][j][k - 1])) {   //p->Qa   a加入follow(Q)
					string str = "";
					if (len > 2 && Gen[i][j][k - 1] == '\'') {
						str = Gen[i][j].substr(k - 2, 2);
					}
					else {
						str += Gen[i][j][k - 1];
					}
					int x = FindSub(str);
					int y = FindSub_Vt(Gen[i][j][k]);
					arry[x][y] = true;
				}
			}
		}
	}
	for (int i = 0; i < Len; i++) {
		for (int j = 1; j < Gen_num[i]; j++) {
			int len = Gen[i][j].length();
			for (int k = 0; k < len - 1; k++) {
				if (!IsVt(Gen[i][j][k]) && !IsVt(Gen[i][j][k + 1]) && Gen[i][j][k + 1] != '\'') {//P->..QW   first(W)-"e"  --->follow(Q)
					string str = "";
					if (k < len - 2 && Gen[i][j][k + 2] == '\'') {
						str = Gen[i][j].substr(k + 1, 2);
					}
					else {
						str += Gen[i][j][k + 1];
					}
					int y = FindSub(str);//  W  在消除左递归后的数组中所在的行下标
					str = "";
					if (k > 0 && Gen[i][j][k] == '\'') {
						str = Gen[i][j].substr(k - 1, 2);
					}
					else {
						str += Gen[i][j][k];
					}
					int x = FindSub(str);//  Q  在消除左递归后的数组中所在的行下标 
					for (int w = 1; w < num_Fi[y]; w++) {
						if (!First[y][w]._Equal("e")) {
							int m = FindSub_Vt(First[y][w][0]);
							arry[x][m] = true;
						}
					}
				}
			}
		}
	}
	for (int i = 0; i < Len; i++) {
		for (int j = 1; j < Gen_num[i]; j++) {
			int len = Gen[i][j].length();
			for (int k = 0; k < len; k++) {
				if (k == len - 1 && !IsVt(Gen[i][j][k])) {//最后一个元素   P->....Q||P->....Q'   follow(P)入follow(Q)
					string str = "";
					if (Gen[i][j][k] == '\'') {
						str = Gen[i][j].substr(k - 1, 2);
					}
					else {
						str += Gen[i][j][k];
					}
					int x = FindSub(str);//Q所在行
					int y = FindSub(Gen[i][0]);//P所在行
					for (int p = 0; p < len_vt + 1; p++) {
						if (arry[y][p]) {
							arry[x][p] = true;
						}
					}
				}
				else if (k < len - 1) {
					if (!IsVt(Gen[i][j][k]) && !IsVt(Gen[i][j][k + 1])) {
						string str = "";
						if (k < len - 2 && Gen[i][j][k + 2] == '\'') {
							str = Gen[i][j].substr(k + 1, 2);
						}
						else {
							str += Gen[i][j][k];
						}
						int t = FindSub(str);
						int flag = 0;
						for (int w = 1; w < num_Fi[t]; w++) {//判断是否包含空集
							if (First[t][w]._Equal("e")) {
								flag = 1;
								break;
							}
						}
						if (flag) {//包含空集
							str = "";
							if (Gen[i][j][k] == '\'') {
								str = Gen[i][j].substr(k - 1, 2);
							}
							else {
								str += Gen[i][j][k];
							}
							int x = FindSub(str);//Q所在行
							int y = FindSub(Gen[i][0]);//P所在行
							for (int p = 0; p < len_vt + 1; p++) {
								if (arry[y][p]) {
									arry[x][p] = true;
								}
							}
						}

					}
				}
			}
		}
	}
	PrintFollow(arry);
	Print(arry);
}


void Print_Table() {
	cout << "\n\n" << "\t";
	for (int i = 0; i < len_vt + 1; i++) {
		cout << V[i]<<"\t\t";
	}
	cout << endl;
	for (int i = 0; i < len_first; i++){
		cout << First[i][0] << "\t";
		for (int j = 0; j < len_vt + 1; j++) {
			if (Ana_Table[i][j] != "") {
				cout << Ana_Table[i][j] << "\t\t";
			}
			else {
				cout << ""<<"\t\t";
			}
		}
		cout << endl;
	}
}

int FindSub_V(char c) {
	for (int i = 0; i < len_vt + 1; i++) {
		if (c == V[i]) {
			return i;
		}
	}
	return -1;
}

void Cre_AnaTable() {
	for (int i = 0; i < len_vt; i++) {
		V[i] = Vt[i];
	}
	V[len_vt] = '#';
	for (int i = 0; i < len_first; i++) {
		for (int j = 1; j < num_Fi[i]; j++) {
			if (First[i][j][0] != 'e') {//该终结符  不为空
				int y = FindSub_V(First[i][j][0]);//该终结符所在的下标
				if (Gen_num[i] == 2) {//只有一个产生式后件
					Ana_Table[i][y] = Gen[i][0] + "->" + Gen[i][1];
				}
				else {//有多个产生式后件
					for (int k = 1; k < Gen_num[i]; k++) {
						if (Gen[i][k][0] == First[i][j][0]) {
							Ana_Table[i][y] = Gen[i][0] + "->" + Gen[i][k];
							break;
						}
					}
				}
			}
			else {//该终结符  为空
				for (int k = 1; k < num_Fo[i]; k++) {
					int y = FindSub_V(Follow[i][k][0]);
					Ana_Table[i][y] = Gen[i][0] + "->" + "e";
				}
			}
		}
	}
	Print_Table();
}


void Analysis(string str) {
	cout << "\n\n==========预测分析过程==========\n";
	string stack = "";
	stack += str[0]; 
	stack += Gen[0][0];
	str=str.substr(1, str.length() - 1);
	char a = str[0];
	bool flag = true;
	int npc = 0;
	cout << "步骤\t\t" << "符号栈\t\t" << "输入串\t\t" << "所用产生式" << endl;
	cout << npc << "\t\t" << stack << "\t\t" << str << "\t\t" << "" << "\n";
	while (flag) {
		npc++;
		char x = stack[stack.length() - 1];
		stack.erase(stack.length() - 1);
		if (IsVt(x)) {//栈顶元素为终结符
			if (x == a) {
				str=str.substr(1, str.length() - 1);
				a = str[0];
				cout << npc << "\t\t" << stack << "\t\t" << str << "\t\t" << "" << "\n";
			}
			else {
				cout << "error" << endl;
				break;
			}
		}
		else if (x == '#') {//栈顶元素位#
			if (x == a) {
				flag = false;
			}
			else {
				cout << "error" << endl;
				break;
			}
		}
		else{
			string s="";
			if (x == '\'') {
				s += stack[stack.length() - 1];
				s += x;
				stack.erase(stack.length() - 1);
			}
			else {
				s += x;
			}
			int m;
			for (int i = 0; i < Len; i++) {
				if (s == Gen[i][0]) {
					m = i;
					break;
				}
			}
			int n = FindSub_V(a);
			int len = Ana_Table[m][n].length();
			if (len == 0) {
				cout << "error" << endl;
			}
			else if (Ana_Table[m][n][len-1] != 'e') {
				for (int k = len - 1; k >= 0; k--) {
					if (Ana_Table[m][n][k] == '>') {
						break;
					}
					else if (Ana_Table[m][n][k] == '\'') {
						stack += Ana_Table[m][n].substr(k - 1, 2);
						k--;
					}
					else {
						stack += Ana_Table[m][n][k];
					}
				}
				cout << npc << "\t\t" << stack << "\t\t" << str << "\t\t" << Ana_Table[m][n] << "\n";
			}
			else {
				cout << npc << "\t\t" << stack << "\t\t" << str << "\t\t" << Ana_Table[m][n] << "\n";
			}
		}
		//cout << npc << "\t\t" << stack << "\t\t" << str << "\t\t" << "" << "\n";
	}
}




int main()
{
    string Pri[100];
	ifstream infile("Source.txt");
	if (!infile)
		cout << "error" << endl;
	int len = 0;//文件中产生式的个数
	while (infile.good()) {
		getline(infile, Pri[len++]);
	}//len=5
	cout << "==========从文件中读取到的产生式==========\n" << endl;
	for (int i = 0; i < len; i++) {
		cout << Pri[i] << endl;
	}
	Len = len;
	Pretreatment(Pri);
	Cre_First();
	Cre_Follow();
	Cre_AnaTable();
	string str;
	cout << "==========请输入产生式==========" << endl;
	cin >> str;//       #i*i+i#
	Analysis(str);
}
_码到成功_
关注
  • 4
    点赞
  • 踩
  • 45
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
编译原理实验2(1)——自上而下语法分析
Neymessi_JR的博客
07-09 1209
1、为初等函数运算语言构造LL（1）语法分析器。2、掌握LL（1）语法分析器的方法，加深对自上而下语法分析原理的理解。3、掌握设计、编制并调试LL（1）语法分析程序的思想和方法。一、根据初等函数运算语言运算法则，将语法模式用上下文无关文法表达。（纸上作业）1、注意运算的优先级问题，避免产生二义性文法。二、将上述文法改写为LL(1)文法。（纸上作业）三、根据LL（1）文法给出预测分析表。（纸上作业）四、根据预测分析表，给出解析LL(1)文法的递归下降子程序或预测分析器程序。五、本语法分析程序的输入是实验一生成
编译上机-自上而下的语法分析
05-08
编译上机-自上而下的语法分析
自上而下的语法分析，LL(1)文法（消除左递归，提取左因子）
热门推荐
小镜子~
05-14 1万+
自上而下的语法分析：（推导） 由根节点到叶节点 ※最左推导和最右推导 （每一步替换最左边的非终结符/每一步替换最右边的非终结符），最右推导称为规范推导。最右推导对应于最左规约（规范规约） 例： 文法： S--->AB A--->a|t B---->+CD C--->a D---->a 最右推导： S--->AB---->A+CD--->A+Ca---->A+
自下而上语法分析、自上而下语法分析和递归下降法、预测分析法、LL(1)和LR是什么关系
最新发布
weixin_63681863的博客
06-10 1061
自上而下 vs 自下而上自上而下：从开始符号推导输入（递归下降、预测分析）。自下而上：从输入归约至开始符号（LR分析）。递归下降 vs 预测分析都是自上而下方法。递归下降：函数调用匹配输入，适用于手工实现。预测分析：使用预测表，适用于自动生成分析器。LL(1)：自上而下，1符号前瞻，无回溯。LR：自下而上，能处理更广泛的文法，包括左递归。递归下降法：手工编写的函数，每个函数对应一个非终结符。预测分析法：构造预测表，根据输入符号决定推导规则。LL(1)：构造预测表，1符号前瞻。
自上而下的LL(1)语法分析法
weixin_30659829的博客
07-01 756
LL(1)文法：从文法的开始符，向下推导，推出句子。 对文法G的句子进行确定的自顶向下语法分析的充分必要条件是，G的任意两个具有相同左部的 产生式A—>α|β 满足下列条件： （1）如果α、β均不能推导出ε，则 FIRST(α) ∩ FIRST(β) = ∅。 （2）α 和 β 至多有一个能推导出 ε。 （3）如果 β *═> ε，则 FIRST(α) ∩ FO...
编译原理学习笔记7——语法分析|自上而下分析1
我的的博客
05-22 1831
编译原理学习笔记7——语法分析| 自上而下分析
【编译原理】c++实现自上而下语法分析器
weixin_30656145的博客
04-27 3439
写在前面：本博客为本人原创，严禁任何形式的转载！本博客只允许放在博客园（.cnblogs.com），如果您在其他网站看到这篇博文，请通过下面这个唯一的合法链接转到原文！ 本博客全网唯一合法URL：http://www.cnblogs.com/acm-icpcer/p/8964342.html 　　使用递归下降子程序实现的PL/0语言的算术表达式的自上而下语法分析。该语言的其他语法实...
LL(1)语法分析器.zip
06-13
在编译原理中，LL(1)语法分析器是一种重要的工具，用于理解并解析编程语言的源代码。本文将深入探讨LL(1)语法分析器的工作原理、特点以及与词法分析器的关系。 首先，我们要了解词法分析，这是编译器的前端阶段。...
编译原理实验二 LL(1)语法分析器.zip
04-27
含源代码、讲解视频、实验报告、程序设计思想等。...输入一个LL（1）文法，构造相应的LL（1）预测分析表。2．从键盘读入输入串，由算法判断该输入串是否为该文法的句子，若正确，就通过，若错误就报错。
编译原理的语法分析——LL(1)分析表的实现.docx
12-04
4. **运行分析**：分析程序根据LL(1)算法处理输入字符串，通过堆栈操作进行语法分析，并输出分析结果。 实验中还提到了一些编程注意事项，如确保正确处理编码问题，避免在源代码中使用中文，以及使用适当的头文件和...
编译原理：LL(1)语法分析器的设计
03-08
E →T E’ E’→+ T E’ | λ TF→ T’ T’→* F T’ | λ F →id| ( E ) 符号串 i + i * i # 的LL[1]分析过程：
自上而下的语法分析*******
04-11
编译原理9999999999999999999999999999999999999999999999999999999999
自上而下语法分析
11-25
c++编写自上而下语法分析程序，bcisakjvfgdafibv dskzugbf
byyl_编译原理；自上而下语法分析；实验_
10-03
1.将词法分析的输出结果，作为表达式语法分析器的输入，进行语法解析，对于语法正确的表达式，报告“语法正确法错误的表达式，报告“语法错误”， 指出错误原因。2.把语法分析器设计成一个独立一遍的过程。3.采用递归下降分析法或者采用预测分析法实现语法分析。
语法分析器和自上而下语法分析器
12-07
词法分析器和自上而下语法分析器，其中语法分析器采用的是简单优先的方法。里面有实验原理，实验代码（界面采用MFC做的）
语法分析自上而下分析c语言算法,实验5-LL(1)语法分析程序的设计与实现(C语言).doc...
weixin_32513585的博客
05-23 824
班级: 学号: 姓名:PAGE 19实验五 LL(1)文法识别程序设计一、实验目的通过LL(1)文法识别程序的设计理解自顶向下的语法分析思想。二、实验重难点FIRST集合、FOLLOW集合、SELECT集合元素的求解，预测分析表的构造。三、实验内容与要求实验内容：阅读并理解实验案例中LL(1)文法判别的程序实现；参考实验案例，完成简...
编译原理实验（自上而下的语法分析）
weixin_44348327的博客
05-12 3087
自上而下的语法分析（Java描述） 【问题描述】 依据给定的LL(1)文法，识别输入符号串是否是文法的合法句子。 【基本要求】 1、输入 LL(1)文法、待识别的符号串。 2、实现由 LL(1)文法构造 First 集和 Follow 集的算法。 3、根据First 集和 Follow 集构造相应的预测分析表。 4、实现预测分析技术的总控程序。 5、输出识别过程(推导或语法树)及结论。 【测试用例...
自上而下语法分析：LL(1)解析与递归下降详解
第四章-第二讲-1主要探讨了...总结来说，第四章-第二讲-1详细阐述了自上而下语法分析的基础理论、实际应用和常见挑战，以及如何通过LL(1)分析法和其他技术来解决这些问题，是深入学习编译原理不可或缺的一部分。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

_码到成功_

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

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

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

打赏作者

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

抵扣说明：

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

余额充值