使用C++选择循环结构实现以下需求：1.对于给定的一个表达式，表达式中可以包括常数、算术运行符（“+”、“-”、“*”、“/”）和括号，编写一个简单计算器计算表达式的值。 2.从键盘输入一个正确的中缀表达式，将中缀表达式转换为对应的后缀表达式输出，并计算后缀表达式的值。 3.对于输入表达式时发生的简单错误如：括号不匹配、除数不能为0、有无效字符能够给出提示，能够给出提示并可以重新输入新表达式循环选择功能 4.中缀表达式中可以包括单个字母表示的变量。

以下是使用C++实现上述需求的代码：

#include <iostream>
#include <stack>
#include <map>
#include <string>
#include <cmath>

using namespace std;

// 判断字符是否是数字
bool isNumber(char c) {
    return c >= '0' && c <= '9';
}

// 判断字符是否是操作符
bool isOperator(char c) {
    return c == '+' || c == '-' || c == '*' || c == '/';
}

// 获取操作符的优先级
int getPriority(char op) {
    switch (op) {
        case '+':
        case '-':
            return 1;
        case '*':
        case '/':
            return 2;
        default:
            return 0;
    }
}

// 中缀表达式转后缀表达式
string toPostfix(string infix) {
    stack<char> opStack;
    string postfix = "";
    for (int i = 0; i < infix.length(); i++) {
        char c = infix[i];
        if (isNumber(c) || isalpha(c)) {  // 如果是数字或字母，则直接加入后缀表达式
            postfix += c;
        } else if (isOperator(c)) {  // 如果是操作符
            while (!opStack.empty() && isOperator(opStack.top()) && getPriority(opStack.top()) >= getPriority(c)) {
                postfix += opStack.top();  //将优先级大于等于c的操作符弹出并加入后缀表达式
                opStack.pop();
            }
            opStack.push(c);  // 将c压入操作符栈
        } else if (c == '(') {  // 如果是左括号
            opStack.push(c);
        } else if (c == ')') {  // 如果是右括号
            while (!opStack.empty() && opStack.top() != '(') {
                postfix += opStack.top();  // 将左括号前的操作符加入后缀表达式
                opStack.pop();
            }
            if (!opStack.empty() && opStack.top() == '(') {
                opStack.pop();  // 将左括号弹出
            } else {
                return "error: mismatched parentheses";
            }
        } else {
            return "error: invalid character";
        }
    }
    while (!opStack.empty()) {
        if (opStack.top() == '(') {
            return "error: mismatched parentheses";
        }
        postfix += opStack.top();  // 将操作符栈中剩余的操作符加入后缀表达式
        opStack.pop();
    }
    return postfix;
}

// 计算后缀表达式的值
double calculate(string postfix) {
    stack<double> numStack;
    map<char, double> varMap;
    for (int i = 0; i < postfix.length(); i++) {
        char c = postfix[i];
        if (isNumber(c)) {  // 如果是数字
            double num = c - '0';
            while (i + 1 < postfix.length() && isNumber(postfix[i + 1])) {
                num = num * 10 + (postfix[i + 1] - '0');
                i++;
            }
            numStack.push(num);
        } else if (isalpha(c)) {  // 如果是字母
            if (varMap.find(c) == varMap.end()) {
                double value;
                cout << "Enter the value of " << c << ": ";
                cin >> value;
                varMap[c] = value;
            }
            numStack.push(varMap[c]);
        } else if (isOperator(c)) {  // 如果是操作符
            if (numStack.size() < 2) {
                return NAN;
            }
            double num2 = numStack.top();
            numStack.pop();
            double num1 = numStack.top();
            numStack.pop();
            switch (c) {
                case '+':
                    numStack.push(num1 + num2);
                    break;
                case '-':
                    numStack.push(num1 - num2);
                    break;
                case '*':
                    numStack.push(num1 * num2);
                    break;
                case '/':
                    if (num2 == 0) {
                        return NAN;
                    }
                    numStack.push(num1 / num2);
                    break;
            }
        } else {
            return NAN;
        }
    }
    if (numStack.size() == 1) {
        return numStack.top();
    } else {
        return NAN;
    }
}

int main() {
    while (true) {
        cout << "Enter an infix expression: ";
        string infix;
        getline(cin, infix);
        string postfix = toPostfix(infix);
        if (postfix.substr(0, 5) == "error") {
            cout << postfix << endl;
            continue;
        }
        cout << "Postfix expression: " << postfix << endl;
        double result = calculate(postfix);
        if (isnan(result)) {
            cout << "error: invalid expression" << endl;
            continue;
        }
        cout << "Result: " << result << endl;
        cout << "Do you want to continue? (y/n) ";
        char choice;
        cin >> choice;
        if (choice != 'y' && choice != 'Y') {
            break;
        }
        cin.ignore();
    }
    return 0;
}

这个程序使用了 `stack` 实现了中缀表达式转后缀表达式和计算后缀表达式的值。同时，使用了 `map` 存储变量的值，并且支持在程序运行时输入变量的值。程序还处理了一些错误情况，并能够循环运行，直到用户选择退出。