zuerst erstmal mein etwas langer quellcode:

struct cInDat
{
	public:
		void	SetINT (int i, int zahl)
		{
			itsINT[i] = zahl;
		}
		double	GetINT (int i) const
		{
			return itsINT[i];
		}
		void	DecLayOR ()
		{
			int i;
			itsINT = new int [2];
			for (i=0;i<2;i++)
				itsINT[i] = -1;
		}
	private:
		int		*itsINT;
};

struct cData
{
	public:
		void SetDat (int i, cInDat data)
		{
			itsVAL[i].push_back(data);
		}
		void SetVal (int type, int num, int i, double zahl)
		{
			itsVAL[type][num].SetINT(i,zahl);
		}
		int  GetVal (int type, int num, int i) const
		{
			return itsVAL[type][num].GetINT(i);
		}
	private:
		vector <cInDat> itsVAL[2];
};

int main()
{
	cInDat MyTest;
	cData MyData;
	int i;

	MyTest.DecLayOR();
	for (i=0;i<2;i++)
		MyData.SetDat(i,MyTest);

	MyData.SetVal(0,0,0,1);

	cout << MyData.GetVal(0,0,0) << " " << MyData.GetVal(1,0,0);
}

der code funktioniert in etwa so: zuerst lege ich mir eine struktur fest (cInDat), die aus einem eindimensionalem array besteht. mit dieser struktur baue ich eine weitere struktur (cData), die cInDat in form von vectoren speichert.

das problem ist nun wie folgt: warum wird in zeile 54 die gleiche zahl, nämlich eins, ausgegeben?
eigentlich müsste nur der erste wert eins sein, so wie ich es in zeile 52 festgelegt habe, also nur für das erste der beiden arrays (zeile 39). der zweite wert müsste seinen ursprünglichen wert von -1 behalten (zeile 17).

DANKE.
STICK.

for (i=0;i<2;i++)
	{
		MyTest.DecLayOR();
		MyData.SetDat(i,MyTest);
	}

ich habe die main-funktion wie oben geändert. müsste ich dann noch eine funktion delete in 'cInDat' einfügen, um den zuvor geschaffenen speicherplatz wieder frei zu machen?

DANKE.
STICK.

Zweitens: An deiner Stelle würde ich die struct zu einer vollwertigen Klasse ausbauen - inklusive Konstruktor (anstelle der DecLayOR()-Methode), Cpy-Ctor und Destruktor (da gehört dann das delete[] rein).

- die 'DecLayOR()-Methode' kann leider nicht in den Konstruktor, da der wert '2' (zeile 15) erst zuvor aus einer datei ausgelesen werden muss. danach wollte ich dann die 'DecLayOR()-Methode' aufrufen.
- der hinweis mit dem delete[] im Destruktor ist gut, DANKE!

STICK.

p.s.:

Erstens: Wieso gibt dein GetINT() einen double zurück?

-> war ein versehen, da ich den code aus meiner original-datei herauskopiert und modifiziert habe.

@CStoll: danke für die hinweise.

- die 'DecLayOR()-Methode' kann leider nicht in den Konstruktor, da der wert '2' (zeile 15) erst zuvor aus einer datei ausgelesen werden muss. danach wollte ich dann die 'DecLayOR()-Methode' aufrufen.

Randfrage: Wie kommt der Wert dann in deine Methode rein?

- der hinweis mit dem delete[] im Destruktor ist gut, DANKE!

Aber dann solltest du auch darauf achten, daß dir niemand den Speicher weglöscht (sprich: Die Klasse braucht auch einen Copy-Ctor und operator=, der neuen Speicher anlegt und den Inhalt von itsINT kopiert).

class cInDat
{
	public:
		cInDat::cInDat()
		{
			Bord = 0;
		}
		cInDat::~cInDat()
		{}
		void	SetINT (int i, int zahl)
		{
			itsINT[i] = zahl;
		}
		void	SetBord (int i)
		{
			Bord = i;			
		}
		double	GetINT (int i) const
		{
			return itsINT[i];
		}
		void	DecLayOR ()
		{
			if (0 != Bord)
			{
				int i;
				itsINT = new int [Bord];
				for (i=0;i<Bord;i++)
					itsINT[i] = -1;
			}
		}
	private:
		int		Bord;
		int		*itsINT;
};

Aber dann solltest du auch darauf achten, daß dir niemand den Speicher weglöscht

das muss ich mir erstmal irgendwo durchlesen, denn das verstehe ich so nicht.

STICK.

int  itsINT[4];
		int ****itsLayINT;

ich wüsste nicht, wie dies mit einem vector umzusetzen geht.

vielleicht hast du nen tipp?
STICK.

int  itsINT[4];
		cCoo ****itsLayINT;

ich wüsste nicht, wie dies mit einem vector umzusetzen geht.

vielleicht hast du nen tipp?
STICK.

(und wenn das Feld "rechteckig" sein soll, könntest du auch einen eindimensionalen vector<> verwenden und den Index passend umrechnen)

Aber dann solltest du auch darauf achten, daß dir niemand den Speicher weglöscht

das muss ich mir erstmal irgendwo durchlesen, denn das verstehe ich so nicht.

Im Klartext: die Standard-Zuweisungen, die dir dein Compiler spendiert, kopieren flach (also nur die Zeigeradresse). Damit verwenden nach der Zuweisung Original und Kopie die selben Daten (das führt erstens zu Problemen, wenn sie sich gegenseitig beeinflussen und zweitens zu Zugriffsfehlern, wenn beide versuchen, den selben Block freizugeben - letzteres ist schwerwiegender).
Aus dem Grund mußt du, wenn du mit dynamischem Speicher hantierst, meistens den Copy-Ctor (cInDat(const cInDat& other);) und Zuweisungs-Operator (cInDat& operator=(const cInDat& other);) selber definieren, damit sie eine tiefe Kopie ihres Inhalts durchführen können.

und wenn ich anstelle des zeigers einen vector benutze, dann kann ich mir Copy-Ctor und Zuweisungs-Operator sparen und meine klasse wird etwas einfacher, richtig?

STICK.