सी ++ सरल संचालन (+, -, /, *) मूल्यांकन वर्ग

Question

मैं एक सी ++ वर्ग मैं एक परियोजना मैं पर काम कर रहा हूँ में शामिल कर सकते हैं के लिए देख रहा हूँ। कार्यक्षमता की आवश्यकता संख्यात्मक फार्म के लिए स्ट्रिंग आपरेशन के मूल्यांकन है: उदाहरण के लिए "2 + 3 * 7" का मूल्यांकन करना चाहिए 23.

लिए मुझे पता है एक दुभाषिया का एक प्रकार है कि मैं क्या पूछ रहा हूँ है, और देखते हैं कि सीएस में मेरी पृष्ठभूमि से उन्हें बनाने के लिए उपकरण बहुत खराब हैं इसलिए यदि आप मुझे तैयार कक्षा में इंगित कर सकते हैं तो मैं सराहना करता हूं।

Answer 1

यह आप क्या चाहते हैं वास्तव में क्या करना चाहिए। आपको कम से लाइव यह परीक्षण कर सकते हैं: http://www.wowpanda.net/calc

यह Reverse Polish Notation उपयोग करता है और समर्थन करता है:

• ऑपरेटर पूर्वता (5 + 5 * 5 = 30 नहीं 50)
• कोष्ठक ((5 + 5) * 5 = 50)
• निम्नलिखित ऑपरेटरों: +, -, *,/

संपादित: आप शायद ABS() तल पर निकालना चाहेंगे; मेरी जरूरतों के लिए 0 - 5 5 होना चाहिए और नहीं -5!

static bool Rpn(const string expression, vector<string> &output) 
{ 
    output.clear(); 
    char *end; 
    vector<string> operator_stack; 
    bool expecting_operator = false; 

    for (const char *ptr = expression.c_str(); *ptr; ++ptr) { 
     if (IsSpace(*ptr)) 
      continue; 

     /* Is it a number? */ 
     if (!expecting_operator) { 
      double number = strtod(ptr, &end); 
      if (end != ptr) { 
       /* Okay, it's a number */ 
       output.push_back(boost::lexical_cast<string>(number)); 
       ptr = end - 1; 
       expecting_operator = true; 
       continue; 
      } 
     } 

     if (*ptr == '(') { 
      operator_stack.push_back("("); 
      expecting_operator = false; 
      continue; 
     } 

     if (*ptr == ')') { 
      while (operator_stack.size() && operator_stack.back() != "(") { 
       output.push_back(operator_stack.back()); 
       operator_stack.pop_back(); 
      } 

      if (!operator_stack.size()) 
       return false; /* Mismatched parenthesis */ 

      expecting_operator = true; 
      operator_stack.pop_back(); /* Pop '(' */ 
      continue; 
     } 

     if (*ptr == '+' || *ptr == '-') { 
      while (operator_stack.size() && IsMathOperator(operator_stack.back())) { 
       output.push_back(operator_stack.back()); 
       operator_stack.pop_back(); 
      } 

      operator_stack.push_back(boost::lexical_cast<string>(*ptr)); 
      expecting_operator = false; 
      continue; 
     } 

     if (*ptr == '*' || *ptr == '/') { 
      while (operator_stack.size() && (operator_stack.back() == "*" || operator_stack.back() == "/")) { 
       output.push_back(operator_stack.back()); 
       operator_stack.pop_back(); 
      } 

      operator_stack.push_back(boost::lexical_cast<string>(*ptr)); 
      expecting_operator = false; 
      continue; 
     } 

     /* Error */ 
     return false; 
    } 

    while (operator_stack.size()) { 
     if (!IsMathOperator(operator_stack.back())) 
      return false; 

     output.push_back(operator_stack.back()); 
     operator_stack.pop_back(); 
    } 

    return true; 
} // Rpn 

/***************************************************************************************/ 

bool Calc(const string expression, double &output) 
{ 
    vector<string> rpn; 

    if (!Rpn(expression, rpn)) 
     return false; 

    vector<double> tmp; 
    for (size_t i = 0; i < rpn.size(); ++i) { 
     if (IsMathOperator(rpn[i])) { 
      if (tmp.size() < 2) 
       return false; 
      double two = tmp.back(); 
      tmp.pop_back(); 
      double one = tmp.back(); 
      tmp.pop_back(); 
      double result; 

      switch (rpn[i][0]) { 
       case '*': 
        result = one * two; 
        break; 

       case '/': 
        result = one/two; 
        break; 

       case '+': 
        result = one + two; 
        break; 

       case '-': 
        result = one - two; 
        break; 

       default: 
        return false; 
      } 

      tmp.push_back(result); 
      continue; 
     } 

     tmp.push_back(atof(rpn[i].c_str())); 
     continue; 
    } 

    if (tmp.size() != 1) 
     return false; 

    output = Abs(tmp.back()); 
    return true; 
} // Calc 

/***************************************************************************************/ 

Answer 2

सी ++ कार्रवाई में, सी ++ पर एक बड़ा पुस्तक होने के अलावा, एक पूरी तरह से काम कर रहे कैलकुलेटर भी शामिल है, कर रही है कि तुम क्या (और वास्तव में बहुत अधिक) की जरूरत है। और किताब के लिए मुफ्त ऑनलाइन

Answer 3

बढ़ावा :: भावना उपलब्ध है एक कैलकुलेटर उदाहरण जो आपको क्या चाहिए करना होगा साथ आता है: http://www.boost.org/doc/libs/1_33_1/libs/spirit/example/fundamental/ast_calc.cpp

Answer 4

muParser सी में लिखा है ++ और तुम सिर्फ क्या जरूरत है।