DEV_C++ 6.0233251

#include 
#include 
#include 
#include 
#include 
using namespace std;
const char NUM[] = {‘0‘ ‘1‘ ‘2‘ ‘3‘ ‘4‘ ‘5‘ ‘6‘ ‘7‘ ‘8‘ ‘9‘ ‘.‘};
const char OPERATION[] = {‘+‘ ‘-‘ ‘*‘ ‘/‘};
const double PI = 3.14159265358979;
const double EE = 2.71828182818281;
class Fun { //处理系统数学函数的类
public:
    Fun（string o int t double l = 0.0 double r = 0.0）: op（o） type（t） lvalue（l） rvalue（r） {}
    static string FUN[];
    double calc（）;
private:
    int type; //666 0 1 sin90 2 3! 3 3C2
    string op; //函数类型
    double lvalue; //函数左边的值
    double rvalue; //函数右边的值
    static int FunNum;
};
int Fun::FunNum = 10;
string Fun::FUN[] = {“!“ “sin“ “cos“ “tan“ “log“ “ln“ “C“ “A“ “^“ “-“};
/*
函数说明:
1:log是以10为底的工程对数
2:ln 是以e为底的自然对数
3:C 计算组合数 输入规则 如计算 3取2的组合 输入表达式 3C2
4:A 计算排列数 输入规则 如计算 3取2的排列 输入表达式 3A2
5:! 计算阶乘
6:^ x的y次方 输入 x^y
*/
int factorial（int n） { //阶乘函数
    int i s = 1;

    for（i = 1; i <= n; i++）
        s *= i;

    return s;
}
int C（int a int b） {
    return factorial（a） / （factorial（b） * factorial（a - b））;
}
int A（int a int b） {
    return factorial（a） / factorial（b）;
}
double Fun::calc（） { //计算系统函数的值
    if（type == 0）
        return lvalue;
    else {
        if（op == “!“）
            return factorial（lvalue）;

        if（op == “sin“）
            return sin（rvalue / 180 * PI）;

        if（op == “cos“）
            return cos（rvalue / 180 * PI）;

        if（op == “tan“）
            return tan（rvalue / 180 * PI）;

        if（op == “log“）
            return log10（rvalue）;

        if（op == “ln“）
            return log10（rvalue） / log10（EE）;

        if（op == “C“）
            return C（lvalue rvalue）;

        if（op == “A“）
            return A（lvalue rvalue）;

        if（op == “^“）
            return pow（lvalue rvalue）;

        if（op == “-“）
            return -rvalue;
        else {
            string err = “暂时没有函数“ + op;
            MessageBox（NULL err.c_str（） “错误“ MB_OK）;
            return 0;
        }
    }
}
struct Unit { //双向链表保存运算单元
    Unit（int p char o string c double v int t Unit * pr = NULL Unit * n = NULL）
        : PRI（p） Operation（o） Code（c） value（v） Type（t） Pre（pr） Next（n） {}
    int PRI; //优先级
    char Operation; //操作符
    string Code; //原始代码
    double value; //数据
    int Type; //类型 操作符0 数据1 函数2
    Unit * Pre; //构成双向链表
    Unit * Next;
};
class Node { //表达式树状结构的节点
public:
    Node（char o int p int e = 1 double v = 0 Node * ph = NULL Node * pl = NULL Node * pr = NULL）
        : Operation（o） PRI（p） expression（e） value（v） Head（ph） Left（pl） Right（pr） {}
    Node * Head; //节点的根左树枝右树枝
    Node * Left;
    Node * Right;
    double GetValue（）;
    char GetOperation（） const {
        return Operation;
    }
    int GetPri（） const {
        return PRI;
    }
    int IsExp（） const {
        return expression;
    }
private:
    char Operat