“桌面计算器”从标准输入设备读入一个（数值计算）表达式，计算它的值后从标准输出设备输出；读入的也可以是一个赋值语句：左端是一个符号名，右端是表达式。 表达式中可以有四则运算符、括号、整数/实数值、已经赋值的符号名和预定义的符号常量（ pi 和 e ），也可以只有单个的整数/实数值。 发现输入内容与文法不符或将导致非法计算时，则从标准输出设备输出出错提示，并计算出错次数。设计满足以上条件的c++代码

以下是一个简单的C++代码实现，可以实现基本的表达式计算和赋值语句：

#include<iostream>
#include<stack>
#include<map>
#include<string>
#include<cmath>
using namespace std;

map<string, double> var; // 存储变量值
const double pi = acos(-1.0); // 定义pi
const double e = exp(1.0); // 定义e

// 判断是否为数字
bool is_digit(char ch) {
    return ch >= '0' && ch <= '9';
}

// 判断是否为字母
bool is_alpha(char ch) {
    return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z');
}

// 判断是否为操作符
bool is_operator(char ch) {
    return ch == '+' || ch == '-' || ch == '*' || ch == '/';
}

// 判断是否为括号
bool is_bracket(char ch) {
    return ch == '(' || ch == ')';
}

// 获取操作符的优先级
int get_priority(char op) {
    if (op == '+' || op == '-') {
        return 1;
    }
    if (op == '*' || op == '/') {
        return 2;
    }
    return 0;
}

// 计算表达式
double calculate(string expr) {
    stack<double> num_stack; // 存储数字
    stack<char> op_stack; // 存储操作符
    int i = 0;
    while (i < expr.size()) {
        // 处理空格
        if (expr[i] == ' ') {
            i++;
            continue;
        }
        // 处理数字
        if (is_digit(expr[i])) {
            double num = 0;
            while (i < expr.size() && is_digit(expr[i])) {
                num = num * 10 + (expr[i] - '0');
                i++;
            }
            if (i < expr.size() && expr[i] == '.') {
                i++;
                double k = 0.1;
                while (i < expr.size() && is_digit(expr[i])) {
                    num += k * (expr[i] - '0');
                    k *= 0.1;
                    i++;
                }
            }
            num_stack.push(num);
            continue;
        }
        // 处理符号
        if (is_alpha(expr[i])) {
            string name;
            while (i < expr.size() && (is_alpha(expr[i]) || is_digit(expr[i]) || expr[i] == '_')) {
                name += expr[i];
                i++;
            }
            // 判断是否为预定义常量
            if (name == "pi") {
                num_stack.push(pi);
                continue;
            }
            if (name == "e") {
                num_stack.push(e);
                continue;
            }
            // 判断是否为变量
            if (var.count(name) > 0) {
                num_stack.push(var[name]);
                continue;
            }
            cout << "error: undefined symbol '" << name << "'" << endl;
            return -1;
        }
        // 处理操作符
        if (is_operator(expr[i])) {
            while (!op_stack.empty() && is_operator(op_stack.top()) && get_priority(op_stack.top()) >= get_priority(expr[i])) {
                char op = op_stack.top();
                op_stack.pop();
                double b = num_stack.top();
                num_stack.pop();
                double a = num_stack.top();
                num_stack.pop();
                if (op == '+') num_stack.push(a + b);
                if (op == '-') num_stack.push(a - b);
                if (op == '*') num_stack.push(a * b);
                if (op == '/') num_stack.push(a / b);
            }
            op_stack.push(expr[i]);
            i++;
            continue;
        }
        // 处理左括号
        if (expr[i] == '(') {
            op_stack.push(expr[i]);
            i++;
            continue;
        }
        // 处理右括号
        if (expr[i] == ')') {
            while (!op_stack.empty() && op_stack.top() != '(') {
                char op = op_stack.top();
                op_stack.pop();
                double b = num_stack.top();
                num_stack.pop();
                double a = num_stack.top();
                num_stack.pop();
                if (op == '+') num_stack.push(a + b);
                if (op == '-') num_stack.push(a - b);
                if (op == '*') num_stack.push(a * b);
                if (op == '/') num_stack.push(a / b);
            }
            if (op_stack.empty()) {
                cout << "error: unmatched bracket" << endl;
                return -1;
            }
            op_stack.pop();
            i++;
            continue;
        }
        cout << "error: invalid character '" << expr[i] << "'" << endl;
        return -1;
    }
    while (!op_stack.empty()) {
        char op = op_stack.top();
        op_stack.pop();
        double b = num_stack.top();
        num_stack.pop();
        double a = num_stack.top();
        num_stack.pop();
        if (op == '+') num_stack.push(a + b);
        if (op == '-') num_stack.push(a - b);
        if (op == '*') num_stack.push(a * b);
        if (op == '/') num_stack.push(a / b);
    }
    if (num_stack.size() != 1) {
        cout << "error: invalid expression" << endl;
        return -1;
    }
    return num_stack.top();
}

// 处理赋值语句
void assign(string expr) {
    int i = 0;
    string name;
    while (i < expr.size() && (is_alpha(expr[i]) || is_digit(expr[i]) || expr[i] == '_')) {
        name += expr[i];
        i++;
    }
    if (name.empty()) {
        cout << "error: invalid assignment" << endl;
        return;
    }
    if (i >= expr.size() || expr[i] != '=') {
        cout << "error: invalid assignment" << endl;
        return;
    }
    i++;
    double value = calculate(expr.substr(i));
    if (value == -1) {
        return;
    }
    var[name] = value;
    cout << name << " = " << value << endl;
}

int main() {
    int error_count = 0;
    while (true) {
        string expr;
        getline(cin, expr);
        if (expr.empty()) {
            continue;
        }
        if (expr == "quit") {
            break;
        }
        if (expr[0] == ':') {
            assign(expr.substr(1));
        } else {
            double value = calculate(expr);
            if (value == -1) {
                error_count++;
            } else {
                cout << value << endl;
            }
        }
    }
    cout << "error count: " << error_count << endl;
    return 0;
}

代码中使用了栈来处理中缀表达式，通过逐个读取字符并判断类型，进行计算。同时，使用了map来存储变量值，支持赋值语句。