**
Eine Klasse definieren, die das Abspeichern, skalare Multiplizieren und Addieren von Polynomes eines (nahezu) beliebigen Grades ermöglicht, mit dynamischer Speicherverwaltung (d.h. Konstruktor, Destruktor + Funktionen). Die Koeffizienten sind vom Typ double.
**

Dabei bin ich im Code steckengeblieben, ich weiss nicht wie ich weiterkommen kann:

class Polynom {

private:
	double *pol1;
	double *pol2;
	double size1;
	double size2;

public:

	Polynom(double, double );
	~Polynom();

};

Polynom::Polynom(double grad1, double grad2)
{
	pol1 = new double;
	pol2 = new double;
	*pol1=grad1;
	*pol2=grad2;

}
Polynom::~Polynom()
{
	delete pol1;
	delete pol2;
}

Dynamische Speicherverwaltung ist sicherlich nötig, um die Anforderungen aus 1 (Polynome beliebigen Grades) zu erfüllen. Die technische Umsetzung davon ist in C++ aber sicherlich nicht über new, delete und Pointer (zumindest wenn man irgendwann auch mal fertig werden möchte und es auch funktionieren soll), sondern über die Containerklassen (vector bietet sich hier an). Dann brauchst du auch den Destruktor nicht, der Konstruktor wird wesentlich einfacher und die Funktionen die du hier fälschlicherweise weggelassen hast (Regel der großen Drei) brauchst du auch gar nicht erst.

struct Level
{
        typedef double coefficient_t;

        coefficient_t coefficient;
        size_t exponent;

        Level(coefficient_t ld = 0, size_t s = 0): //default: Summe, 0
        coefficient(ld), exponent(s) {}

        long double operator()(long double x)
        {
            return coefficient * std::pow(x, exponent);
        }
};

bool operator<(Level const& a, Level const& b)
{
        return a.exponent < b.exponent;
}
bool operator==(Level const& a, Level const& b)
{
        return a.exponent == b.exponent;
}

Dann eine Polynomklasse:

#include <map>

class Polynom
{
    std::map<size_t, Level> mLevels;//Redundanz-Pegel: 4/10 :D
    size_t const mNLevel;

public:

        template<typename it_t>
        Polynom(it_t a, it_t b):
        mLevels(a, b),
        mNLevel(mLevels.size()) {}

        long double operator()(long double X)
        {
                long double sum(0);
                for(size_t a(0) ; a < mLevels.size(); ++a) //Range-Based for in C++11 - bin zu faul zum iterieren :p
                        sum += mLevels[a](X);

                return sum;
        }
};

Sourceforge: http://ideone.com/hFp6h

Jetzt kann man diskutieren, ob man nicht doch lieber einen std::vector nimmt (Performance), oder ob meine Lösung Scheiße ist..

Edit: Folgende Methode kann noch zum skalaren Multiplizieren verwendet werden, vorrausgesetzt ich habe verstanden was es ist:

void multiplyEach(Level::coefficient_t scalar)
        {
                for(size_t a(0) ; a < mLevels.size(); ++a) //Range-Based for in C++11 - bin zu faul zum iterieren :p
                        mLevels[a].coefficient *= scalar;
        }

Mein Vorschlag: Eine Datenstruktur für einen Grad erstellen:

Wofür? Code-Bloat pur.

Auch in diesem Thread gilt: Bitte poste wenigstens richtigen Code. Du übergibst der Level-Struktur nicht den Exponenten, den du sowieso schon in der Polynom-Klasse speicherst. So funktioniert dein Code nur für x = 1.