boost正则表达式判断字符串是不是正确的四则运算

使用正则表达式判断字符串是否符合四则混合运算规则。

"[^0-9\\.\\+\\-\\*\\/\\(\\)]"   // 除了数字小数点和运算符之外的符号
"[\\+\\-\\*\\/][)]|[)][0-9.]"   // )前面有运算符号+-*/  )后面有数字
"[0-9\\.][(]|[(][\\*\\/]"         // (前面有数字 (后面有运算符号*/
"\\.[0-9]*\\."                      // 数字小数点超过2个(包括两个)
"[\\+\\-\\*\\/]\\.{1,}[\\+\\-\\*\\/]" // 两个运算符号只间只有小数点


"[\\+\\-\\*\\/][\\*\\/]|[\\+\\-\\*\\/][\\+\\-][\\+\\-\\*\\/]"      // 三个运算符号连接, 两个*/运算符号连接
"^[\\*\\/]|[\\+\\-\\*\\/]$"     // 表达式前面或后面有运算符号

符合以上条件的大概就是正确的四则混合运算字符串了。如有遗漏请回贴指正谢谢。

下面是程序：

// 表达式正确返回TRUE，表达式中有错误返回FALSE
BOOL Arithmetic::IsExpressionsTrue(void)
{
    int length = m_expression.GetLength();
    if (length <= 0)
    {
        m_szError += _T("表达式长度为0\n");
        return FALSE;
    }
    if (OnlyDecimalPointIn2Opetator())
    {
        m_szError += _T("运算符号间只有小数点！\n");
        return FALSE;
    }
    if (IsHaveOtherChar())
    {
        m_szError += _T("表达式中存在非法字符\n");
        return FALSE;
    }
    if (!IsArithmeticPointRight())
    {
        m_szError += _T("数字中小数点多于1个\n");
        return FALSE;
    }
    if (!VerifyParenthesis())
    {
        m_szError += _T("表达式中括号不匹配\n");
        return FALSE;
    }
    if (ParenthesisErroe())
    {
        m_szError += _T("括号使用有问题有如下格式：数字(运算符)数字\n");
        return FALSE;
    }
    if (BeginOrEndHaveOperator())
    {
        m_szError += _T("表达式开始或结束有运算符号\n");
        return FALSE;
    }


    return TRUE;
}

// 计算结果,验证字符串付合正确的四则运算规则后调用才能得到正确结果.计算正确输出TRUE，结果在outValue中
BOOL Arithmetic::Calculation(double& outValue)
{
    typedef BOOL (PASCAL EXPORT *GetArithmeticResult)(const CString&, double&);
    HINSTANCE hDLL = NULL;
    hDLL = LoadLibrary(_T("GetArithmeticResult.dll"));
    if (NULL != hDLL)
    {
        GetArithmeticResult GetValue =(GetArithmeticResult)GetProcAddress(hDLL, _T("GetArithmeticResult"));
        if (NULL != GetValue )
        {
            if (GetValue(m_expression, outValue))
            {
                return TRUE; // _T("运算正确");
            }
            else
            {
                m_szError += _T("运算出现错误！");
                return FALSE;// 
            }
        }
        else
        {
            m_szError += _T("取GetArithmeticResult函数错误！");
            return FALSE; // 
        }
        FreeLibrary(hDLL);//卸载MyDll.dll文件；
    }
    else
    {
        m_szError += _T("加载GetArithmeticResult.dll错误！");
        return FALSE; // 
    }

}

// 验证括号符合表达式规则返回TRUE，不符合返回FALSE
BOOL Arithmetic::VerifyParenthesis(void)
{
    boost::regex reg(_T("[(][)]"));
    std::string str;
    str = m_expression;
    if (boost::regex_search(str, reg))
    {
        return FALSE;
    }
    int n = 0; // 记录左括号个数

    int length = m_expression.GetLength();
    for (int i = 0; i < length; ++i)
    {
        if ('(' == m_expression[i])
        {
            ++n;
        }
        else if (')' == m_expression[i])
        {
            if (0 == n)
            {
                return FALSE;
            }
            else
            {
                --n;
            }
        }
                
    }
    if (0 == n)
    {
        return TRUE;
    }
    return FALSE;
}

// 检查表达式中各字符是否有其它字符,不允许有+*-/.0-9()外的字符。有其它字符返回TRUE,没有返回FALSE
BOOL Arithmetic::IsHaveOtherChar(void)
{
    boost::regex reg(_T("[^\\+\\-\\*\\/\\(\\)\\.0-9]"));
    std::string str;
    str = m_expression;
    if (boost::regex_search(str, reg))
    {
        return TRUE;
    }
    return FALSE;
}

// 检查表达式前面或后面有没有运算符号，有返回TRUE，没有返回FALSE
BOOL Arithmetic::BeginOrEndHaveOperator(void)
{
    boost::regex reg(_T("^[\\*\\/]|[\\+\\-\\*\\/]$"));
    std::string str;
    str = m_expression;
    if (boost::regex_search(str, reg))
    {
        return TRUE;
    }
    return FALSE;
}

// 检查运算符号是否过多两个*或/相连 或3个+或-相连
BOOL Arithmetic::IsOperatorTooMuch(void)
{
    boost::regex reg(_T("[\\+\\-\\*\\/][\\*\\/]|[\\+\\-\\*\\/][\\+\\-][\\+\\-\\*\\/]"));
    std::string str;
    str = m_expression;
    if (boost::regex_search(str, reg))
    {
        return TRUE;
    }
    return FALSE;
}

// 左括号前面有数字或后面有运算符号*/  例如9(*,  或右括号前面有运算符+-*/或后面有数字 例如 -)7 
// 有返回TRUE，没有返回FALSE
BOOL Arithmetic::ParenthesisErroe(void)
{
    boost::regex reg(_T("[0-9\\.][(]|[(][\\*\\/]|[\\+\\-\\*\\/][)]|[)][0-9\\.]"));
    std::string str;
    str = m_expression;
    if (boost::regex_search(str, reg))
    {
        return TRUE;
    }
    return FALSE;
}

// 检查小数点是否使用正确，正确返回TRUE，错误返回FALSE
BOOL Arithmetic::IsArithmeticPointRight(void)
{
    boost::regex reg(_T("[\\.][0-9]*[\\.]"));
    std::string str;
    str = m_expression;
    if (boost::regex_search(str, reg))
    {
        return FALSE;
    }
    return TRUE;
}
// 两个运算符号间只有小数点,返回TRUE，否则返回FALSE
BOOL Arithmetic::OnlyDecimalPointIn2Opetator(void)
{
    boost::regex reg(_T("[\\+\\-\\*\\/]\\.{1,}[\\+\\-\\*\\/]"));  // 两个运算符号只间只有小数点
    std::string str;
    str = m_expression;
    if (boost::regex_search(str, reg))
    {
        return TRUE;
    }
    return FALSE;
}