"String beklammerten_term_aufloesen(String,float)"

fertig geworden.
Die zwei Übergabewerte stehen für den im Textfeld eingegebenen Wert und der zweite Parameter natürlich für den Wert, der für "x" eingesetzt werden soll.
Die Funktion arbeitet perfekt- somit habe ich mich gefreut und mir gedacht:
Jo- jetzt kannste das ganze einfach in eine Schleife bauen, die den zweiten Übergabeparameter immer um 1 hochzählt und schon hast du deine Wertetabelle fertig.
Doch leider hatte ich falsch gedacht.
Lasse ich meine Schleife öfter als 16 mal durchlaufen, so tritt die folgende Fehlermeldung auf:

http://Jesusfreak777.je.funpic.de/EAccess.JPG

Ich habe mich bereits totgesucht nach dem Fehler kann aber einfach nicht seine Ursache finden.
Das Komische ist auch, dass die Funktion super arbeitet, wenn ich die Anzahl der Schleifendurchläufe auf 15 reduziere.
Ich könnte Beispielsweise auch bei "15" anfangen und dann bis "30" zählen- das würde auch noch gehen- aber sobald es dann "31" ist spuckt mir der Compiler diesen Fehler.
Kann mir jemand helfen?

cya
David

PS:

Code:

Das Button-Event:

void __fastcall Tfrmgraph::Image1MouseDown
(TObject *Sender,TMouseButton Button, TShiftState Shift,
int X, int Y)
{
    lst1->Items->Clear();
    firstnegative=false;
    button->LoadFromFile("down.bmp");
    lblberechnen->Picture = button;
    klammerende=-1;
    klammerstart=-1;
    male=0;
    String funktionsterm = txtterm->Text;
    txtrechnung->Text = funktionsterm;

    txtterm->Text=leerstellen_ausmerzen(txtterm->Text);
    txtterm->Text=mal_einsetzen(txtterm->Text);
    for(float a=1;a<20;a+=1)
    {
        String funktionsterm2 = beklammerten_term_aufloesen(funktionsterm,a);
        funktionsterm2=klammerlosen_term_aufloesen(funktionsterm2);
        lst1->Items->Add(funktionsterm2);
    }
   imggraph->Canvas->Draw(0,0,graph);
}

Das hier ist die Hauptfunktion. Von ihr aus werden noch kleinere Unterfunktionen die unten gepostet sind aufgerufen um das ganze übersichtlicher zu machen:

String beklammerten_term_aufloesen(String funktion, float ix)
{
    funktion = x_einsetzen(funktion,ix);
    for(int a=1;a<=funktion.Length()-1;a++)
    {
       if(funktion[a]==45 && a==1)
          firstnegative=true;
    }
    while(schleife==false)
    {
          for(int a=1;a<=funktion.Length();a++)
          {
             if(funktion[a]==40)
                klammerstart=a;
             if(funktion[a]==41)
                klammerende=a;
          }
          if(klammerende>-1 && klammerstart>-1)
          {
             String zwischenterm="";
             for(int a=klammerstart+1;a<klammerende;a++)
                zwischenterm+=funktion[a];
             String neuer_term="";
             for(int a=1;a<klammerstart;a++)
                neuer_term+=funktion[a];
             neuer_term+=klammerlosen_term_aufloesen(zwischenterm);
             for(int a=klammerende+1;a<=funktion.Length();a++)
                neuer_term+=funktion[a];
             funktion=neuer_term;
             klammerstart=-1;
             klammerende=-1;
          }
          else
             schleife=true;
       }
     funktion=klammerlosen_term_aufloesen(funktion);
     schleife=false;
     return(funktion);
}

Diese Funktion setzt für x irgendeinen Wert ein:

String x_einsetzen(String l, float w)
{
   String vorterm="",nachterm="";
   int vor=0;
   for(int a=1;a<=l.Length();a++)
   { :die: 
      if(l[a]==120)
      {
         vor=a-1;
         vorterm="";
         nachterm="";
         for(int b=1;b<=vor;b++)
            vorterm+=String(l[b]);
         for(int b=vor+2;b<=l.Length();b++)
            nachterm+=String(l[b]);
         l=vorterm+FloatToStr(w)+nachterm;

      }
   }
   return(l);
}

Diese Funktion löst einen Term, der keine Klammern enthält:

String klammerlosen_term_aufloesen(String t)
{
for(int truth=0;truth<=5;truth++)
{
   for(int a=1;a<=t.Length();a++)
   {
      regel(truth);
      if(t[a] == 42 && mal == true
      || t[a] == 43 && plus == true
      || t[a] == 94 && hoch == true
      || t[a] == 47 && durch == true
      || t[a] == 45 && minus == true)
      {
         int multiplikationslaengen=1;
         int multiplikationslaengev=0;

	 //Alle Zeichen nach dem "*" durchlaufen bis es keine Zahl mehr ist.
         String vzahl="";
         String nzahl="";
         for(int b=a+1;b<=t.Length();b++)
         {
            if(t[b]>47 && t[b]<58|| t[b]==44)
            {
               nzahl+=String(t[b]);
               multiplikationslaengen++;
            }
            else
               break;
         }
         theterm=false;
	 //Alle Zeichen vor dem "*" durchlaufen bis es keine Zahl mehr ist.
         for(int b=a-1;b>0;b--)
         {
            if(t[b]>47 && t[b]<58 || t[b]==44|| (t[b]==45&&b==1))
            {
               vzahl+=String(t[b]);
               multiplikationslaengev++;
            }
            else
               break;
         }
         if(vzahl.Length()>0)
         {
         theterm=false;
         vzahl = String_invertieren(vzahl);
         double nachzahl=StrToFloat(nzahl);
         double vorzahl=StrToFloat(vzahl);
         double ergebnis=0;
         switch(truth)
         {
            case 0:
               ergebnis=nachzahl*vorzahl;
            break;
            case 1:
            if(nachzahl!=0)
               ergebnis=vorzahl/nachzahl;
            break;
            case 2:
               ergebnis=nachzahl+vorzahl;
            break;
            case 3:
               ergebnis=vorzahl-nachzahl;
            break;
            case 4:
               ergebnis=pow(vorzahl,nachzahl);
            break;
         }
         String loesung = FloatToStr(double(ergebnis));
         String vorterm="";
         String nachterm="";
         for(int x=1;x<a-multiplikationslaengev;x++)
            vorterm+=String(t[x]);
         for(int x=a+multiplikationslaengen;x<=t.Length();x++)
            nachterm+=String(t[x]);
         t=vorterm+loesung+nachterm;
         terme[male]=t;
         male++;
         }
      }
   }
}
   return(t);
}