Eine Zeile im LGS wird durch einen Array-Index vom Typ Lane dargestellt, welcher ein Array für alle Vorfaktoren und eine Variable für das Ergebnis der jeweiligen Gleichung besitzt.

class Lane {
public:
	Lane();
	Lane(int lanes);
	double* f; //Vorfaktoren 
	double res; //Ergebnis 

	void setFaktorCount(int lanes); //Initialisiert das Array für die Vorfaktoren abhängig von der Anzahl der Gleichungen (Eine neue Variable pro Gleichung) 
	void setFaktors(double* f, double res); //Übergibt ein Array mit Vorfaktoren an das Objekt. 
	void printLane(int factCount); //Gibt die Gleichung aus
	Lane multiplyWith(double m, int factCount); //Multipliziert das Ergebnis und alle Vorfaktoren mit dem Parameter m.

};

So weit klappt das auch ganz gut:

int main(int argc, char *argv[]) 
{
	int lanes = 3; //LGS mit drei Gleichungen/Variablen/Vorfaktoren 

	double res[lanes];
	double factors[lanes][lanes];

	factors[0][0] = 4;
	factors[0][1] = 9;
	factors[0][2] = 5;
	res    [0]    = 13;

	factors[1][0] = -5;
	factors[1][1] = 6;
	factors[1][2] = 3;
	res    [1]    = 17;

	factors[2][0] = 6;
	factors[2][1] = 3;
	factors[2][2] = -10;
	res    [2]    = 23;

	Lane lane[lanes];

	for (int i = 0; i<lanes;i++)
	{
		lane[i].setFaktorCount(lanes);
		lane[i].setFaktors(factors[i], res[i]);
		lane[i].printLane(lanes);
	}

Ausgabe:

4   9   5   | 13
-5   6   3   | 17
 6   3  -10   | 23

Sobald ich aber beginne die Methode Lane Lane::multiplyWith(double m, int factCount) aufzurufen fangen die Probleme an. Wie der Name vermuten lässt ist der Sinn dieser Methode die Vorfaktoren und das Ergebnis mit dem Parameter double m zu multiplizieren und die veränderte Gleichung als neues Instanz von Lane zurück zu geben.

Die Implementierung sieht aus wie folgt:

Lane Lane::multiplyWith(double m, int factCount)
{
	Lane ret(factCount);
	for (int i = 0; i < factCount; i++)
		ret.f[i] = this->f[i] * m;
	ret.res = this->res * m;
	return ret;
}

Wenn ich das jetzt aber z.B. auf lane[0] anwende geht irgendetwas gewaltig schief.

lane[0].printLane(lanes);
lane[0] = (lane[0].multiplyWith(0, lanes)); //Alle Vorfaktoren und das Ergebnis der Gleichung mit 0 multiplizieren. 
lane[0].printLane(lanes);

Ausgabe:

4   9   5   | 13
0   3.68253e+259   6.88306e-313   | 0

Das Ergebnis der Gleichung (res) und der erste Vorfaktor (f[0]) wurden erfolgreich mit 0 multipliziert, allerdings ist mit allen andren Stellen des Arrays f[] irgendetwas seltsames passiert. Ich habe nicht die geringste Ahnung was da genau verrechnet wurde, aber es könnte nicht weiter vom meinem Ziel entfernt sein. Wurde dort eventuell eine Adresse im Speicher in Dezimalschreibweise ausgegeben?

Ich persönlich habe den Verdacht, dass der Fehler daher rührt das es sich bei double* f um einen Zeiger handelt. Ich glaube mal gelesen zu haben das der Wert eines Zeigers, so fern dieser auf ein Array zeigt, immer den des nullten Index des Arrays beträgt, was erklären würde warum bei diesem der Fehler nicht auftritt.

Irgendwelche Vorschläge?
(Bitte keine "Das ist alles Schrott und mache es ganz anders" Antworten. Es geht, wie zu beginn schon erwähnt, mir nicht darum das Programm fertig zu schreiben, sondern um genau dieses spezifische Problem zu lösen, unabhängig vom Zweck des Programms.)

EDIT: Ich vergaß zu erwähnen dass wenn ich ret mit dem static keyword deklariere, der Fehler ebenfalls bei res und f[0] auftritt.

class Lane { 
public: 
	Lane() :  f(nullptr) {}
	Lane(int lanes) :  f(new double[lanes]) {}
    double* f; //Vorfaktoren 
    double res; //Ergebnis 

	void setFaktorCount(int lanes) { f = new double[lanes]; } //Initialisiert das Array für die Vorfaktoren abhängig von der Anzahl der Gleichungen (Eine neue Variable pro Gleichung) 
	void setFaktors(double* f, double res) { this->f = f; this->res = res; }//Übergibt ein Array mit Vorfaktoren an das Objekt. 
	void printLane(int factCount) { for(int c = 0; c < factCount; ++c) cout << f[c] << " "; cout << "| " << res << endl; } //Gibt die Gleichung aus 
    Lane multiplyWith(double m, int factCount); //Multipliziert das Ergebnis und alle Vorfaktoren mit dem Parameter m. 
};

Damit bekomme ich keine Probs.
Dein Problem hattest du höchstwahrscheinlich, weil dein Konstruktor kein Array angelegt hat:

Lane(int lanes) :  f(new double[lanes]) {}

Ein bissl mehr OOP hätte dem Code sicher gut getan

Des weiteren vergaß ich zu erklären was der Konstruktor macht. Mein Fehler.

Lane::Lane(int lanes) 
{
	setFaktorCount(lanes);
}

void Lane::setFaktorCount(int lanes)
{
	double faktors[lanes];
	this->f=faktors;
}

Wie genau unterscheidet sich das von deiner Lösung, abgesehen davon das meine nicht funktioniert?
**
EDIT:**

void Lane::setFaktorCount(int lanes)
{
	f = new double[lanes];
}

Damit wäre das Problem gelöst. Tausend Dank! Ich würde trotzdem gerne wissen worin hier der genaue unterschied besteht.

Was genau macht der Doppelpunkt hinter den Konstruktoren?

Das ist die Member Initializer List. Genaueres solltest du in deinem Buch oder mit Google finden.

Cyberpunc schrieb:

void Lane::setFaktorCount(int lanes)
{
	double faktors[lanes];
	this->f=faktors;
}

Wie genau unterscheidet sich das von deiner Lösung, abgesehen davon das meine nicht funktioniert?
**
EDIT:**

void Lane::setFaktorCount(int lanes)
{
	f = new double[lanes];
}

In der ersten Version wird ein Array angelegt mit static storage duration. Dann wird ein Zeiger darauf gestzt. Diese Version ist falsch aus folgendem Grund: Sobald die Funktion 'setFaktorCount' verlassen wird, wird das Array 'faktors' automatisch geloescht. Das heisst der Zeiger 'f' zeigt auf geloeschten Speicher. Spaetere Zugriffe darauf erzeugen undefiniertes Verhalten.

In der zweiten Version wird ein Array angelegt mit dynamic storage duration, das heisst das Array wird nach Verlassen der Funktion nicht automatisch geloescht. Der dafuer angeforderte Speicher muss zu einem Zeitpunkt manuell mit delete[] geloescht werden.
Der Code von Soley scheint falsch zu sein, da er den Speicher nirgendwo freigibt. Das erzeugt sogenannte Memory Leaks. Du solltest dich fragen, ob 'faktors' wirklich ein dynamisch alloziertes Array sein muss. Fuer solche Dinge sollte man onehin besser std::array oder std::vector verwenden.

Zusammengefasst solltest du dir folgendes Anschauen:
- Member Initializer List
- Automatic Storage Duration, Dynamic Storage Duration, Static Storage Duration
- std::vector, std::array
- faktors gibt es im Englischen nicht, es heisst factors

Lane::~Lane() 
{
	delete this->f;
}

So richtig?

Lane::~Lane() 
{
	delete this->f;
}

Nein. En Array musst du mit delete[] freigeben. Aber ernsthaft: Nimm stattdessen unbedingt std::vector, den du gerade schlecht nachprogrammierst.

Lane Lane::substractLanes(Lane s, const int& factCount)
{
	static Lane ret(factCount);
	for (int i = 0; i < factCount; i++)
		ret.f[i] = this->f[i] - s.f[i];
	ret.res = this->res - s.res;
	return ret;
}

Wenn ich diese Elementarfunktion aufrufe, beendet das Programm sofort mit 1.

class Lane
{
  private:
    std::vector<int> values;

  public:
    int& position(int at)
    {
      return values[at+1];
    }
    int position(int at) const
    {
      return values[at+1];
    }

    int& result()
    {
      return values[0];
    }
    int result() const
    {
      return values[0];
    }

    Lane& operator*=(int factor)
    {
      for(std::vector<int>::const_iterator it(values.begin()), end(values.end()); it != end; ++it)
        *it *= factor;
    }
};

int main()
{
  lane eins(4);
  lane zwei(4);

  eins *= 8;
  zwei *= 8;
}

alternativ noch eine freie funktion zur verfügung stellen:

void multiply_with(Lane& lhs, Lane& rhs, int factor)
{
  lhs *= factor;
  rhs *= factor;
}

so einfach und intuitiv kann das sein. und richtig - und sicher auch noch

bb