精华内容
下载资源
问答
  • 实现计算器功能:本实例用到的commandbutton控件数组,利用控件数组可方便编程。
  • VB6四则运算器-数学计算器,可实现简单的加,减,乘,除和求余运算。严格来说还并不是一个计算器哦,只是一个运算器,太简单了,你可以用这个源码学习一些界面设计方面、基本数学运算方面的小技巧,运行效果如图所示。
  • vb.net 四则运算器

    2015-07-06 13:43:05
    利用vb.net写的四则运算器代码,简单易懂,适合初学者
  • VB093-四则运算器四则运算器,实现加,减,乘,除,求余运算VB6.0源代码
  • 一实验目的目标 综合运用本课程的相关知识完成两位数四则运算器的设计编写与测试培养学生的实践动手能力并检测本课程的学习效果 二实验内容 基本要求 两位数指10-99的自然数的加减乘除除法指的是整除运算其中减法和...
  • VB 简单的运算器VB 简单的运算器VB 简单的运算器VB 简单的运算器VB 简单的运算器
  • VB 编写的四则运算器

    2009-01-01 19:00:08
    本系统是一个简单的四则运算器,能够实现加减乘除四则运算,而且能够实现先乘除后加减运算!
  • 很简单的:窗口放入个COMMAND控件(Caption属性分别为+、-、X、÷),三个TEXT控件,再放入三个Label控件(Caption属性分别为:操作数1、操作数2和计算结果),窗口的Caption属性改为“四则运算”代码如下:Private ...

    很简单的:窗口放入四个COMMAND控件(Caption属性分别为+、-、X、÷),三个TEXT控件,再放入三个Label控件(Caption属性分别为:操作数1、操作数2和计算结果),窗口的Caption属性改为“四则运算”

    代码如下:

    Private Sub Command1_Click()

    If Val(Text1.Text) + Val(Text2.Text) Int(Val(Text1.Text) + Val(Text2.Text)) Then

    Text3.Text = Format(Val(Text1.Text) + Val(Text2.Text), 0.######)

    Else

    Text3.Text = Val(Text1.Text) + Val(Text2.Text)

    End If

    End Sub

    Private Sub Command2_Click()

    If Val(Text1.Text) - Val(Text2.Text) Int(Val(Text1.Text) - Val(Text2.Text)) Then

    Text3.Text = Format(Val(Text1.Text) - Val(Text2.Text), 0.######)

    Else

    Text3.Text = Val(Text1.Text) - Val(Text2.Text)

    End If

    End Sub

    Private Sub Command3_Click()

    If Val(Text1.Text) * Val(Text2.Text) Int(Val(Text1.Text) * Val(Text2.Text)) Then

    Text3.Text = Format(Val(Text1.Text) * Val(Text2.Text), 0.######)

    Else

    Text3.Text = Val(Text1.Text) * Val(Text2.Text)

    End If

    End Sub

    Private Sub Command4_Click()

    If Val(Text1.Text) / Val(Text2.Text) Int(Val(Text1.Text) / Val(Text2.Text)) Then

    Text3.Text = Format(Val(Text1.Text) / Val(Text2.Text), 0.######)

    Else

    Text3.Text = Val(Text1.Text) / Val(Text2.Text)

    End If

    End Sub

    取消

    评论

    展开全文
  • 这是一个用vb编的四则运算器,很不错,有加、减、乘、除。很适合学生使用
  • 四则运算出题,可选题数,显示正确答案,计分。
  • 四则运算器,实现加,减,乘,除,求余运算VB6.0源代码
  • Text & "4" End Sub Private Sub Command16_Click() Text1。 Text = Text1。Text & "3" End Sub Private Sub Command17_Click() Text1。Text = Text1。Text & "2" End Sub Private Sub Command2_Click()’清空 Text1...

    Dim a As Double, b As Double, c As String

    Private Sub Command1_Click()

    Text1。Text = Text1。Text & "1"

    End Sub

    Private Sub Command10_Click()

    Text1。

    Text = Text1。Text & "9"

    End Sub

    Private Sub Command11_Click()

    Text1。Text = Text1。Text & "8"

    End Sub

    Private Sub Command12_Click()

    Text1。

    Text = Text1。Text & "7"

    End Sub

    Private Sub Command13_Click()

    Text1。Text = Text1。Text & "6"

    End Sub

    Private Sub Command14_Click()

    Text1。

    Text = Text1。Text & "5"

    End Sub

    Private Sub Command15_Click()

    Text1。Text = Text1。Text & "4"

    End Sub

    Private Sub Command16_Click()

    Text1。

    Text = Text1。Text & "3"

    End Sub

    Private Sub Command17_Click()

    Text1。Text = Text1。Text & "2"

    End Sub

    Private Sub Command2_Click()’清空

    Text1。

    Text = ""

    Text1。SetFocus

    End Sub

    Dim i As Variant

    If Text1。Text = "" Then Exit Sub

    aa = Len(Text1。

    Text)

    If Text1。Text 57 Or Asc(Mid(Text1。Text, i, 1)) = 47 Then

    MsgBox "非法数据,请重新输入!", 64, "提示!"

    Text1。

    Text = ""

    Text1。SetFocus

    Exit For

    End If

    Next i

    End If

    b = Val(Text1。

    Text)

    Select Case c

    Case " "

    Text1。Text = Val(a) Val(b)

    Case "-"

    Text1。

    Text = Val(a) - Val(b)

    Case "*"

    If b = "0" Or a = "0" Then

    MsgBox "0不可以其它数相乘,请输入正确的数据!", 16, "提示!"

    Text1。

    Text = ""

    Text1。SetFocus

    Exit Sub

    End If

    Text1。

    Text = Val(a) * Val(b)

    Case "/"

    If Val(b) = 0 Then Exit Sub

    If a = 0 Or b = 0 Then

    MsgBox "0不可以作除数,请输入正确的数据!", 16, "提示!"

    Text1。

    Text = ""

    Text1。SetFocus

    Exit Sub

    End If

    Text1。Text = Val(a) / Val(b)

    End Select

    If IsNumeric(Text1。

    Text) Then

    Text1。Text = Text1。Text

    End If

    End Sub

    Private Sub Command4_Click()

    If Text1。

    Text = "" Then Exit Sub

    a = Text1。Text

    Text1。Text = ""

    c = "/"

    End Sub

    Private Sub Command5_Click()

    If Text1。

    Text = "" Then Exit Sub

    a = Text1。Text

    Text1。Text = ""

    c = "-"

    End Sub

    Private Sub Command6_Click()

    If Text1。

    Text = "" Then Exit Sub

    a = Text1。Text

    Text1。Text = ""

    c = "*"

    End Sub

    Private Sub Command7_Click()

    If Text1。

    Text = "" Then Exit Sub

    a = Text1。Text

    Text1。Text = ""

    c = " "

    End Sub

    Private Sub Command8_Click()

    If InStr(1, Text1。

    Text, "。") > 0 Then Exit Sub

    If Len(Text1。Text) = 0 Then Text1。Text = "0"

    Text1。Text = Text1。Text & "。

    "

    End Sub

    Private Sub Command9_Click()

    Text1。Text = Text1。Text & "0"

    End Sub

    Private Sub Form_Load()

    Text1。

    fontsize = 40

    End Sub

    Private Sub Text1_Change()

    If KeyAscii = 46 Then

    If InStr(1, Text1。

    Text, "。

    ") > 0 Then

    KeyAscii = 0: Exit Sub

    Else

    Exit Sub

    End If

    End If

    If KeyAscii >= 48 And KeyAscii <= 57 Then Exit Sub

    If KeyAscii = 8 Or KeyAscii = 13 Then Exit Sub

    If KeyAscii = 45 Then Exit Sub

    KeyAscii = 0

    End Sub。

    全部

    展开全文
  • 在数学中,当一级运算(加减)和二级运算(乘除)同时出现在一个式子中时,它们的运算顺序是先乘除,后加减,如果有括号就先算括号内后算括号外,同一级运算顺序是从左到右,这样的运算四则运算四则是指加法、...
  • 四则运算解释

    2008-04-24 12:23:28
    vb写的四则运算解释
  • vb矩阵运算

    2012-06-24 19:29:33
    运算公式运用计算机...此系统开发简单,功能完善,小巧实用,运用动态数组与常用VB知识编写,可以运用到大一新生的学习线性代数中去,帮助新接触矩阵的大学生更好的学习矩阵,避免掉不必要的繁难运算,实用性超高。
  • VB开发的简单小程序,实现加减乘除以及乘方和开方的功能
  • vb做得小程序,也是课堂上的作业,可能有些小bug
  • 一款不错的出题,支持选择加减乘除及最大数,并可以导出到文件。还有游戏模式,支持计时,有vb源码和编译程序。出计算题是一件麻烦事 有了这个出题 一点就搞定! 欢迎下载!!!
  • VB加法运算器源代码

    2009-07-19 16:10:52
    VB为设计平台,编制一个简单的加法运算器
  • 大数据加法运算器

    2018-01-05 14:43:34
    大数据加法运算器大数据加法运算器大数据加法运算器大数据加法运算器
  • 面对模拟电路中各种公式,若是不掌握本质内容,即使知道公式,哪天换一种模式,可能就不会算了。本节主要讲解运算放大的计算。
  • 用于学习vb.net的程序。 不包含运算顺序判断的最基本的四则运算器。 (例如,1+2*3会先计算1+2=3,再计算3*3) 开源,转载请保留作者信息。 (使用VS2008 开发)
  • VB 小学生 加减乘除 测试运算系统,可实现随机出题,打题之后并判分的功能。分为低级、中级、高级三个级别。
  • 函数表达运算 函数运算 函数运算器 开发工具类 超级函数表达式运算器既是方便实用的数字计算器,又是一个会列表达式就会运算的超级新颖的多...超级函数表达式运算器是进行数字计算、公式运算、函数应用、vb编程的好帮手
  • C++实现计算器(四则混合运算

    万次阅读 多人点赞 2017-04-29 18:34:01
    计算器是带括号的四则运算实际上利用的是栈后进先出的原则 转换思想: #define _CRT_SECURE_NO_WARNINGS 1 #include"stdio.h" #include"stdlib.h" #include"string.h" #define maxsize 1024 typedef struct { ...

    计算器是带括号的四则运算实际上利用的是栈后进先出的原则
    这里写图片描述

    这里写图片描述

    转换思想:
    这里写图片描述

    #define _CRT_SECURE_NO_WARNINGS 1
    #include"stdio.h"  
    #include"stdlib.h"   
    #include"string.h" 
    #define maxsize 1024
    typedef struct
    {
        float data[maxsize];
        int top;
    }Stack1;
    void Initstack1(Stack1 *S)
    {
        S = (Stack1*)malloc(sizeof(Stack1));
        S->top = -1;
    }
    int Push1(Stack1 *S, float ch)
    {
        if (S->top == maxsize - 1)
            return 0;
        else
        {
            S->top++;
            S->data[S->top] = ch;
            return 1;
        }
    }//入栈Push
    int Pop1(Stack1 *S, float ch)
    {
        if (S->top == -1)
            printf("栈上溢出!\n");
        else
            ch = S->data[S->top];
        S->top--;
        return 1;
    }//出栈
    typedef struct
    {
        char data[maxsize];
        int top;
    }Stack2;
    void Initstack2(Stack2 *S)
    {
        S = (Stack2*)malloc(sizeof(Stack2));
        S->top = -1;
    }
    int Push2(Stack2 *S, char ch)
    {
        if (S->top == maxsize - 1)
            return 0;
        else
        {
            S->top++;
            S->data[S->top] = ch;
            return 1;
        }
    }//入栈Push
    int Pop2(Stack2 *S, char ch)
    {
        if (S->top == -1)
            printf("栈上溢出!\n");
        else
            ch = S->data[S->top];
        S->top--;
        return 1;
    }//出栈
    int Comop(char ch) //判断是否是运算符
    {
        switch (ch)
        {
        case'+':
        case'-':
        case'*':
        case'/':
        case'(':
        case')':
        case'#':
            return 1;
        default:
            return 0;
        }
    }//判断ch是否为运算符
    char Prior[7][7] =
    { // 运算符优先级表   
              // '+' '-'   '*'  '/'  '('  ')'  '#'    
        /*'+'*/{ '>', '>', '<', '<', '<', '>', '>' },
        /*'-'*/{ '>', '>', '<', '<', '<', '>', '>' },
        /*'*'*/{ '>', '>', '>', '>', '<', '>', '>' },
        /*'/'*/{ '>', '>', '>', '>', '<', '>', '>' },
        /*'('*/{ '<', '<', '<', '<', '<', '=', '< ' },
        /*')'*/{ '>', '>', '>', '>', ' ', '>', '>' },
        /*'#'*/{ '<', '<', '<', '<', '<', '> ', '=' },
    };
    int Opid(char op1)
    {
        switch (op1)
        {
        case'+':return 0;
        case'-':return 1;
        case'*':return 2;
        case'/':return 3;
        case'(':return 4;
        case')':return 5;
        case'#':return 6;
        default:return -123456;
        }
    }
    char Precede(char op1, char op2)  //优先级比较
    {
        int a, b;
        a = Opid(op1); b = Opid(op2);
        return(Prior[a][b]);
    }
    float Operation(float a, char op, float b)
    {
        switch (op)
        {
        case '+':
            return b + a;
        case '-':
            return b - a;
        case '*':
            return b * a;
        case '/':
            return b / a;
        default:
            return -123456;
        }
    }
    void CreateExpression(char *exp)
    {
    
        if (exp == NULL)
        {
            exit(1);
        }
        scanf("%s", exp);
    }
    void TransmitExpression(char *exp, char postexp[]) //中缀表达式转换后缀表达式
    {
        Stack2 FZ;
        Initstack2(&FZ);
        int i = 0;
        char x;
        FZ.top = -1;
        Push2(&FZ, '#');
        FZ.data[FZ.top] = '#';
        while (*exp != '\0')
        {
            if (!Comop(*exp))
            {
                while (*exp >= '0'&&*exp <= '9')//读取一个数字串
                {
                    postexp[i++] = *exp;
                    exp++;
                }
                postexp[i++] = '#';
            }
            else
                switch (Precede(FZ.data[FZ.top], *exp))
            {
                case'<':
                    Push2(&FZ, *exp);
                    exp++;
                    break;
                case'=':
                    x = FZ.data[FZ.top];
                    Pop2(&FZ, x);
                    exp++;
                    break;
                case'>':
                    postexp[i++] = FZ.data[FZ.top];
                    x = FZ.data[FZ.top];
                    Pop2(&FZ, x);
                    break;
            }
        }
        while (FZ.data[FZ.top] != '#')
        {
            postexp[i++] = FZ.data[FZ.top];
            x = FZ.data[FZ.top];
            Pop2(&FZ, x);
        }
        postexp[i] = '\0';
    }
    float EvaluateExpression(char *postexp) //后缀表达式的计算
    {
        Stack1 SZ;
        Initstack1(&SZ);
        float a, b, d;
        SZ.top = -1;
        while (*postexp != '\0')
        {
            switch (*postexp)
            {
            case'+':
            case'-':
            case'*':
            case'/':
                a = SZ.data[SZ.top];
                Pop1(&SZ, a);
                b = SZ.data[SZ.top];
                Pop1(&SZ, b);
                Push1(&SZ, Operation(a, *postexp, b));
                break;
            default:
                d = 0;
                while (*postexp >= '0'&&*postexp <= '9')
                {
                    d = 10 * d + *postexp - '0';
                    postexp++;
                }
                Push1(&SZ, d);
                SZ.data[SZ.top] = d;
    
                break;
            }
            postexp++;
        }
        return(SZ.data[SZ.top]);
    }
    int Error(char *exp) //错误表达式判断
    {
        int i = 0;
        while (exp[i] != '\0')
        {
            if (
                ((exp[i] == '+' || exp[i] == '-' || exp[i] == '*' || exp[i] == '/') && (exp[i + 1] == ')'))
                || ((exp[i] == '+' || exp[i] == '-' || exp[i] == '*' || exp[i] == '/') && (exp[i - 1] == '('))
                || (exp[i] == ')'&&exp[i + 1] == '(')
                || (exp[i] == '('&&exp[i + 1] == ')')
                || ((exp[i] == ')') && exp[i + 1] >= '0'&&exp[i + 1] <= '9')
                || (exp[i] >= '0'&&exp[i] <= '9'&&exp[i + 1] == '(')
                || (exp[0] == '+' || exp[0] == '-' || exp[0] == '*' || exp[0] == '/' || exp[0] == ')')
                || ((exp[i] == '+' || exp[i] == '-' || exp[i] == '*' || exp[i] == '/') && (exp[i + 1] == '+' || exp[i + 1] == '-' || exp[i + 1] == '*' || exp[i + 1] == '/'))
                || (exp[i] == '/'&&exp[i + 1] == '0')
                )
                return 1;
            else
            if (exp[i] == '\0')
                return 0;
            i++;
        }
        return 0;
    }
    void menu()
    {
        printf("\t\t--------------------------------------------\n");
        printf("\t\t|                  计算器                  |\n");
        printf("\t\t|              ----------------            |\n");
        printf("\t\t|              |              |            |\n");
        printf("\t\t|              ----------------            |\n");
        printf("\t\t|              1    2    3   +             |\n");
        printf("\t\t|              4    5    6   -             |\n");
        printf("\t\t|              7    8    9   *             |\n");
        printf("\t\t|              0   (    )  /             |\n");
        printf("\t\t--------------------------------------------\n");
        printf("\t\t 请输入你要进行的操作:\n");
        printf("\t\t a表达式求值 b清空 c退出\n");
    }
    void clear()
    {
        system("cls");
        menu();
    }
    void Quit()
    {
        system("cls");
        exit(1);
    }
    void main()
    {
        char c;
        char exp[maxsize];
        char postexp[maxsize] = { 0 };
        menu();
        while (1)
        {
            scanf("%c", &c);
            switch (c)
            {
            case 'a':
            sr :
                printf("请输入要计算的表达式:\n");
               CreateExpression(exp);
               if (!Error(exp))
               {
                   TransmitExpression(exp, postexp);
                   printf("后缀表达式为:%s\n", postexp);
                   printf("表达式结果为:%s=", exp);
                   printf("%g\n", EvaluateExpression(postexp));
                   break;
               }
               else
               if (Error(exp))
               {
                   printf("您输入的表达式有误!\n");
                   goto sr;//goto语句在循环体里进行跳转
               }
            case'b':
                clear();
                break;
            case'c':
                Quit();
                break;
            }
        }
        system("pause");
    }
    展开全文
  • vb.net加法练习

    2011-11-21 13:05:52
    这是一个用vb.net编写的程序,主要是由计算机随机产生两个两位正整数的加法练习题,给用户进行加法运算练习,并统计练习结果。
  • Visual C# 实现四则运算 完善

    千次阅读 2014-03-27 12:02:56
    从网上找到一篇文档关于 C#实现四则运算,但用运算测试代码报错,运算式为 5*(3+(2*5)-1),之所以报错是因为源代码作者没有考虑到其他运算符与“(”或“)”相邻的情况,修改代码。以下为原文,代码中标红部分...

    从网上找到一篇文档关于 C#实现四则运算,但用运算测试代码报错,运算式为 5*(3+(2*5)-1),之所以报错是因为源代码作者没有考虑到其他运算符与“(”或“)”相邻的情况,修改代码。以下为原文,代码中标红部分为修改,可能依然有考虑不全的地方。

    原文转载地址为http://soft.yesky.com/194/2054194.shtml


    本文是介绍使用Visual C#实现自动计算四则混合运算的一种方法,在.NET1.1框架中,还没有包含全现成的类,不过,现在经过我们下文的介绍,大家完全可以自己写一个,作用嘛,没什么,就是熟悉一下栈的用法,或者家里有上小学的,可以写一个程序给孩子练习一下四则混合运算也行,哈哈,废话不多说了,讲正题吧。 

      出一个典型的算术题: (6+2*5)/4 

      从题中,我们首先算 2*5=10 接下来算 6+10=16 最后算 16/4 =4 所以,结果是4

      计算机怎么算?还好前辈给我们列出来一堆的算法,我们随便选一个就可以了。

      第一种算法

      使用栈来解决,意思就是把不优极最低的压到栈的最下面去,按照先进后出的原则,那么最优先级最低的就是最后计算了。

      计算过程:

      我们建立两个栈,一个是数据栈,一个是计算符号栈,以(6+2*5)/4为例子,看看倒底是怎么计算的。

      假设:

      1)优先级

      符号之间的优先级如下:

      “(“ “)” -1

      “+”,”-” 0
     
       “*”,”/” 1

      数值越大,则越优先,同级别的比较时 先出现的优先。

      2)将”(”,”)”设为特殊运算符,即单目运算,两邻两个运算符则可对消。

      3) 计算条件

      (1) 当前运算符不等于“”(特殊结束符)

      (2) 运算符栈里的运行算个数>=1时

      (3) 出栈口的运算符优先级高于将要入栈的运算符时或者两者可对消时。

      计算时,则将符号出栈参与计算,数值栈的出栈口前两位元素出栈参与计算,计算结果值向数值栈压栈,并进行递归此操作。


    图1:

      1) “(” 压入符号栈 2 ) “6”压入数值栈

      3) “(”与”+”比较优先级,认为”(”比”+”优先级低,则不满足计算条件,将”+”压入符号栈.


    图2:

      1) 将”2” 压入数值栈。 

      2) 将”*”与”+”比较优先级,算得”+”优先级低于”*”,则不满足计算条件,将”*”压入符号栈。 


    图3:

      1) 将 “5”压入数植栈。 2) 将“*“与”)”比较优先级,得出”*”比”)”优先级要高。进行计算,将”*”出栈、”5”、”2”出栈,参与计算


    图4:

      1) 将 2*5 =10的结果压入数值栈。 

      2) (递归)比较 “+”与”)”优先级,得出”+”比”)”优先级要高。再进行计算,将”+”出栈、”10”、”6”出栈,参与计算。


    图 5:

      1) 将 6+10 =16的结果压入数值栈。

      2) (递归)比较 “)”与”(”优先级,得出两者可以对消,将”(”符号出栈,与”)”对消,继续取下一个符号。


    图6:

      1) 将”/”入符号栈。 

      2)将”4”入数值栈。

      3) 发现””算式结束符,则进行计算, 将 “/”、”4’、”16”出栈,参与计算。


    图7:

      1) 将计算结果压入数值栈。

      成功了! 辛苦的计算工作终于干完了,看起来比人脑计算复杂多了:)

       第二种算法

      第二种方法,我们简单的提一下,在这里不作详细过程的叙述。第二种,就是使用树的方式,将一个算式组织成一定规律的树,之后,再进行遍历计算即得得到结果。还是以上面的算式作例子,最终形成的树的样式:(注意“()”这个符号要特殊处理)


    图8:

      使用树的深度遍历即可算出最终的结果。


     本文,给出使用栈处理四则运算的C#实现方法,如下:

    CalUtility.cs

    using System;
    namespace Calculate
    {
     /// <summary>
     /// CalUtility 的摘要说明。
     /// 读算式辅助工具
     /// </summary>

     public class CalUtility
     {
      System.Text.StringBuilder StrB;
      private int iCurr=0;
      private int iCount=0;

      /// <summary>
      /// 构造方法
      /// </summary>

      public CalUtility(string calStr)
      {
       StrB = new System.Text.StringBuilder(calStr.Trim());
       iCount = System.Text.Encoding.Default.GetByteCount(calStr.Trim());
      }

      /// <summary>
      /// 取段,自动分析数值或计算符
      /// </summary>
      /// <returns></returns>

      public string getItem()
      {
       //结束了
       if(iCurr==iCount)
        return "";
       char ChTmp = StrB[iCurr];
       bool b=IsNum(ChTmp);
       if(!b)
       {
        iCurr++;
        return ChTmp.ToString();
       }
       string strTmp="";
       while(IsNum(ChTmp)==b && iCurr<iCount)
       {
        ChTmp = StrB[iCurr];
        if(IsNum(ChTmp)==b)
         strTmp +=ChTmp;
        else
         break;
        iCurr++;
       }
       return strTmp;
      }

      /// <summary>
      /// 是否是数字
      /// </summary>
      /// <param name="c">内容</param>
      /// <returns></returns>

      public bool IsNum(char c)
      {
       if((c>=’0’ && c<=’9’)|| c==’.’)
       {
        return true;
       }
       else
       {
        return false;
       }
      }

      /// <summary>
      /// 是否是数字
      /// </summary>
      /// <param name="c">内容</param>
      /// <returns></returns>

      public bool IsNum(string c)
      {
       if(c.Equals(""))
        return false;
       if((c[0]>=’0’ && c[0]<=’9’)|| c[0]==’.’)
       {
        return true;
       }
       else
       {
        return false;
       }
      }

      /// <summary>
      /// 比较str1和str2两个运算符的优先级,ture表示str1高于str2,false表示str1低于str2
      /// </summary>
      /// <param name="str1">计算符1</param>
      /// <param name="str2">计算符2</param>
      /// <returns></returns>

      public bool Compare(string str1,string str2)
      { 
       return getPriority(str1)>=getPriority(str2);
      }

      /// <summary>
      /// 取得计算符号的优先级
      /// </summary>
      /// <param name="str">计算符</param>
      /// <returns></returns>

      public int getPriority(string str)
      {
       if(str.Equals(""))
       {
        return -1;
       }
       if(str.Equals("("))
       {
        return 0;
       }
       if(str.Equals("+")||str.Equals("-"))
       {
        return 1;
       }
       if(str.Equals("*")||str.Equals("/"))
       {
        return 2;
       }
       if(str.Equals(")"))
       {
        return 0;
       }
       return 0;
      }
     }
    }

    IOper.cs
    using System;

    namespace Calculate
    {
     /// <summary>
     /// IOper 的摘要说明。
     /// 计算符接口
     /// </summary>

     public interface IOper
     {
      /// <summary>
      /// 计算符计算接口计算方法
      /// </summary>
      /// <param name="o1">参数1</param>
      /// <param name="o2">参数2</param>
      /// <returns></returns>
      object Oper(object o1,object o2);
     }
    }

    Opers.cs
    using System;

    namespace Calculate
    {
     /// <summary>
     /// Opers 的摘要说明。
     /// 各类计算符的接口实现,加减乘除
     /// </summary>

     public class OperAdd:IOper
     {
      public OperAdd()
      {
       //
       // TODO: 在此处添加构造函数逻辑
       //
      }
      #region IOper 成员

     public object Oper(object o1, object o2)
     {
      Decimal d1 = Decimal.Parse(o1.ToString());
      Decimal d2 = Decimal.Parse(o2.ToString());
      return d1+d2;
     }

     #endregion
    }

    public class OperDec:IOper
    {
     public OperDec()
     {
      //
      // TODO: 在此处添加构造函数逻辑
      //
     }
     #region IOper 成员

     public object Oper(object o1, object o2)
     {
      Decimal d1 = Decimal.Parse(o1.ToString());
      Decimal d2 = Decimal.Parse(o2.ToString());
      return d1-d2;
     }
     #endregion
    }

    public class OperRide:IOper
    {
     public OperRide()
     {
      //
      // TODO: 在此处添加构造函数逻辑
      //
     }
     #region IOper 成员

     public object Oper(object o1, object o2)
     {
      Decimal d1 = Decimal.Parse(o1.ToString());
      Decimal d2 = Decimal.Parse(o2.ToString());
      return d1*d2;
     }
     #endregion
    }

    public class OperDiv:IOper
    {
     public OperDiv()
     {
      //
      // TODO: 在此处添加构造函数逻辑
      //
     }
     #region IOper 成员

     public object Oper(object o1, object o2)
     {
      Decimal d1 = Decimal.Parse(o1.ToString());
      Decimal d2 = Decimal.Parse(o2.ToString());
      return d1/d2;
     }

     #endregion
    }

    }

    OperFactory.cs
    using System;

    namespace Calculate
    {
     /// <summary>
     /// OperFactory 的摘要说明。
     /// 计算符接口工厂
     /// </summary>
     public class OperFactory
     {
      public OperFactory()
      {
      }
      public IOper CreateOper(string Oper)
      {
       if(Oper.Equals("+"))
       {
        IOper p = new OperAdd();
        return p;
       }
       if(Oper.Equals("-"))
       {
        IOper p = new OperDec();
        return p;
       }
       if(Oper.Equals("*"))
       {
        IOper p = new OperRide();
        return p;
       }
       if(Oper.Equals("/"))
       {
        IOper p = new OperDiv();
        return p;
       }
       return null;
      }
     }
    }

    Calculate.cs
    using System;
    using System.Collections;

    namespace Calculate
    {
     /// <summary>
     /// Calculate 的摘要说明。
     /// 计算实现主类
     /// </summary>
     public class Calculate
     {
      /// <summary>
      /// 算术符栈
      /// </summary>
      private ArrayList HList;
      /// <summary>
      /// 数值栈
      /// </summary>
      public ArrayList Vlist;
      /// <summary>
      /// 读算试工具
      /// </summary>
      private CalUtility cu;
      /// <summary>
      /// 运算操作器工厂
      /// </summary>
      private OperFactory of;
      /// <summary>
      /// 构造方法
      /// </summary>
      /// <param name="str">算式</param>
      public Calculate(string str)
      {
       //
       // TODO: 在此处添加构造函数逻辑
       //
       HList = new ArrayList();
       Vlist = new ArrayList();
       of = new OperFactory();
       cu = new CalUtility(str);
      }

      /// <summary>
      /// 开始计算
      /// </summary>

         public object DoCal()
            {
                string strTmp = cu.getItem();
                bool lastIsNum = false;
                while (true)
                {
                    if (cu.IsNum(strTmp))
                    {
                        //如果是数值,则写入数据栈
                        Vlist.Add(strTmp);
                        lastIsNum = true;
                    }
                    else
                    {
                        //数值
                        if (!lastIsNum)
                        {
                            HList.Add(strTmp);
                        }

                        else
                        {
                           lastIsNum
    = Cal(strTmp);
                        }
                    }
                    if (strTmp.Equals(""))
                        break;
                    strTmp = cu.getItem();
                }
                return Vlist[0];
            }


            /// <summary>
            /// 计算
            /// </summary>
            /// <param name="str">计算符</param>


            private bool Cal(string str)
            {
                //符号表为空,而且当前符号为"",则认为已经计算完毕
                if (str.Equals("") && HList.Count == 0)
                    return false;
                if (HList.Count > 0)
                {
                    //符号是否可以对消?
                    if (HList[HList.Count - 1].ToString().Equals("(") && str.Equals(")"))
                    {
                        HList.RemoveAt(HList.Count - 1);
                        if (HList.Count > 0)
                        {
                            str = HList[HList.Count - 1].ToString();
                            HList.RemoveAt(HList.Count - 1);
                            Cal(str);
                        }
                        return true;
                    }
                    //比较优先级
                    if (cu.Compare(HList[HList.Count - 1].ToString(), str))
                    {
                        //如果优先,则计算
                            IOper p = of.CreateOper(HList[HList.Count - 1].ToString());
                            if (p != null)
                            {
                                Vlist[Vlist.Count - 2] = p.Oper(Vlist[Vlist.Count - 2], Vlist[Vlist.Count - 1]);
                                HList.RemoveAt(HList.Count - 1);
                                Vlist.RemoveAt(Vlist.Count - 1);
                                Cal(str);
                            }
                            return true;
                    }
                    if (!str.Equals(""))
                        HList.Add(str);
                }
                else
                {
                    if (!str.Equals(""))
                        HList.Add(str);
                }
                return false;
            }
     }
    }

      后记

      使用这种方法,我们可以完成更复杂的混合运算,比如说:可以支持函数运算的混合运算,更进一步,可以支持自定义函数的混合运算,最终可以将这种算法运用在自定义报表、工资处理等等 应用 领域,很希望有相关兴趣的朋友与我交流。

    展开全文
  • Grasshopper运算器名称总结 Params:参数 Geometry:几何体 Box: 立方体 BRep: 边界表现形式 Circle: 圆 Circular Arc: 圆弧 Curve: 曲线 Geometry: 几何 Line: 线 Mesh: 网格面 Plane: 平面 Point: 点 Surface: 表面 ...
  • Visual Basic 6.0(vb6)中的运算符优先顺序是什么?尤其是逻辑运算符。算术运算优先顺序^-(一元否定)*、/。\Mod+、-(二进制加减)&比较运算优先顺序=<><><=>=Like、Is。逻辑运算优先顺序...
  • VB脚本编辑在KDI模块中,可以利用VB语言实现一些知识工程阵列无法实现或实现起来比较麻烦的功能。以下为体积布尔运算的实现脚本。 VB脚本体积布尔运算 Dim editor1 As Editor Set editor1 = CATIA.ActiveEditor ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,263
精华内容 4,105
关键字:

vb四则运算器