12*65^2-33 (opdeling?)

Det er absolut ikke triviel kode.

Jeg har noget kod eliggende her http://www.vajhoej.dk/arne/eksperten/EXPR/.

Det er gammel kode, men den virker.

Fors**** det ser indviklet ud - i forhold til min, ikke så udbredde viden om c++.
Det kan ikke gøre simplere?::)

Det kan muligvis gøres lidt nemmere.

Men du kan ikke gøre det med 15 linier ...

var godt klar over at det ikke var helt nemt. Men én mere pædagoisk metode, end bare at copy/paste og intet forstå og til sidst lærer lidt, men uden at forstå alt - må der da være:)

min kode kan opdeles i 3 trin

1) konvertering fra tekst streng til symbolsk form
2) konvertering fra infix til postfix notation
3) evaluering

Hvis du googler må du kunne finde mange andre eksempler på det samme.

Jeg vil prøve at kigge på det:P

Man kunne også kaste sig ud i noget i stil med:
#include <vector>
#include <string>
#include <iostream>
#include <sstream>

template <typename T>
bool FromString(T &aValue, const std::string &aStr)
{
  std::stringstream ss(aStr);
  return ss >> aValue;
}

class ElementBaseClass
{
public:
  enum ElementTypeEnum
  {
      NumberType,
      AddType = '+',
      SubType = '-'
  };

  ElementBaseClass(ElementTypeEnum aElementType) : ElementType(aElementType)
  {
  }
  ElementTypeEnum ElementType;
  virtual void Print(std::ostream& aOs) = 0;
  virtual ~ElementBaseClass(){}
};

class NumberElementClass : public ElementBaseClass
{
public:
  NumberElementClass(std::string& aStr) : ElementBaseClass(NumberType)
  {
      std::string::size_type pos = aStr.find_first_not_of("0123456789");
      if(pos == std::string::npos)
      {
        FromString(Number, aStr);
        aStr = "";
      }
      else
      {
        FromString(Number, aStr.substr(0, pos));
        aStr = aStr.substr(pos);
      }
  }
  virtual void Print(std::ostream& aOs)
  {
      aOs << Number;
  }
private:

  int Number;
};

class AddElementClass : public ElementBaseClass
{
public:
  AddElementClass(std::string& aStr) : ElementBaseClass(AddType)
  {
      aStr = aStr.substr(1);
  }
  virtual void Print(std::ostream& aOs)
  {
      aOs << '+';
  }
};

class SubElementClass : public ElementBaseClass
{
public:
  SubElementClass(std::string& aStr) : ElementBaseClass(SubType)
  {
      aStr = aStr.substr(1);
  }
  virtual void Print(std::ostream& aOs)
  {
      aOs << '+';
  }
};

bool Parse(std::vector<ElementBaseClass *>& aVector, std::string& aStr)
{
  while(!aStr.empty())
  {
      switch(aStr[0])
      {
      case '+':
        aVector.push_back(new AddElementClass(aStr));
        break;
      case '-':
        aVector.push_back(new SubElementClass(aStr));
        break;
      case '0':
      case '1':
      case '2':
      case '3':
      case '4':
      case '5':
      case '6':
      case '7':
      case '8':
      case '9':
        aVector.push_back(new NumberElementClass(aStr));
        break;
    case ' ':
        aStr = aStr.substr(1);
        break;
    default:
        return false;
      }
  }
  return true;
}

int main()
{
  std::vector<ElementBaseClass* > MyVector;
  std::string Str = "123 + 321 - 555";

  if(Parse(MyVector, Str))
  {
      std::vector<ElementBaseClass* >::iterator it;
      for(it = MyVector.begin(); it != MyVector.end(); ++it)
      {
        (*it)->Print(std::cout);
      }
      std::cout << std::endl;
  }
}

I forbindelse med et andet spørgsmål genfandt jeg lige den her
http://www.gnu.org/software/bison/manual/pdf/bison.pdf

I eksempel kapitlet er der noget tilsvarende ved hjælp af bison parser
generator.

Heller ikke helt simpelt men ihvertfald en anden tilgangsvinkel.

Tid at få afsluttet her ?