2-dimensionales Array

Ich möchte ein 2 dimensionales Array deklarieren, dessen Grösse aber erst zur Laufzeit festlegen. Ich denke es müsste mit einem Pointer funktionieren, ich kenne mich aber leider noch nicht allzu gut aus. Über Hilfe wäre ich dankbar..

Mfg

Jan

KPC

Hilfe gibts in der FAQ oder beim Suchen!

Ich habe das Array jetzt mittels der 1. Methode implementiert also ein Array von Zeigern auf int Arrays erstellt. Das hat soweit auch gut geklappt, mein eigentliches Ziel ist es aber dieses Array an eine Funktion zu übergeben. In dem C++ Buch von Stroustroup wird das auch ganz gut beschrieben aber irgendwo ist bei mir dennoch ein Fehler.

In dem Buch wird das Array mit

int spielfeld[4][4];

deklariert und die Funktion sieht da so aus

void machwas(int* spielfeld, int dim1, int dim2)

und zugreifen kann man nun über spielfeld[i*dim2 + j]. Leider funktioniert das nicht mit dem Array was ich oben angegeben habe. Könnte mir jemand helfen und sagen wie ich die Funktion ändern muss.

Mfg

Jan

Asgard

Zeig doch mal die entsprechenden Teile des Programms (Aufruf der Funktion etc.). Denn ohne genau zu wissen, was Du gemacht hast, kann man nur schwer sagen, wo der Fehler liegt.

Das Array ist quadratisch von daher ist die 1. dimension = 2.dimension

--Deklaration des Arrays

private:
 int dim;
 int** spielfeld;

--Initialisierung

spielfeld = new int*[dim];

for(int j=0; j<dim;j++)
  spielfeld[j] = new int[dim];
for(int i=0;i<dim;i++){
  for(int j=0;j<dim;j++){
    spielfeld[i][j] = i*dim+j;
  }
}

--Funktionsaufruf

printArray(&spielfeld[0][0],dim);

--Funktion

void Berechnung::printArray(int* spielfeld, int dim){
for(int i=0;i<dim*dim;i++){
 cout << spielfeld[i] << '\n';
}

KPC

Wie du schon festgestellt hast, erzeugst du ein quadratisches Array, also vom Typ int ** und nicht ein eindimensionales vom Typ int *!
Du musst also auch in der Funktion ein 2-dimensionales übergeben:

void Berechnung::printArray(int** spielfeld, int dim){ 
for(int i=0;i<dim;i++){ 
 for(int j=0;j<dim;j++){ 
 cout << spielfeld[i][j] << '\n'; 
}

volkard

eigentlich ist es eine gute übung, sich eine klase für 2d-arrays zu bauen.

eigentlich ist es eine gute übung, sich eine klase für 2d-arrays zu bauen.

In etwa so:

template <class T> class TwoDimArray {
public:
	TwoDimArray(int x, int y) : x_(x), y_(y) {
		matrix_ = new T[x * y];
	};

	TwoDimArray(const TwoDimArray& lhs) {
		x_ = lhs.x_;
		y_ = lhs.y_;
		matrix_ = new T[x_ * y_];
		for (int i = 0; i < x_ * y_; i++) {
			matrix_[i] = lhs.matrix_[i];
		}
	};

	~TwoDimArray() {
		delete [] matrix_;
	};

	T& operator= (const TwoDimArray& lhs) {
		x_ = lhs.x_;
		y_ = lhs.y_;
		if (x_ != lhs.x_ || y_ != lhs.y_) {
			delete [] matrix_;
			matrix_ = new T[x_ * y_];
		}
		for (int i = 0; i < x_ * y_; i++) {
			matrix_[i] = lhs.matrix_[i];
		}
	};

	T& operator() (int x, int y) {
		assert(0 <= y && y <= y_);
		assert(0 <= y && y <= y_);
		return matrix_[x_ * y + x];
	};

	T operator() (int x, int y, T v) const {
		assert(0 <= x && x <= x_);
		assert(0 <= y && y <= y_);
		matrix_[x_ * y + x] = v;
	};

	int x() const { return x_; }
	int y() const { return y_; }
private:
	T * matrix_;
	int x_;
	int y_;
};

just kidding

mfg

volkard

kidmaster schrieb:

In etwa so:...

jo. sehr fein.