 语法树：[+]

简介

本章在上一节7的基础上对编译树进行完善。上一节7的编译树仅仅支持算术表达式的+-基本运算，本节对其进行扩充，使其支持不仅支持基本的算术运算，还支持变量，支持语句(if, while,input, ouput)，经过这次扩充，它形成的语法树已经基本具备了表达minus-C语言的能力。

简单说来，它可以表示下面的c语言代码：

a = 1
if(a>10){
  a = 11
}else{
  a = 7
}
print(a)

a =1
sum = 0
while(a <= 10){
   sum = sum + a
   a = a+1;
}
print(sum)

根据上述的c语言代码，通过手动构建对应的语法树，然后后序遍历语法树，就可以执行代码，输出结果。本节的编译树代码并不关注如何根据c语言代码自动构建语法树(lex和yacc支持)，而是着眼于对手动构建的语法树进行遍历执行。

语句的处理

if语句

if(expr) {stmt1} else  {stmt2}

对于if树节点，它具有3个孩子，expr，stmt1，stmt2. 当后序遍历到if节点时候，它首先判断expr是否为真，如果为真，则执行stmt1，否则执行stmt2，因此当执行后序遍历的时候，我们会有这样的代码：

if(t->kind == STMT_NODE){
            if(t->kind_kind == IF_STMT){
                //if条件判断结果，第二个孩子存储if成功的代码，第三个孩子存储else成功的代码
                recursive_execute(t->children[0]);
                if (my_mem[t->children[0]->addr] )
                    recursive_execute(t->children[1]);
                else
                    recursive_execute(t->children[2]);
            }//IF_STMT
}//STMT_NODE

如上面的代码所示，首先根据t->kind判断是否是语句节点，然后根据子类型t->kind_kind判断是否是if节点。如果是的话，首先递归执行第一个孩子，执行完毕后，结果保存在my_mem[t->children[0]->addr]中，然后判断它的值是否为真，如果为真，则执行stmt1，否则执行stmt2。

while语句

while(expr)  {stmt}

与if不同的是，while只有两个孩子，expr和stmt，同时当expr为真的时候，stmt会循环执行，直到expr为假。因此遍历代码如下：

if(t->kind_kind == WHILE_STMT){
    //第一个孩子存储条件判断结果，第二个孩子存储while成功的代码
    recursive_execute(t->children[0]);
    while (my_mem[t->children[0]->addr])
    {
        recursive_execute(t->children[1]);
        recursive_execute(t->children[0]);
    }
}

输入输出语句

输入输出相当于修改或者打印给定节点对应的内存的值，因此就非常简单，代码如下：

else if(t->kind_kind == INPUT_STMT){//input statement has one expr child
    cout<<"please input data:";
    cin>>my_mem[t->children[0]->addr];
}else if(t->kind_kind == PRINT_STMT){//print statement has one expr child to print.
    recursive_execute(t->children[0]);
    cout<<my_mem[t->children[0]->addr];
}

复合语句

复合语句是用来包装多个简单语句的，例如如果有3个语句，它们之间是顺序执行的关系，但是最后生成是一棵树，因此需要将3个语句组合在一起，简单来说就是将这3个语句的Node作为一个复合语句Node的孩子，当遍历执行的时候，只需要逐个执行每一个孩子即可。

代码如下：

else if(t->kind_kind == COMP_STMT){//组合语句，逐个语句执行即可。
    for (int i = 0; i < MAX_CHILDREN; ++i)
        recursive_execute(t->children[i]);
}

表达式语句

表达式语句就是基本的表达式后面加上分号，例如b=1;这就是一个语句，它是一个赋值表达式然后加上分号构成的语句。为了简单起见，对于表达式语句，它只有一个孩子就是表达式，因此表达式语句的执行就是执行它的孩子(表达式)

代码如下：

else if(t->kind_kind == EXPR_STMT){
    recursive_execute(t->children[0]); }

表达式的处理

表达式有很多种，例如二元的加减乘除，逻辑运算与或非，比较运算符，一元的取非，自增自减等等，以及还是纯粹的数字，变量表达式。简单起见，本代码只考虑支持基本的二元运算以及数字和变量表达式，它的执行代码比较简单，不具体阐述，示意如下：

if (t->kind == EXPR_NODE){          // 表达式结点
    recursive_execute(t->children[0]);
    recursive_execute(t->children[1]);

    if (t->kind_kind == OP_EXPR) {      // 运算类型表达式
        if (t->attr.op == PLUS)         // 加法表达式
            // 从内存（my_mem）中取出两个孩子的值，进行加法，结果写回内存
            my_mem[t->addr] = my_mem[t->children[0]->addr] + my_mem[t->children[1]->addr]; 
        else if (t->attr.op == MINUS)   // 减法的处理类似加法
            my_mem[t->addr] = my_mem[t->children[0]->addr] - my_mem[t->children[1]->addr];
        else if (t->attr.op == TIMES)
            my_mem[t->addr] = my_mem[t->children[0]->addr] * my_mem[t->children[1]->addr];
        else if (t->attr.op == OVER){
            if(my_mem[t->children[1]->addr] == 0){
                cout<<"error: divide by zero"<<endl;
                my_mem[t->addr] = 0;
            }else{
                my_mem[t->addr] = my_mem[t->children[0]->addr] / my_mem[t->children[1]->addr];
            }
        }
        else if (t->attr.op == AND)
            my_mem[t->addr] = my_mem[t->children[0]->addr] && my_mem[t->children[1]->addr];
        else if (t->attr.op == OR)
            my_mem[t->addr] = my_mem[t->children[0]->addr] || my_mem[t->children[1]->addr];
        else if (t->attr.op == EQ)
            my_mem[t->addr] = (my_mem[t->children[0]->addr] == my_mem[t->children[1]->addr]);
        else if (t->attr.op == GT)
            my_mem[t->addr] = my_mem[t->children[0]->addr] > my_mem[t->children[1]->addr];
        else if (t->attr.op == LT)
            my_mem[t->addr] = (my_mem[t->children[0]->addr] < my_mem[t->children[1]->addr]);
        else if (t->attr.op == NE)
            my_mem[t->addr] = !(my_mem[t->children[0]->addr] == my_mem[t->children[1]->addr]);
        else if (t->attr.op == GE)
            my_mem[t->addr] = (my_mem[t->children[0]->addr] > my_mem[t->children[1]->addr]) || (my_mem[t->children[0]->addr] == my_mem[t->children[1]->addr]);
        else if (t->attr.op == LE)
            my_mem[t->addr] = (my_mem[t->children[0]->addr] < my_mem[t->children[1]->addr]) || (my_mem[t->children[0]->addr] == my_mem[t->children[1]->addr]);
        else if(t->attr.op == ASSIGN){
            my_mem[t->addr] = my_mem[t->children[0]->addr] = my_mem[t->children[1]->addr];
        }
    }
    else if (t->kind_kind == CONST_EXPR)    // 常量表达式，将值（在vali中）保存至分配的内存中
        my_mem[t->addr] = t->attr.vali;
    else if(t->kind_kind == ID_EXPR){
        //do nothing
    }

}//EXPR_NODE

其中比较特别就是对于ID_EXPR(变量)类型，不作处理。这是因为此代码并没有支持符号表，变量节点的内存直接存储的是变量的值，而不是如正规的符号表中存储是变量所处于的符号表的位置。当碰到ID_EXPR类型，不需要进行额外的处理，变量的内存更新由具体的赋值运算决定。

树构建代码

先针对一个具体的while例子，说明如何构建一颗语法树，可以表达while语句。

要表达的while语句如下：

    a =1
    sum = 0
    while(a <= 10){
       sum = sum + a
       a = a+1;
    }
    print(sum)

它包含2个变量，输出结果是1+2+…+10。

对应的构建语法树的代码：

void whileTest()
{
    tree expr;
    Node *p, *q, *r, *s, *o, *u, *t,*p1,*q1;
    p = createId(expr);//a
    q = createId(expr);//sum
    p1 = createAssignStmt(expr,p, 1);//a=1
    q1 = createAssignStmt(expr, q, 0);//sum=0

    Node *a, *b, *c, *d, *e, *f, *g;
    a = createOpExpr(expr, p, createConst(expr, 10), LE);//a<=10
    b = createOpExpr(expr, p, q, PLUS);//sum+a
    c = createAssignStmt(expr, q, b);//sum = sum+a

    d = createOpExpr(expr, p, createConst(expr, 1), PLUS);
    e = createAssignStmt(expr, p, d);   //a=a+1
    f = createCompStmt(expr, c, e); //{sum = sum+a, a= a+1}
    r = createWhileStmt(expr, a,  f);//while

    t = createOutStmt(expr, q);//print sum

    o = createCompStmt(expr, p1, q1, r, t);

    executeTree(expr, o);
}

上面有很多createXXX的函数，并不需要关注其具体实现也可以读懂上面的构建代码。
首先创建两个变量，然后创建两个赋值语句 p1 , q1 ，随后创建while语句 r 和print语句 t ，最后将 4 个语句组装成一个组合语句 o 并将 o 作为语法树的根，启动execute执行。

实现代码

考虑到便于大家自己扩充，我将我自己扩充的版本放在这里，大家可以根据自己的想法继续扩充，例如实现多种一元运算符，实现for循环等等。大家将下面的代码直接粘贴到vs工程中，编译就可以执行。注意main函数中有多种test，可以专注于某一种情况的测试。

#include <iostream>
#include <malloc.h>
using namespace std;

#define MAX_CHILDREN 4
int my_mem[100];            // “内存”
int offset;

enum                    // 结点类型——kind
{
    STMT_NODE = 0,
    EXPR_NODE,
    DECL_NODE
};

enum                    // 语句结点子类型——kindkind
{
    IF_STMT = 0,
    WHILE_STMT,
    INPUT_STMT,
    PRINT_STMT,
    COMP_STMT,
    EXPR_STMT,  //只是一个包装而已
};

enum                    // 表达式结点子类型——kindkind
{
    TYPE_EXPR = 0,
    OP_EXPR,
    NOT_EXPR,
    ARRAY_EXPR,
    CONST_EXPR,
    ID_EXPR,
};

enum                    // 声明结点子类型——kindkind
{
    VAR_DECL = 0,
    ARRAY_DECL
};

enum                    // 运算——op
{
    //加减乘除，算术运算符
    PLUS = 0,
    MINUS,
    TIMES,   
    OVER,
    //与或，逻辑运算符
    AND,
    OR,
    //比较运算符
    EQ,
    LT,
    GT,
    GE,
    LE,
    NE,
    ASSIGN,
};
enum
{
    Integer = 0,
};

union NodeAttr {
    int op;             // 表达式结点，子类型是运算类型时，用op保存具体运算
    double vali;                // 表达式结点，常量表达式时，用vali保存整型常量值
    char valc;          // 字符值

    NodeAttr(void) { op = 0; }      // 几种构造函数
    NodeAttr(int i) { op = i; }
    NodeAttr(double i)  { vali = i; }
    NodeAttr(char c) { valc = c; }
};


struct Node
{
    struct Node *children[MAX_CHILDREN];    // 孩子结点
    int kind;                   // 结点类型
    int kind_kind;              // 子类型
    NodeAttr attr;              // 结点属性
    int addr;                   // 分配的内存空间（数组下标）
};
 class tree // 语法树类 { private: Node *root; // 根结点 private: void recursive_get_addr(Node *t); // 为临时变量（如表达式）分配存储空间 void recursive_execute(Node *t); // 遍历树，执行源程序 public: void setRoot(Node* p){root = p;} Node *NewRoot(int kind, int kind_kind, NodeAttr attr, int type, Node *child1 = NULL, Node *child2 = NULL, Node *child3 = NULL, Node *child4 = NULL); // 创建一个结点，设置其属性，连接孩子结点 void get_addr(void); // 分配空间和执行代码的接口 void execute(void); }; Node * tree::NewRoot(int kind, int kind_kind, NodeAttr attr, int type, Node *child1, Node *child2, Node *child3 , Node *child4) { Node* node = new Node(); node->kind = kind; node->kind_kind = kind_kind; node->attr = attr; node->children[0] = child1; node->children[1] = child2; node->children[2] = child3; node->children[3] = child4; return node; } void tree::get_addr(void) { cout << "allocate memory..." << endl; offset = 0; recursive_get_addr(root); // 接口函数直接调用实际分配空间的递归函数 } void tree::recursive_get_addr(Node *t) { if (t) { // 空指针什么也不做 if (t->kind == EXPR_NODE) { // 为表达式结点分配存储空间 t->addr = offset++; //cout << t->addr << endl; } for (int i = 0; i < MAX_CHILDREN; i++) // 递归处理所有子树——先序遍历 recursive_get_addr(t->children[i]); } } void tree::execute(void) { cout << "execute..." << endl; recursive_execute(root); // 接口函数调用递归函数 //cout << my_mem[root->addr] << endl; // 从内存取出执行结果，输出 } /* 功能逐步添加摘要： if条件判断功能： 根据if的condition来决定是否执行statement代码，因此不能首先对其所有的孩子进行后续遍历，需要根据第一个孩子的执行结果来决定是否执行第二个孩子。 while循环功能： 此功能框架代码与if功能相似，只是多了一个while循环而已 变量赋值： 读取用户输入，并赋值到变量，支持input(a)，它将用户的输入赋值到变量a，a为其第一个孩子。 赋值语句： 支持a=2，包括两个孩子，左边为变量，右边为值，当前值为左边的值。 输入功能： 能够接收用户输入，并赋值到变量中，前提需要增加赋值功能 输出功能： 构建输出语句，它只有一个孩子，即要输出的变量。 */ void tree::recursive_execute(Node *t) { if (t) { if(t->kind == STMT_NODE){ if(t->kind_kind == IF_STMT){ //if条件判断结果，第二个孩子存储if成功的代码，第三个孩子存储else成功的代码 recursive_execute(t->children[0]); if (my_mem[t->children[0]->addr] ) recursive_execute(t->children[1]); else recursive_execute(t->children[2]); }else if(t->kind_kind == WHILE_STMT){ //第一个孩子存储条件判断结果，第二个孩子存储while成功的代码 recursive_execute(t->children[0]); while (my_mem[t->children[0]->addr]) { recursive_execute(t->children[1]); recursive_execute(t->children[0]); } }else if(t->kind_kind == INPUT_STMT){//input statement has one expr child cout<<"please input data:"; cin>>my_mem[t->children[0]->addr]; }else if(t->kind_kind == PRINT_STMT){//print statement has one expr child to print. recursive_execute(t->children[0]); cout<<my_mem[t->children[0]->addr]; }else if(t->kind_kind == COMP_STMT){//组合语句，逐个语句执行即可。 for (int i = 0; i < MAX_CHILDREN; ++i) recursive_execute(t->children[i]); }else if(t->kind_kind == EXPR_STMT){ recursive_execute(t->children[0]); } } if (t->kind == EXPR_NODE){ // 表达式结点 recursive_execute(t->children[0]); recursive_execute(t->children[1]); if (t->kind_kind == OP_EXPR) { // 运算类型表达式 if (t->attr.op == PLUS) // 加法表达式 // 从内存（my_mem）中取出两个孩子的值，进行加法，结果写回内存 my_mem[t->addr] = my_mem[t->children[0]->addr] + my_mem[t->children[1]->addr]; else if (t->attr.op == MINUS) // 减法的处理类似加法 my_mem[t->addr] = my_mem[t->children[0]->addr] - my_mem[t->children[1]->addr]; else if (t->attr.op == TIMES) my_mem[t->addr] = my_mem[t->children[0]->addr] * my_mem[t->children[1]->addr]; else if (t->attr.op == OVER){ if(my_mem[t->children[1]->addr] == 0){ cout<<"error: divide by zero"<<endl; my_mem[t->addr] = 0; }else{ my_mem[t->addr] = my_mem[t->children[0]->addr] / my_mem[t->children[1]->addr]; } } else if (t->attr.op == AND) my_mem[t->addr] = my_mem[t->children[0]->addr] && my_mem[t->children[1]->addr]; else if (t->attr.op == OR) my_mem[t->addr] = my_mem[t->children[0]->addr] || my_mem[t->children[1]->addr]; else if (t->attr.op == EQ) my_mem[t->addr] = (my_mem[t->children[0]->addr] == my_mem[t->children[1]->addr]); else if (t->attr.op == GT) my_mem[t->addr] = my_mem[t->children[0]->addr] > my_mem[t->children[1]->addr]; else if (t->attr.op == LT) my_mem[t->addr] = (my_mem[t->children[0]->addr] < my_mem[t->children[1]->addr]); else if (t->attr.op == NE) my_mem[t->addr] = !(my_mem[t->children[0]->addr] == my_mem[t->children[1]->addr]); else if (t->attr.op == GE) my_mem[t->addr] = (my_mem[t->children[0]->addr] > my_mem[t->children[1]->addr]) || (my_mem[t->children[0]->addr] == my_mem[t->children[1]->addr]); else if (t->attr.op == LE) my_mem[t->addr] = (my_mem[t->children[0]->addr] < my_mem[t->children[1]->addr]) || (my_mem[t->children[0]->addr] == my_mem[t->children[1]->addr]); else if(t->attr.op == ASSIGN){ my_mem[t->addr] = my_mem[t->children[0]->addr] = my_mem[t->children[1]->addr]; } } else if (t->kind_kind == CONST_EXPR) // 常量表达式，将值（在vali中）保存至分配的内存中 my_mem[t->addr] = t->attr.vali; else if(t->kind_kind == ID_EXPR){ //do nothing } }//EXPR_NODE } } /* if: st_if -> (condition, action) while: st_while->(condition, action) */ void basicTest() { tree expr; Node *p, *q, *r; // 创建结点a p = expr.NewRoot(EXPR_NODE, CONST_EXPR, NodeAttr(9), Integer); // 创建结点5 q = expr.NewRoot(EXPR_NODE, CONST_EXPR, NodeAttr(5), Integer); // 创建减法结点，孩子结点为9和5 r = expr.NewRoot(EXPR_NODE, OP_EXPR, NodeAttr(MINUS), Integer, p, q); // q = expr.NewRoot(EXPR_NODE, CONST_EXPR, NodeAttr(2), Integer); // p = expr.NewRoot(EXPR_NODE, OP_EXPR, NodeAttr(PLUS), Integer, r, q); expr.setRoot(r); expr.get_addr(); // 为（子）表达式（们）分配存储空间 expr.execute(); // 执行代码 } void assignTest() { /* a = 1 output(a) 两个语句 */ tree expr; Node *p, *q, *r, *s, *o, *u, *t; //构建赋值语句 // 创建结点a p = expr.NewRoot(EXPR_NODE, ID_EXPR, NodeAttr(0), Integer); // 创建结点1 q = expr.NewRoot(EXPR_NODE, CONST_EXPR, NodeAttr(5), Integer); //赋值 r = expr.NewRoot(EXPR_NODE, OP_EXPR, NodeAttr(ASSIGN), Integer, p, q); s = expr.NewRoot(STMT_NODE, EXPR_STMT, NodeAttr(0), Integer, r);//赋值语句：孩子赋值表达式 //构建输出语句 t = expr.NewRoot(STMT_NODE, PRINT_STMT, NodeAttr(), Integer, p); //构建组合语句 o = expr.NewRoot(STMT_NODE, COMP_STMT, NodeAttr(), Integer, s, t); expr.setRoot(o); expr.get_addr(); // 为（子）表达式（们）分配存储空间 expr.execute(); // 执行代码 cout<<endl; } Node* createOpExpr(tree& expr, Node* p, Node* q, int type) { Node* p1; p1 = expr.NewRoot(EXPR_NODE, OP_EXPR, NodeAttr(type), Integer, p,q); return p1; } Node* createId(tree& expr) { Node* p; p = expr.NewRoot(EXPR_NODE, ID_EXPR, NodeAttr(0), Integer); return p; } Node* createConst(tree& expr, double value) { Node* q2; q2 = expr.NewRoot(EXPR_NODE, CONST_EXPR, NodeAttr(value), Integer); return q2; } Node* createSTMT(tree& expr, int type, Node* p1, Node* p2=NULL, Node* p3 = NULL, Node* p4=NULL) { Node* r; r = expr.NewRoot(STMT_NODE, type, NodeAttr(), Integer, p1,p2,p3,p4); return r; } Node* createIfStmt(tree& expr,Node* p1, Node* p2, Node* p3 = NULL ) { return createSTMT(expr, IF_STMT, p1, p2, p3); } Node* createWhileStmt(tree& expr, Node* p1, Node* p2) { return createSTMT(expr, WHILE_STMT, p1, p2); } Node* createInputStmt(tree& expr, Node* p) { return createSTMT(expr, INPUT_STMT, p); } Node* createOutStmt(tree& expr, Node* p) { return createSTMT(expr, PRINT_STMT, p); } Node* createExprStmt(tree& expr, Node* p) { return expr.NewRoot(STMT_NODE, EXPR_STMT, NodeAttr(0), Integer, p);//xxxx; xxxx为表达式，组合成语句 } Node* createAssignStmt(tree& expr, Node* variable, int value) { Node* p = variable; Node *q, *r, *s; q = createConst(expr, value); r = createOpExpr(expr, p,q, ASSIGN); return createExprStmt(expr, r); } Node* createAssignStmt(tree& expr, Node* variable, Node* q) { Node* p = variable; Node *r, *s; r = createOpExpr(expr, p,q, ASSIGN); return createExprStmt(expr, r); } Node* createCompStmt(tree& expr, Node* p1, Node* p2=NULL, Node* p3 = NULL, Node* p4=NULL) { return createSTMT(expr, COMP_STMT, p1,p2,p3,p4); } void executeTree(tree& expr, Node* root) { expr.setRoot(root); expr.get_addr(); // 为（子）表达式（们）分配存储空间 expr.execute(); // 执行代码 cout<<endl; } void inputOutTest() { /* input(a) output(a) */ tree expr; Node *p, *q, *r, *s, *o, *u, *t; //输入语句 // 创建结点a p = expr.NewRoot(EXPR_NODE, ID_EXPR, NodeAttr(0), Integer); s = createInputStmt(expr, p); q = createOutStmt(expr, p); o = createCompStmt(expr, s, q); executeTree(expr, o); } void ifTest() { /* a = 1 if(a>10){ a = 11 }else{ a = 7 } print(a) */ tree expr; Node *p, *q, *r, *s, *o, *u, *t; //输入语句 // 创建结点a p = expr.NewRoot(EXPR_NODE, ID_EXPR, NodeAttr(0), Integer); s = createAssignStmt(expr, p, 1);//a=1 //if语句 q = createOpExpr(expr, p, createConst(expr, 10), GT);//a>10 r = createIfStmt(expr, q, createAssignStmt(expr, p, 11), createAssignStmt(expr, p, 7));//if(a>10) a=11 else a=7 //构建输出语句 t = createOutStmt(expr, p);//print(a) //构建组合语句 o = createCompStmt(expr,s ,r, t ); executeTree(expr , o); } void whileTest() { /* a =1 sum = 0 while(a <= 10){ sum = sum + a a = a+1; } print(sum) */ tree expr; Node *p, *q, *r, *s, *o, *u, *t,*p1,*q1; p = createId(expr);//a q = createId(expr);//sum p1 = createAssignStmt(expr,p, 1);//a=1 q1 = createAssignStmt(expr, q, 0);//sum=0 Node *a, *b, *c, *d, *e, *f, *g; a = createOpExpr(expr, p, createConst(expr, 10), LE);//a<=10 b = createOpExpr(expr, p, q, PLUS);//sum+a c = createAssignStmt(expr, q, b);//sum = sum+a d = createOpExpr(expr, p, createConst(expr, 1), PLUS); e = createAssignStmt(expr, p, d); //a=a+1 f = createCompStmt(expr, c, e); //{sum = sum+a, a= a+1} r = createWhileStmt(expr, a, f);//while t = createOutStmt(expr, q);//print sum o = createCompStmt(expr, p1, q1, r, t); executeTree(expr, o); } void whileInputTest() { /* a = 1 sum = 0 input(x) while(a <= x){ sum = sum + a a = a+1; } print(sum) */ tree expr; Node *p, *q, *r, *s, *o, *u, *t,*p1,*q1; p = createId(expr);//a q = createId(expr);//sum p1 = createAssignStmt(expr, p, 1);//a=1 q1 = createAssignStmt(expr, q, 0);//sum=0 Node *a, *b, *c, *d, *e, *f, *g; g = createId(expr);//x f = createInputStmt(expr,g); u = createCompStmt(expr, p1, q1, f);//first 3 sentences. because Comp not support more than 4 children. a = createOpExpr(expr, p, g, LE);//a<=x, x from input b = createOpExpr(expr, p, q, PLUS);//sum+a c = createAssignStmt(expr, q, b);//sum = sum+a d = createOpExpr(expr, p, createConst(expr, 1), PLUS); e = createAssignStmt(expr, p, d); //a=a+1 f = createCompStmt(expr, c, e); //{sum = sum+a, a= a+1} r = createWhileStmt(expr, a, f);//while t = createOutStmt(expr, q);//print sum o = createCompStmt(expr, u, r, t); executeTree(expr, o); } int main(int argc, char *argv[]) { //assignTest(); //inputOutTest(); //ifTest(); //whileTest(); whileInputTest(); }

http://blog.csdn.net/lpstudy/article/details/51340537

实现效果

最后放上一个支持用户输入的while循环，它支持用户手动输入一个值x，然后程序会计算1+2+…+x的结果，并打印输出。它对应的c语言代码如下：

    a = 1
    sum = 0
    input(x)
    while(a <= x){
       sum = sum + a
       a = a+1;
    }
    print(sum)

效果：

秒客网

http://blog.csdn.net/lpstudy/article/details/51340537

简介