ich möchte ein 2 dimensionales Feld zur Laufzeit erzeugen in dem Werte 0/1 gespeichert werden (mit array bekomme ich es nicht hin). Die Größe (Höhe * Breite) wird dem Konstruktor als Parameter übergeben. Also zum Beispiel:

#ifndef FELD_H
#define FELD_H

class Feld {
public:
	Feld(size_t width, size_t height) {
		// irgendwas erzeugen, wo man Feldwerte speichern kann
	};

	enum wert readPos(size_t x, size_t y);
	void setPos(size_t x, size_t y, enum wert feldinhalt);

private:
	//char board[höhe?][breite?];
};

#endif

Ich wollte dann mit der readPos und setPos auf diese Werte zugreifen. Mit einem array geht das scheinbar nicht, da beim Kompilieren schon bekannt sein muss, wie groß dieses ist.

Nun dachte ich an Pointers. Und dann Speicher allokieren. Also bei einem ein dimensionales Feld dann einfach den Zeiger entsprechend oft erhöhen, um auf den richtige Wert zu zugreifen.
Aber wie mache ich dies nun bei einem zwei dimensionalen Feld?

#ifndef YOUR_PROJECTS_FELD_H
#define YOUR_PROJECTS_FELD_H

#include <vector>

typedef ... wert;

class Feld {
public:
   typedef std::vector<wert>::reference reference;
   typedef std::vector<wert>::size_type size_type;
   Feld() : size1_(0), size2_(0) {}
   Feld(size_type size1, size_type size2) : size1_(0), size2_(0) {resize(size1,size2);}
   void resize(size_type size1, size_type size2);
   size_type size1() const {return size1_;}
   size_type size2() const {return size2_;}
   wert      operator()(size_type i, size_type j) const {return elements_[indexof(i,j)];}
   reference operator()(size_type i, size_type j)       {return elements_[indexof(i,j)];}
private:
   size_type size1_, size2_;
   std::vector<wert> elements_;
   size_type indexof(size_type i, size_type j) {return i*size2_+j;}
};

#endif

(ungetestet)

Was ist der Unterschied zwischen dem wert-Operator und dem reference-Operator?
Und für resize(size_type size1, size_type size2) fehlt doch noch irgendwie, dass size1_, size2_ den Wert zugewiesen bekommt?

Das ist das erstmal, dass ich mit vector arbeite.

resize(size_type size1, size_type size2) {elements_.resize(size1 * size2);}

ist bestimmt falsch, oder?

Was ist der Unterschied zwischen dem wert-Operator und dem reference-Operator?

Der erste wird genommen, wenn Du "nur Lesezugriff" auf ein Feldobjekt hast. Der zweite, wenn Du auch "Schreibzugriff" hast. Das liegt an der Präsenz/dem Fehlen von const dahinter. std::vector<wert>::reference ist das, was der nicht-const operator[] von vector zurück gibt. Damit kannst du das Element auch verändern:

Feld f = ...;
f(2,2) = 99;

Wenn Du jetzt nur Wahrheitswerte speichern willst, kannst Du ruhig bool statt wert verwenden. std::vector<bool> legt die Daten auch komprimiert im Speicher ab. Wenn Dir das dann aber zu langsam ist, kannst Du bei Deinem enum bleiben oder std::vector<char> verwenden oder so. Dann verbrätst Du ein ganzes Byte für einen Wahrheitswert, es mag aber schneller sein.

bugbug schrieb:

Was muss ich nehmen, damit resize die richtige Größe übergeben bekommt?

resize(size_type size1, size_type size2) {elements_.resize(size1 * size2);}

ist bestimmt falsch, oder?

Innerhalb von resize solltest auch auch noch die Datenelemente size1_ und size2_ ändern. Sonst sieht das OK aus.

bugbug schrieb:

Was ist der Unterschied zwischen dem wert-Operator und dem reference-Operator?

Der erste wird genommen, wenn Du "nur Lesezugriff" auf ein Feldobjekt hast. Der zweite, wenn Du auch "Schreibzugriff" hast.

Das stimmt so eigentlich nicht. Der Unterschied ist eigentlich, dass wenn du den "Wert-Operator" benutzt, wird eine Kopie von dem Objekt erzeugt. Wenn du eine Referenz übergibst kannst du das objekt direkt manipulieren. Intern wird das mit Zeigern realisiert.
Stichwort: call-by-value bzw. call-by-reference

Will man nur lesezugriff verwendet man ein const