Hi Leute!

Oben hab ich euch meine get-Methode reinkopiert. Mit der will ich in meiner print-Methode auf das zweidimensionale private-Feld zugreifen und in Abhgängigkeit meiner beiden for-Schleifen, den jeweiligen Wert in's cout schicken. Leider kackt mir genau an dieser Stelle das Programm ab!

Was mache ich falsch?

Edit: Das wäre die Klasse dazu:

class matrix
{
private:
	int n, m;
	int** feld;

public:
	matrix(int n, int m);
	~matrix();
	void print(int n, int m);
	void input();
	int getVal(int n, int m);
};

Was mache ich falsch?

Du gibst keine Informationen über Fehler oder deine print -Funktion. Poste beides.

Das ist mein Konstruktor:

matrix::matrix(int n, int m) : n(n), m(m)
{
	int** feld = new int*[n];

	//Array allokieren
	for(int i = 0; i < n ; i++)
	{
		feld[i] = new int[m];
	}

	//mit Nullen befüllen
	for(int i = 0; i<n; i++)
	{
		for(int j = 0; j<m; j++)
		{
			feld[i][j] = 0;
		}
	} 
}

Das ist die print-Methode:

void matrix::print(int n, int m)
{
	//Array ausgeben
	for(int i = 0; i<n; i++)
	{
		for(int j = 0; j<m; j++)
		{
			int temp = getVal(i, j);
			cout << temp;
		}

		cout << endl;
	}
}

Jetzt hab ihr alles wichtige an Code und die Fehlermeldung

Vorschlag: Komplett neu machen. Dieses mal mit folgendem Ansatz:

class matrix
{
private:
    size_t size_x, size_y;
    std::vector<int> data;

public:
    matrix(size_t n, size_t m);
//    ~matrix();                Brauchst du nicht mehr
//    void print(int n, int m); Anwendungscode. Nicht Aufgabe der Matrixklasse.
//    void input();             Anwendungscode. Nicht Aufgabe der Matrixklasse.
    int getVal(size_t n, size_t m) const;  // const-correctness beachten!
    int& getVal(size_t n, size_t m);       // Sicherlich auch ganz nützlich, wenn man schreibend zugreifen kann
};

P.S.: Du hast den Code gepostet, während ich geantwortet habe. Mein Verdacht, dass du mit manueller Speicherverwaltung hantierst und dabei alles falsch machst, bestätigt sich.

Von daher kann ich leider mit deinem Tip nicht viel anfangen. Wäre daher nett, wenn du mir sagen könntest, wo der Hase im Pfeffer liegt!

int operator[]( std::array<int, 2> const& indices ) const;  // const-correctness beachten!
    int& operator[]( std::array<int, 2> const& indices )       // Sicherlich auch ganz nützlich, wenn man schreibend zugreifen kann

FTFY
(Mit init-list benutzen, ginge aber natürlich auch mit dem Funktionsoperator)

Wenn das fertig und getestet(!) ist, dann bastelst du damit deine Matrixklasse. Und zwar wirklich nur 1D! Das 2D zu machen ist (fast immer^*) Unsinn.

^*: Diese Relativierung bezieht sich nicht auf die hier vorliegende Aufgabe. Naturwissenschaftler mögen keine absoluten Aussagen, wenn sie nicht in jedem Fall stimmen. Die Relativierung ist für die Klugscheißer im Forum gedacht, die ansonsten einen Flamewar starten würden, dass sie einen Sonderfall kennen, in dem das sinnvoll ist. Daher nochmal absolute Aussage: Solch ein Fall liegt hier nicht vor. 1D ist angesagt.

Sone schrieb:

int operator[]( std::array<int, 2> const& indices ) const;  // const-correctness beachten!
    int& operator[]( std::array<int, 2> const& indices )       // Sicherlich auch ganz nützlich, wenn man schreibend zugreifen kann

FTFY
(Mit init-list benutzen, ginge aber natürlich auch mit dem Funktionsoperator)

Wo soll denn da der Vorteil sein, außer, dass es umständlicher⁺ ist?

⁺: Ich bin nicht mehr sicher, ob das in C++ als Vorteil oder als Nachteil gilt

Sone schrieb:

int operator[]( std::array<int, 2> const& indices ) const;  // const-correctness beachten!
    int& operator[]( std::array<int, 2> const& indices )       // Sicherlich auch ganz nützlich, wenn man schreibend zugreifen kann

FTFY
(Mit init-list benutzen, ginge aber natürlich auch mit dem Funktionsoperator)

Wo soll denn da der Vorteil sein, außer dass es umständlicher ist?

Naja, und außerdem passt es besser. Wenn du eine Matrix auslesen willst, dann nimmst du halt den operator[] .

Siehe auch Boost, AFAIR mit boost::range machen die das da....

a.get(1, 2) = 8;

Viel lieber:

a[{1, 2}] = 8;

#include<iostream>
#include"U1A3und4header.h"
using namespace std;

int main()
{
	matrix matrixLinks(4,4);
	matrix matrixRechts(4,4);

return 0;
}

#ifndef U1A3UND4HEADER__H
#define U1A3UND4HEADER__H

class matrix
{
private:
	int n, m;
	int** feld;

public:
	matrix(int n, int m);
	~matrix();
	void print(int n, int m);
	void input();
	int getVal();
};

#endif

#include<iostream>
#include"U1A3und4header.h"
using namespace std;

matrix::matrix(int n, int m) : n(n), m(m)
{
	int** feld = new int*[n] ();

	//Array allokieren
	for(int i = 0; i<n ; i++)
	{
		feld[i] = new int[m] ();
	}
}

matrix::~matrix()
{
	for (int j=0; j<n ; j++)
	{
        delete[] feld[j];
	}

	delete[] feld;
}

Die "getVal"-Methode hab ich nun nochmal gelöscht. Mir fällt nämlich jetzt schon auf, dass der Destruktor den gleichen Fehler wie die getVal-Methode bringt.

Ich denke ein Fehler liegt dann wohl schon am Anfang beim allokieren...

Helft ihr mir?

Was SeppJ sagt, gilt natürlich trotzdem, das ist aber anscheinend nicht die direkte Ursache für dein Problem.

Jetzt fällts mir auch auf! Nur wie kann ich auf das Feld in der Klasse zugreifen?

Edit: So richtig?

matrix::matrix(int n, int m) : n(n), m(m)
{
	this->feld = new int*[n] ();

	//Array allokieren
	for(int i = 0; i<n ; i++)
	{
		this->feld[i] = new int[m] ();
	}
}

void matrix::mul(matrix feldLinks, matrix feldRechts)
{
	for (int i=0; i<this->m; m++)	//Zeilen durchschalten
	{
		for (int j=0; j < this->n; j++)		//Spalten durchschalten
		{
			for (int inner = 0; inner<this->n; inner++)		//Multiplizieren
			{
				this->feld[i][j] = this->feld[i][j] + (feldLinks.getVal(i, inner) * feldRechts.getVal(i, j));
			}
		}

		cout << endl;
	}
}

Die Klasse sieht nun mittlerweile so aus:

class matrix
{
private:
	int n, m;
	int** feld;

public:
	matrix(int m, int n);
	~matrix();
	void print();
	void input();
	void mul(matrix feldLinks, matrix feldRechts);
	int getVal(int m, int n);
	void setVal(int m, int n, int val);
};

Die main Aufrufe hab ich so gemacht:

matrix matrixLinks(3,3), matrixRechts(3,3), matrixErgebnis(3,3);

	matrixLinks.input();
	matrixRechts.input();
	matrixErgebnis.print();

	matrixErgebnis.mul(matrixLinks, matrixRechts);
	matrixErgebnis.print();

Problem daran ist nun, dass nach dem Aufruf der vorletzten Zeile in der main das Programm augenblicklich ohne Warnung stehen bleibt. Der Compiler kompiliert fehlerfrei! Was könnte das sein? Riecht irgendwie nach Endlosschleife...

int n, m;

wenn der Compiler da keinen Drehwurm bekommt, bekommt ihn der menschliche Leser

wenn der Compiler da keinen Drehwurm bekommt

Ne, der bekommt gar nix.

ich würde zunächst mal die Membervariablen umbenennen, damit sie anders heißen, als die gleichnamigen Funktionesparameter

Wohl eher andersrum!

void matrix::mul(matrix feldLinks, matrix feldRechts)
{
  for (int i=0; i<this->m; m++)	//Zeilen durchschalten
  ...
}

m++?

Wovon soll da irgendwer 'nen Drehwurm bekommen?!

in diesem Konstruktor

matrix::matrix(int n, int m) : n(n), m(m)

gelten folgende Regeln:

3.4.1 Unqualified name lookup
11 During the lookup for a name used as a default argument (8.3.6) in a function parameter-declaration-clause or used in the expression of a mem-initializer for a constructor (12.6.2), the function parameter names are visible and hide the names of entities declared in the block, class or namespace scopes containing the function declaration. [ Note: 8.3.6 further describes the restrictions on the use of names in default arguments. 12.6.2 further describes the restrictions on the use of names in a ctor-initializer. —end note ]
12.6.2 Initializing bases and members
2 In a mem-initializer-id an initial unqualified identifier is looked up in the scope of the constructor’s class and, if not found in that scope, it is looked up in the scope containing the constructor’s definition. [ Note: If the constructor’s class contains a member with the same name as a direct or virtual base class of the class, a mem-initializer-id naming the member or base class and composed of a single identifier refers to the class member. A mem-initializer-id for the hidden base class may be specified using a qualified name. —end note ] Unless the mem-initializer-id names the constructor’s class, a non-static data member of the constructor’s class, or a direct or virtual base of that class, the mem-initializer is ill-formed.
12 Names in the expression-list or braced-init-list of a mem-initializer are evaluated in the scope of the constructor for which the mem-initializer is specified. [ Example:
class X {
int a;
int b;
int i;
int j;
public:
const int& r;
X(int i): r(a), b(i), i(i), j(this->i) { }
};
initializes X::r to refer to X::a, initializes X::b with the value of the constructor parameter i, initializes X::i with the value of the constructor parameter i, and initializes X::j with the value of X::i; this takes place each time an object of class X is created. —end example ] [ Note: Because the mem-initializer are evaluated in the scope of the constructor, the this pointer can be used in the expression-list of a mem-initializer to refer to the object being initialized. —end note ]

in der mem-initializer-list im Konstrukor kann der Compiler also n und n noch auseinanderhalten, aber spätestens hier ist dann der Wurm drin:

void print(int n, int m);

der Compiler führt das dann zwar aus, aber es ist besser, die Member n und m anders zu benennen als die Funktionsparameter, denn in der Funktion print sind die Member n und m hidden und es geschehen merkwürdige Dinge

Und auch für den C++-Programmierer: Denn die Faustregel ist: Zuerst werden in inneren, und dann in äußeren Scopes gesucht. Und in der Initialisierungsliste lässt sich anhand der Syntax und logischen Gegebenheiten (wie der, dass Funktionsparameter nicht in der Initialisierungsliste "initialisiert" werden können) eben die jeweiligen Namen deduzieren.

class matrix
{
private:
    int n, m;
    int** feld;

public:
    matrix(int n, int m);
    ~matrix();
    void print(int n, int m);
    void input();
    int getVal(int n, int m);
};

ihr würded also empfehlen, die Benennung der Member und Funktionsparameter beizubehalten?

Wir haben gar nix empfohlen und auch nichts suggeriert. Ich würde beispielsweise, tatsächlich um ein schnelleres Verstehen des Codes zu fördern, die Funktionsparameter mit Unterstrichen o.ä. entsprechend Kennzeichnen. Wichtig ist, dass man diesen Stil dann konsequent beibehält.

Ich würde beispielsweise, tatsächlich um ein schnelleres Verstehen des Codes zu fördern, die Funktionsparameter mit Unterstrichen o.ä. entsprechend Kennzeichnen. Wichtig ist, dass man diesen Stil dann konsequent beibehält.

Bitte nicht schon wieder diese Diskussion!
Ich würde generell nicht n und m verwenden, sondern irgendetwas wie width, height oder rows, columns oder so.

Sone schrieb:

Ich würde beispielsweise, tatsächlich um ein schnelleres Verstehen des Codes zu fördern, die Funktionsparameter mit Unterstrichen o.ä. entsprechend Kennzeichnen. Wichtig ist, dass man diesen Stil dann konsequent beibehält.

Bitte nicht schon wieder diese Diskussion!
Ich würde generell nicht n und m verwenden, sondern irgendetwas wie width, height oder rows, columns oder so.

Aha, du hast keine Lust auf die Diskussion, förderst sie aber durch deine Anteilnahme...

Persönlich könnte ich die Variablen leichter ihrem Zweck zuordnen, wenn ich sie auf die Membervariablen "abbilden" kann, aber das ist Geschmackssache.
(Dementsprechend würde ich auch den Member zu mWidth & co. o.ä. umbenennen)