boost正規表現文字列が正しいかどうかを判断する四則演算

正規表現を使用して、文字列が4つの混合演算規則に合致するかどうかを判断します.

"[^0-9\\.\\+\\-\\*\\/\\(\\)]"   //                 
"[\\+\\-\\*\\/][)]|[)][0-9.]"   // )       +-*/  )     
"[0-9\\.][(]|[(][\\*\\/]"         // (      (       */
"\\.[0-9]*\\."                      //        2 (    )
"[\\+\\-\\*\\/]\\.{1,}[\\+\\-\\*\\/]" //              


"[\\+\\-\\*\\/][\\*\\/]|[\\+\\-\\*\\/][\\+\\-][\\+\\-\\*\\/]"      //         ,   */      
"^[\\*\\/]|[\\+\\-\\*\\/]$"     //              

以上の条件を満たすのは、正しい4つの混合演算文字列だろう.漏れがあれば指摘を貼ってください.ありがとうございます.
次はプログラムです.

//        TRUE，         FALSE
BOOL Arithmetic::IsExpressionsTrue(void)
{
    int length = m_expression.GetLength();
    if (length <= 0)
    {
        m_szError += _T("      0
");
        return FALSE;
    }
    if (OnlyDecimalPointIn2Opetator())
    {
        m_szError += _T("          ！
");
        return FALSE;
    }
    if (IsHaveOtherChar())
    {
        m_szError += _T("          
");
        return FALSE;
    }
    if (!IsArithmeticPointRight())
    {
        m_szError += _T("        1 
");
        return FALSE;
    }
    if (!VerifyParenthesis())
    {
        m_szError += _T("         
");
        return FALSE;
    }
    if (ParenthesisErroe())
    {
        m_szError += _T("            ：  (   )  
");
        return FALSE;
    }
    if (BeginOrEndHaveOperator())
    {
        m_szError += _T("             
");
        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;
}