谁能给一个计算器代码，能计算带括号的四则运算，（拜求）

[macro_lu]

如题

[qpx1125]

出自C++之父Bjarne Stroustrup的《c++程序设计语言》
高人写的不是太好懂。。。。。。用了递归下降的语法分析。。。。编译原理LZ学过没？

#include <cstdlib>
#include <iostream>
#include <map>
#include <string>

using namespace std;

enum Token_value {
     NAME,       NUMBER,    END,
     PLUS='+',   MINUS='-', MUL='*',    DIV='/',
     PRINT=';',  ASSIGN='=',LP='(',     RP=')'
};
Token_value curr_tok = PRINT;

double number_value;
string string_value;
map<string,double> table;
int no_of_errors;

double error(const string& s)
{
       no_of_errors++;
       cerr<<"error:"<<s<<'\n';
       return 1;
}

Token_value get_token()
{
            char ch=0;
            cin>>ch;
            
            switch(ch) {
            case 0:
                 return curr_tok=END;
            case ';':
            case '*':
            case '/':
            case '+':
            case '-':
            case '(':
            case ')':
            case '=':
                 return curr_tok=Token_value(ch);
            case '0': case '1': case '2': case '3': case '4':
            case '5': case '6': case '7': case '8': case '9':
            case '.':
                 cin.putback(ch);
                 cin>>number_value;
                 return curr_tok=NUMBER;
            
            default:
                    if (isalpha(ch)) {
                       cin.putback(ch);
                       cin>>string_value;
                       return curr_tok=NAME;
                       }
                    error("bad token");
                    return curr_tok=PRINT;
            }
}                                                                                                            
                   
double expr(bool);
double prim(bool get)
{
       if (get) get_token();
       
       switch (curr_tok) {
              case NUMBER:
              {    double v = number_value;
                   get_token();
                   return v;
              }
              case NAME:
              {
                   double& v = table[string_value];
                   if (get_token() == ASSIGN) v = expr(true);
                   return v;
              }
              case MINUS:
                   return -prim(true);
              case LP:
              {
                   double e = expr(true);
                   if (curr_tok != RP) return error(") expected");
                   get_token();
                   return e;
              }
              default:
                      return error("primary expected");
       }
}

double term(bool get)
{
       double left = prim(get);
       
       for (;;) {
           switch (curr_tok) {
           case MUL:
                left *= prim(true);
                break;
           case DIV:
                if (double d = prim(true)) {
                           left /= d;
                           break;
                }
           default:
                   return left;
           }
       }
}
                   
double expr(bool get)
{
       double left = term(get); 
       for (;;)
           switch (curr_tok) {
           case PLUS:
                left += term(true);
                break;
           case MINUS:
                left -= term(true);
                break;
           default:
                   return left;
           }        
}       



int main(int argc, char *argv[])
{
    table["pi"] = 3.1415926535897932385;
    table["e"] = 2.7182818284590452354;
    
    while (cin) {
          get_token();
          if (curr_tok == END) break;
          if (curr_tok == PRINT) continue;
          cout<<expr(false)<<'\n';
    }  

    system("PAUSE");
    return no_of_errors;
}

[qpx1125]

在DEVC++下编译通过的，如果通不过LZ的编译器，把开头的#include <cstdlib>
和main的system("PAUSE"); return no_of_errors; 删掉，最后return 0；

支持如下语句：
a=(1+3)*6/pi; //要有分号结束
b=a-e; //a是上一行定义的，e是自然对数的底数

不是重载运算符的问题，运算符重载是写程序时为了给程序员方便而用的。这里是要对用户的输入进行分析，是另一码事

[sunshyran]

做两件事，
提取符号，包括运算符，（），操作数。是一件琐碎易错的事情。
转换表达式：转成逆波兰表达式，然后计算（可以用栈实现，比二叉树代码要少一些。数据结构书上都有源码）

[AlanBruce]

//definition.h

#ifndef DEFINITION_H_INCLUDED
#define DEFINITION_H_INCLUDED

using namespace std;

class Complex
{
public:
    Complex();
	Complex(double r,double v);
	Complex operator+(Complex right);
	Complex operator-(Complex right);
	Complex operator*(Complex right);
	friend ostream &operator<<(ostream &output,Complex &a);
	friend istream &operator>>(istream &input,Complex &a);
	bool operator!=(const Complex& b);
	bool operator==(const Complex& b);
	void print();
private:
	double Real;
	double Imaginary;
};
#endif // DEFINITION_H_INCLUDED

//realization.cpp

#include <iomanip>
#include "definition.h"
#include <iostream>
using namespace std;


Complex::Complex()
{
	
}
Complex::Complex(double r,double v)
{
	Real = r;
	Imaginary = v;
	return;
}

Complex Complex::operator+(Complex right)
{
	Real  = Real + right.Real;
	Imaginary = Imaginary + right.Imaginary;
	return *this;
}

Complex Complex::operator-(Complex right)
{
	Real = Real - right.Real;
	Imaginary = Imaginary - right.Imaginary;
	return *this;
}

Complex Complex::operator*(Complex right)
{
	Real = Real * right.Real - Imaginary * right.Imaginary ;
	Imaginary = Real * right.Imaginary + Imaginary * right.Real;
	return *this;
}

ostream &operator<<(ostream &output,Complex &a)
{
	output<<a.Real<<"+"<<a.Imaginary<<"i";
	return output;
}

istream &operator>>(istream &input,Complex &complex2)
{
	input>>setw(1)>>complex2.Real;
	input.ignore();
	input>>setw(1)>>complex2.Imaginary;
	input.ignore();
	return input;
}

bool Complex::operator!=(const Complex &right)
{
	if(Real != right.Real ||Imaginary != right.Imaginary)
		return true;
	else
		return false;
}

bool Complex::operator==(const Complex & right)
{
	if(Real == right.Real && Imaginary == right.Imaginary)
		return true;
	else
		return false;
}

void Complex::print()
{
	cout<<"%lf + %lfi"<<Real<<Imaginary<<std::endl;
}

//main.cpp

#include <iostream>
#include "definition.h"
using namespace std;

int main()
{
	Complex c1,c2(2,3),c3;
	cin>>c3;
	cout<<"c3=";
	c3.print();
	if(c3 == c2)
		cout<<"c3 = c2";
	else
		cout<<"c3 != c2";
	c1 = c3 - c2;
	c1.print();
	c1 = c3 + c2;
	c1.print();
	c1 = c3 * c2;
	c1.print();
	return 0;
}

这是刚才给别人改的复数四则运算代码

你加一个基类也就够用啦

[ypb362148418]

将符号全部重载了就行了，这样的问题还是自己想吧，锻炼一下，实在写不出，可以在网上搜一下，100分问这个问题的确有点多啊

[dyy415]

让我看一眼啊~~~