✔ [OOP] Polynomials

[Online-Skater]

Hallo liebe Tutorianer

Ich schreibe eine Klasse die Polynome verarbeiten kann z.b. 7.4x^5+3.1x^2-10.2x+14.9
Das Problem ist jetzt, das ich keine passende Umsetzung für die Art und Weise der Aufnahme habe. Gemeint ist damit speziell der Konstruktor eines Polynoms der als Parameter eben eine Polynomfkt enthält.
Zwei Probleme
- Die Anzahl der terme ist beliebig
- Der Grad des Terms ist beliebig aber absteigend

Meine erste Idee war als Parameter einen String zu benutzen, nur gibt es eine Version die einen Verzicht eines eigenen Interpreters zulässt ? Gibt es Ideen , Ansätze ?
Folgende Struktur

#ifndef POLY_H
#define POLY_H

#include <iostream>
#include <string>
using namespace std;

struct Term
{
     double coeff;
     int degree;
     Term();
     Term(double c, int d);
};

class Poly
{
     Term *Elem;
     int anz;
  public:
     Poly();
     Poly(const Poly&)
     Poly(string);
     ~Poly();
     Poly& operator= (const Poly&)
     Poly operator+ (const Poly&) const;
     Poly operator- (const Poly&) const;
     Poly operator* (const Poly&) const;
     double Value(const double) const;
     Poly operator- () const;        // Ableitungsoperator
};

#endif

Wäre die Anzahl nicht beliebig hätte man scanf benutzen können..
Wahrschinlich komme ich um einen Interpreter nicht herum !?

Vielen Dank für Ansätze

 

[Daniel Toplak]

Hi,

also meiner Meinung nach ist dieses Problem vernünftig mit einem Parser zu lösen, dieser Parser ist wahrscheinlich die Hauptarbeit des Projekts.
Entweder du schreibst dir solch einen Parser selbst, oder befasst dich mit sog. Parsergeneratoren, z.B. ANTLR oder "yacc", "bison"
ANTLR soll hier sehr leistungsfähig sein und du kannst mit hilfe einer "Grammatik" den Parser erstellen lassen.

 

[Online-Skater]

Danke für die Antwort, das habe ich mir schon fast gedacht, ich habe mal so ein Versuch gestartet leider klappt das nicht wirklich, es kommen übergroße Ergebnisse raus usw. aber immerhin terminiert es Da sind keine Sicherheitsabfragen drin usw.

Poly::Poly(string S)
{
    anz = 0;                     // Termzähler
    Term *Elem = new Term[10];   // max 9 Terme :(
    int i=0;
    while(i < S.length())
    {
        char tmp = S[i];        // akt. Zeichen
        char zk[10] = {'\0'};     // max 9 Stellen  :(
        short x = 0;
        if (tmp == '-')
        {
             zk[x++] = tmp;     // VZ speichern
             tmp = S[++i];      // nächste Stelle
        }
        if ((int)tmp > 47 && (int)tmp < 58)
        {
            // Searching coefficient
            while(tmp != 'x' && tmp != '\0')
            {
                zk[x++] = tmp;
                tmp = S[++i];
            }
            double val = atof(zk);
            int deg = 0;
            if (tmp != '\0')
            {
                i += 2;         // ^ wird ausgelassen
                tmp = S[i];
                deg = (int)tmp;  // Potenz einzahlig
            }
            Term T(val,deg);
            Elem[anz++] = T;
        }
        i++;
    }
}

Da es nur eine "simple" Übung sein soll zu Klassen werde ich wohl eine Eingabeaufforderung machen in denen man zuerst die Anzahl Terme und dann Paarweise Koeffizient und Potenz eingibt.

Später werde ich mich auch mal mit solchen Parsergeneratoren befassen.

 

[Online-Skater]

Ok habe es selber hinbekommen, total dämlicher Fehler und zwar in Zeile 4 ...
Habe noch ein Array für die Potens angelegt damit es mit atoi() besser klappt.

So funktioniert es wunderbar, sofern man die Polynome richtig angibt.

Poly::Poly(string S):anz(0)
{
   // Miniparser
   p_Elem = new Term[10];         // max 9 Terme :(
   int i=0;
   while(i < S.length())
   {
      char tmp = S[i];          // akt. Zeichen
      char db[6] = {'\0'};      // koeffizient double
      char in[4] = {'\0'};      // Potenz int
      short x = 0, y = 0;       // hilfscount.
      if (tmp == '-')           // VZ speichern
      {
         db[x++] = tmp;
         tmp = S[++i];      // nächste Stelle
      }
      if ((int)tmp > 47 && (int)tmp < 58)
      { // Searching coefficient
         while(tmp != 'x' && tmp != '\0')
         {
            db[x++] = tmp;
            tmp = S[++i];
         }
         double val = atof(db);
         int deg = 0;
         if (tmp != '\0')
         {
            i += 2;          // ^ wird ausgelassen
            tmp = S[i];
            // Searching Potenz
            while(tmp != '+' && tmp != '-' && tmp != '\0')
            {
              in[y++] = tmp;
              tmp = S[++i];
            }
            deg = atoi(in);  // Potenz
         }
         Term T(val,deg);
         p_Elem[anz++] = T;
      }
      if (tmp != '-') i++;
   }
}

*Closed* ;-)