Hier meine Quelldateien: Header, Cpp und Main.

#ifndef QUA_H // Waechter
#define QUA_H

class Qua{
	protected:

		double m_A;
		double m_B;
		double m_C;

	public:

		Qua(); 
		Qua(double newA, double newB, double newC);

		~Qua();

		double getCoeffA();
		double getCoeffB();
		double getCoeffC();

		void setCoeffA(double A);
		void setCoeffB(double B);
		void setCoeffC(double C);

		void printQuaFkt();

		void normalizeFkt();

		void computeZeros();

};
#endif

#include "Quadratic2.h"
#include <iostream>
#include <cmath>

using namespace std;

Qua::Qua(){ // Standardkonstruktor
	m_A = 1;
	m_B = 1;
	m_C = 1;
}
Qua::Qua(double newA, double newB, double newC){
	m_A = newA;
	m_B = newB;
	m_C = newC;
}

Qua::~Qua(){
}

double Qua::getCoeffA(){
	return m_A;
}
double Qua::getCoeffB(){
	return m_B;
}
double Qua::getCoeffC(){
	return m_C;
}
void Qua::setCoeffA(double A){
	m_A = A;
}
void Qua::setCoeffB(double B){
	m_B = B;
}
void Qua::setCoeffC(double C){
	m_C = C;
}

void Qua::printQuaFkt(){
	cout << getCoeffA() <<"x^2+ "<< getCoeffB() <<"x+ "<< getCoeffC() << endl;
}

void Qua::normalizeFkt(){
	if (m_A != 0){

		m_B = getCoeffB() / getCoeffA();
		m_C = getCoeffC() / getCoeffA();
		m_A = 1;
	}
}
void Qua::computeZeros(){
	double x0;
	double x1;
	double x2;
	if (m_A = 0){
		x0 = - (getCoeffB()/ getCoeffC());
		cout << x0 << endl;

	}
	else{
		x1 = (-1*getCoeffB() + sqrt(getCoeffB()*getCoeffB() - 4*getCoeffA()*getCoeffC())) / 2*getCoeffA();
		x2 = (-1*getCoeffB() - sqrt(getCoeffB()*getCoeffB() - 4*getCoeffA()*getCoeffC())) / 2*getCoeffA();
		cout << x1 << " und " << x2 << endl;

	}
}

#include "Quadratic2.h"
#include <iostream>

using namespace std;

int main(){

	Qua Start = Qua();
	cout << Start.getCoeffA() << " ist Koeffizient A der unveraenderten Standardfunktion" << endl;
	cout << endl;
	Qua Weiter = Qua(2,4,6);
	cout << Weiter.getCoeffB() << " ist Koeffizient B der erstellten Instanz" << endl;
	cout << endl;

	Start.setCoeffA(2);
	cout <<"Koeffizient A der Standardfunktion wird auf " << Start.getCoeffA()<< " gesetzt" << endl;
	cout << endl;

	cout << "Das ist die veraenderte Standardfunktion:" << endl;
	Start.printQuaFkt();
	cout << endl;
	cout << "Das ist die erstellte Instanz:" << endl;
	Weiter.printQuaFkt();
	cout << endl;

	Start.normalizeFkt();
	cout << endl;
	cout << "Das ist die normalisierte Standardfunktion:" << endl;
	Start.printQuaFkt();
	cout << endl;

	Weiter.normalizeFkt();
	cout << " Das ist die normalisierte Instanz:" << endl;
	Weiter.printQuaFkt();
	cout << endl;

	cout << "Das sind die Nullstellen der Standardfunktion:" << endl;
	Start.computeZeros();
	cout << endl;

	cout << "Das sind die Nullstellen der Instanz:" << endl;
	Weiter.computeZeros();
	cout << endl;
}

Ich weiß, der Code ist noch unzureichend kommentiert, aber ich habe mich bemüht selbsterklärende Bezeichnungen zu benutzen. Vlt hat ja einer Lust mal zu schauen, woran das liegen mag, ich starre seit Tagen drauf und es wird nicht besser

Vielen Dank

(-1*getCoeffB() + sqrt(getCoeffB()*getCoeffB() - 4*getCoeffA()*getCoeffC())) / 2*getCoeffA()

Scheint doch richtig zu sein ...

Hat die ueberhaupt eine Nullstelle?

Qua Weiter = Qua(2,4,6);

PS: Wenn m_A = 0, dann ist es keine quadratische Gleichung.

if (m_A = 0){

Das ist eine Zuweisung, kein Vergleich!

void Qua::computeZeros(){
    double x0;
    double x1;
    double x2;
    // Eigentlich: m_A == 0
    if (m_A = 0){
        // 1. b*x + c = 0 <=> x = -c / b <!=> x = -b / c
        // 2. Was ist wenn der Nenner (b) 0 ist?
        x0 = - (getCoeffB()/ getCoeffC()); 
        cout << x0 << endl;

    }
    else{
        // Du solltest die Fälle D < 0, D > 0 und D = 0 unterscheiden
        // Wenn die Normalform vorliegt vereinfacht sich das Ganze auf:
        //   x1/2 = (-b +- sqrt(b^2-4c))/2 (bei D > 0)
        //   
        // Im Fall D = 0 kannst du dir die Wurzel komplett sparen d.h.
        //   x1/2 = -b / 2 (bei D = 0)
        //
        // Im Fall D < 0 gibt es keine reelle Nullstelle

        x1 = (-1*getCoeffB() + sqrt(getCoeffB()*getCoeffB() - 4*getCoeffA()*getCoeffC())) / 2*getCoeffA();
        x2 = (-1*getCoeffB() - sqrt(getCoeffB()*getCoeffB() - 4*getCoeffA()*getCoeffC())) / 2*getCoeffA();
        cout << x1 << " und " << x2 << endl;

    }
}

Du solltest die Fälle D < 0, D > 0 und D = 0 unterscheiden

was ist D?

D > 0 2 Lösungen, D = 0 1 Lösung, D < 0 keine Lösung
im Bereich der Reellen Zahlen

Eine Untersuchung der Diskriminante bringt keinen großen Nutzen, da er so die Division durch Null nicht verhindern kann und weiter denn Nenner auf Ungleichheit mit Null vergleichen muss.

Eine Untersuchung der Diskriminante bringt keinen großen Nutzen, da er so die Division durch Null nicht verhindern kann und weiter denn Nenner auf Ungleichheit mit Null vergleichen muss.

Eine Unterscheidung bringt aber insofern Vorteile, als das man die Anzahl der Lösungen liefern- und z.T. einige rechenintensive Operationen sparen kann.