3. Parameterkonstruktor

Parameterkonstruktor

  • ?

    Hallo,

    wenn ich ein Polynom mit Parameter aufrufe, bekomme ich immer folgenden Fehler:
    _BLOCK_TYPE_IS_VALID(pHead->nBlockUse)

    Danke für eure Hilfe!

    Minimalcode:

    class Monomial
{
public:
	int COEFF;
	int * EXPS;
	int SIZE;

	Monomial() : COEFF(0), EXPS(new int), SIZE(1) {};
	~Monomial(){ delete EXPS; }
	Monomial(int coeff, int* exps);
	Monomial(const Monomial &mono);
	Monomial& operator= (const Monomial &mono);
};

class Polynomial
{
public:
	int NUMB_VAR;
	int NUMB_MONO;
	Monomial * MONO;
	int LENGTH;

	~Polynomial() { delete MONO; }
	Polynomial(int n);
};

Monomial::Monomial(int coeff, int* exps)
{
	COEFF = coeff;
	SIZE = sizeof(exps) / 2;
	EXPS = new int[SIZE];
	if (coeff != 0)
	for (int i = 0; i < SIZE; i++)
		EXPS[i] = exps[i];
}

Monomial::Monomial(const Monomial &mono)
{
	COEFF = mono.COEFF;
	SIZE = mono.SIZE;
	EXPS = new int[SIZE];
	if (COEFF != 0)
	for (int i = 0; i<SIZE; i++)
		EXPS[i] = mono.EXPS[i];
}

Monomial& Monomial::operator= (const Monomial &mono)
{
	COEFF = mono.COEFF;
	SIZE = mono.SIZE;
	EXPS = new int[SIZE];
	if (COEFF != 0)
	for (int i = 0; i<SIZE; i++)
		EXPS[i] = mono.EXPS[i];
	return *this;
}

Polynomial::Polynomial(int n)
{
	NUMB_VAR = n;
	NUMB_MONO = 0;
	MONO = new Monomial[5];
	int* exps = new int[n];
	Monomial tmp(0, exps);
	for (int i = 0; i<5; i++)
		MONO[i] = tmp;
	delete exps;
	LENGTH = 5;
}

int main()
{
	Polynomial a(2);
}
    0
  • M

    Polynomial braucht einen Copy-Konstruktor.

    Warum benutzt du nicht std::vector? Dann hast du diesen ganzen Ärger nicht.

    0
  • ?

    Hallo, danke für die schnelle Antwort!

    ich dachte den brauch ich für den Minimalcode nicht, habe aber in meinen Programm folgenden Kopierkonstruktor (Leider bekomme ich noch immer den gleichen Fehler):

    Polynomial(const Polynomial &p);

    Polynomial::Polynomial(const Polynomial &p)
{
	NUMB_VAR = p.NUMB_VAR;
	NUMB_MONO = p.NUMB_MONO;
	int size = p.MONO->SIZE;
	MONO = new Monomial[size];
	for (int i = 0; i<size; i++)
		MONO[i] = p.MONO[i];
	LENGTH = p.LENGTH;
}
    0
  • ?

    ...ach ja. std::vector haben wir noch nicht kennengelernt und dürfen wir deswegen wahrscheinlich noch nicht verwenden.

    0

  • An welcher Stelle tritt denn der Fehler auf, wenn du deinen Code debuggst? Dein Code ist so übersichtlich, dass man den Fehler mit dem Debugger sofort finden sollte.

    Für mich sieht Zeile 31 schon mal sehr seltsam aus, da halbierst du die Größe eines Zeigers zur Bestimmung der Puffergröße.
    Außerdem solltest du delete[] statt delete benutzen, wenn du Speicher mit new[] anforderst.

    0
  • ?

    diese Möglichkeit zum ermitteln der Länge habe ich im Internet gefunden.
    Falls die Methode nicht so gut ist, würde ich gern wissen wie man die Länge des Feldes sonst ermitteln kann?

    mfg

    0
  • Mod

    Max25 schrieb:

    diese Möglichkeit zum ermitteln der Länge habe ich im Internet gefunden.

    Und sie ist kompletter Quark. Nicht schlecht, sondern falsch. Nicht einmal nahe dran.

    Falls die Methode nicht so gut ist, würde ich gern wissen wie man die Länge des Feldes sonst ermitteln kann?

    Gar nicht, musst du mitschleppen.

    Da du mit den Klassen Monomial und Polynomial gerade im Begriff bist, gleich zweimal std::vector nach zu programmieren, bietet sich ganz dringend folgende Vorgehensweise an: Du programmierst einmal std::vector nach. Das ist eine ganz einfache Klasse, die intern ein dynamisches Feld verwaltet. Also genau das, was deine beiden Klassen im Moment tun (mit entsprechender Codeverdoppelung), aber ohne die fuer Monomials und Polynomials typischen Methoden. Also im einfachsten Fall bloss Zugriff auf die Elemente.
    Dann benutzen Monomial und Polynomial jeweils einen dieser nachprogrammierten std::vector. So faellt sehr viel unnoetige Komplexitaet bei diesen beiden Klassen weg, weil sie sich ganz und gar auf ihre Kernaufgaben konzentrieren koennen, ohne sich um Speicherverwaltung zu kuemmern (Wieso sollte ein Polynom sich mit Speicherverwaltung auskennen muessen? Davon habe ich in Mathe nichts gehoert).
    Der nachprogrammierte vector kann sich hingegen voll auf Speicherverwaltung konzentrieren, denn das ist seine einzige Aufgabe. Da brauchst du das bloss ein einziges Mal richtig zu machen und kannst es dann immer wider neu benutzen. Beispielsweise gehoert zu der Speicherverwaltung auch, dass man sich irgendwie die Groesse eines Feldes merkt. (Der "richtige" vector merkt sich uebrigens normalerweise nicht die Groesse, sondern Anfang und Ende und rechnet bei Bedarf die Groesse aus, aber das ist ein anderes Thema, das jetzt zu weit fuehren wuerde.)

    0
Anmelden zum Antworten