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

以下是使用C++实现的代码，可以实现中缀表达式转换为后缀表达式，并计算出结果：

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

using namespace std;

bool isOperator(char c) {
    return (c == '+' || c == '-' || c == '*' || c == '/');
}

int getPriority(char op) {
    int priority = 0;
    if (op == '+' || op == '-') {
        priority = 1;
    }
    else if (op == '*' || op == '/') {
        priority = 2;
    }
    return priority;
}

string infixToPostfix(string infix) {
    stack<char> s;
    string postfix;
    map<char, int> priorityMap;
    priorityMap['+'] = priorityMap['-'] = 1;
    priorityMap['*'] = priorityMap['/'] = 2;
    for (int i = 0; i < infix.length(); i++) {
        char c = infix[i];
        if (isdigit(c)) {
            postfix += c;
        }
        else if (isalpha(c)) {
            postfix += c;
        }
        else if (c == '(') {
            s.push(c);
        }
        else if (c == ')') {
            while (!s.empty() && s.top() != '(') {
                postfix += s.top();
                s.pop();
            }
            if (!s.empty() && s.top() == '(') {
                s.pop();
            }
            else {
                cout << "Error: Parentheses mismatch!" << endl;
                return "";
            }
        }
        else if (isOperator(c)) {
            while (!s.empty() && s.top() != '(' && priorityMap[s.top()] >= priorityMap[c]) {
                postfix += s.top();
                s.pop();
            }
            s.push(c);
        }
        else {
            cout << "Error: Invalid character!" << endl;
            return "";
        }
    }
    while (!s.empty()) {
        if (s.top() == '(') {
            cout << "Error: Parentheses mismatch!" << endl;
            return "";
        }
        postfix += s.top();
        s.pop();
    }
    return postfix;
}

double evaluatePostfix(string postfix) {
    stack<double> s;
    for (int i = 0; i < postfix.length(); i++) {
        char c = postfix[i];
        if (isdigit(c)) {
            s.push(c - '0');
        }
        else if (isalpha(c)) {
            double value;
            cout << "Enter value for " << c << ": ";
            cin >> value;
            s.push(value);
        }
        else if (isOperator(c)) {
            double operand2 = s.top();
            s.pop();
            double operand1 = s.top();
            s.pop();
            switch (c) {
            case '+':
                s.push(operand1 + operand2);
                break;
            case '-':
                s.push(operand1 - operand2);
                break;
            case '*':
                s.push(operand1 * operand2);
                break;
            case '/':
                if (operand2 != 0) {
                    s.push(operand1 / operand2);
                }
                else {
                    cout << "Error: Division by zero!" << endl;
                    return 0;
                }
                break;
            }
        }
    }
    return s.top();
}

int main() {
    string infix;
    char choice;
    do {
        cout << "Enter an infix expression: ";
        cin >> infix;
        string postfix = infixToPostfix(infix);
        if (postfix != "") {
            cout << "Postfix expression: " << postfix << endl;
            double result = evaluatePostfix(postfix);
            if (result != 0) {
                cout << "Result: " << result << endl;
            }
        }
        cout << "Do you want to continue (y/n)? ";
        cin >> choice;
    } while (choice == 'y' || choice == 'Y');
    return 0;
}

使用该代码时，程序会要求输入一个中缀表达式，并将其转换为后缀表达式输出，并要求输入变量的值，最终输出结果。如果输入的表达式中有错误，则会给出相应的提示并重新要求输入表达式。同时，程序会询问是否继续执行，如果回答“是”，则可以继续输入表达式并计算，否则程序结束运行。