array mit zeigern auf zeiger

[uga_dawg]

hallo erstmal.

ich habe folgendes problem und wie ihr sicher schon erraten habt, geht es um ein allseits bekanntes: zeigerzeugs. ich bin neu in C++ und habe auch schon viel nachgelesen und versucht, aber irgendwie klappt es diesmal nicht so recht.

folgendes: ich brauche ein 3-dimensionales array von zeigern, wobei jedoch die letzte dimension erst zur laufzeit bekannt ist und alle verschieden sind.

meine idee ist bisher wie folgt

ein zweidimensionales array von zeigern erzeugen (ich nenn's mal A). die zeiger darin zeigen abermals auf arrays verschiedener groessen die auch wieder zeiger enthalten. diese letzten zeiger sollen dann auf die objekte gerichtet sein, die ich tatsaechlich benoetige.

damit nicht genug, ich muss das ganze noch an eine methode uebergeben, da ich schaetze, dies kann ich mit einem pointer auf A[0][0] oder so regeln und mich dann durchhangeln.

ich hoffe ihr koennt mir helfen und falls ich noch etwas unklar erlaeutert habe, dann sagt es schnell an, damit das dann aus der welt ist und ich hier weiterkomme

DANKE

[VaNaTiC]

Musst Du das mit Zeigern machen?

Oder könntest Du auch höhere Datentypen, wie Template-Klassen nehmen?

Und wo genau ist Dein Problem? Deklaration, Instanziieren, Füllen?

[uga_dawg]

Musst Du das mit Zeigern machen?

Oder könntest Du auch höhere Datentypen, wie Template-Klassen nehmen?

also allg geht es um eine approximation von funktionen in der numerik, also mathematische berechnung. daher sind also viele koeffizienten direkt zu benennen, daher mein ansatz mit arrays. ich bin aber natuerlich gerne bereit andere modellierungen zu waehlen.

Momentan hab ich mich leider darauf beschraenken muessen, in der letzten dimension die groesstmoegliche tiefe rauszusuchen, das ganze dreidim mit festen letzten groessen zu machen und dann nur zeiger im array zu haben. ABER, das wird wohl nur fuer testbeispiele gehen, fuer interessante groessen befuerchte ich, dass mir die kiste dann mit speicherplatz um die ohren fliegt... na ja. also zumindest daher meine intention effizienz bzgl speicherplatz und performance.

Und wo genau ist Dein Problem? Deklaration, Instanziieren, Füllen?

leider bei so ziemlich allem. zu testzwecken arbeite ich mit integern. ich schaetze, dass sich bei mir das verstaendnis fuer zeiger noch nicht genuegend gesetzt hat.

also gedacht ist ja wie oben geschrieben ein 2dim array mit zeigern, daher schreibe ich

int * M[zeilen][spalten],

damit sollte ich ja nun ein 2dim array mit zeigern auf ints haben. um die eintraege festzulegen schreibe ich dann

M[j] = new int[laenge]

wobei diese laenge fuer alle iterationen der i,j verschieden sind. das hier kann aber schonmal nicht stimmen, da ich ja keine array mit integern haben moechte, sondern mit zeigern auf integers. und da liegt das hase im pfeffer.

ich hab's mit sachen wie int ** M[zeilen][spalten] probiert und so, aber da reicht dann mein verstaendnis der zeiger eben nicht weit genug... na ja, zumindest sollte dann letztlich sowas stehen wie

M[j][k] = new int(2);

oder so, wobei ich schaetze, dass ich es wohl kaum schaffen werde die letzte dimension mit diesen einfach [] klammern anzusprechen.

hoffe es ist nun klarer wo mein problem liegt und wo ich hin will.

danke uebrigens fuer die fixe antwort.

[TDM]

Seh ich das richtig?:

Matrix[Zeile][spalte] -> vector<int> mit Anzahl beliebig

Matrixklassen gibts genug über google zu finden. vector ist im Endeffekt ja auch nur eine Liste. Das ganze schön in eine Klassenhierachie und schon sparst du dir lästiges Zeigergefriemel.

[uga_dawg]

hmn...

ich schaetze soeine Matrixklasse wird wohl auch ueber arrays definiert sein, nur dass man dann in einer methode die die matrix uebergeben bekommt ganz einfach drauf zugreifen kann mit der doppelindizierung [][].

und die vector<int> klasse wird wohl auch zugriff in O(1) gewaehrleisten und mit bekannten groessen keinen speicheroverhead haben.

perfect, klingt supi! danke fuer den tipp, dann muss ich mich hier nichtmehr rumquaelen.

vielen dank fuer's augen oeffnen

[uga_dawg]

okay, das scheint so weit das zu machen was ich will und brauche. nun habe ich das problem, dass ich nicht weiss, wie ich, wenn ich das ganze an eine function uebergebe, an meine daten komme. insbesondere weiss ich nicht so recht wie weit ich meine schreittweite waehlen muss wenn ich mit nem zeiger durch meine 2dimArray laufe.

ich habe momentan folgenden code, vielleicht (d.h. bestimmt) habt ihr noch weitere hilfsvorschlage.

#include <iostream>

#include <stdlib.h>

#include <time.h>

#include <vector>


void h( std::vector<int> *M, int zeilen, int spalten,int laenge){

	std::vector<int> *pointer = M;

	std::vector<int> helfer;


	for(int i=0; i<zeilen; i++){

		std::cout << "\t*[  ";

		for(int j=0; j<spalten; j++){

			helfer = *pointer;

			std::cout << "(";

			for(int k=0; k<laenge; k++){

				std::cout << helfer[k] << ",";

			}

			pointer += sizeof(pointer); // denke hier liegt u.a. ein fehler

			std::cout << ")  ";

		}

		std::cout << "]\n";

	}

}



int main()

{

	int zeilen = 3;

	int spalten = 4;

	int laenge = 2; // spater verschieden

	srand(15);


	std::vector<int> *M[zeilen][spalten];


	for(int i=0; i<zeilen; i++){

		std::cout << "\t[  ";

		for(int j=0; j<spalten; j++){

			M[i][j] = new std::vector<int>(laenge);

			std::cout << "(";

			for(int k=0; k<laenge; k++){

				(*M[i][j])[k] =  *(new int(rand() % 9 + 1));

				std::cout << (*M[i][j])[k] << ",";

			}

			std::cout << ")  ";

		}

		std::cout << "]\n";

	}

	std::cout << "**************************\n";


	h(M[0][0],zeilen,spalten,laenge);


	std::cout << "\nprog ended successfully\n";

	return 0;

} // end main()

dabei habe ich mich erstmal nicht auf eine matrix[][] klasse versteift, da gehofft hatte mir den aufwand zu ersparen eine geeignete klasse zu suchen (die soll ja pointer belieber typen enthalten und neuschreiben wollte ich's als newbie auch erstmal nicht, da ich dann auch operatoren neudefinieren muesst um sie wirklich sinnvoll einsetzen zu koennen...)

[Klotzkopp]

insbesondere weiss ich nicht so recht wie weit ich meine schreittweite waehlen muss wenn ich mit nem zeiger durch meine 2dimArray laufe.

Warum willst du denn mit einem Zeiger durch dein Array laufen?

Und ist es wirklich unbedingt notwendig, dass die Elemente Zeiger sind?

Und das hier:

*(new int(rand() % 9 + 1))

ist ein astreines Speicherleck. Die Zeiger kannst du nie wieder freigeben. Ich habe mir mal erlaubt, das ganze ohne Zeiger zu machen.

#include <iostream>

#include <cstdlib>

#include <ctime>

#include <vector>


const int zeilen = 3;

const int spalten = 4;


void h( std::vector<int> M[zeilen][spalten]){

	for(int i=0; i<zeilen; i++){

		std::cout << "\t*[  ";

		for(int j=0; j<spalten; j++){

			std::cout << "(";

			int laenge=M[i][j].size();

			for(int k=0; k<laenge; k++){

				std::cout << M[i][j][k] << ",";

			}

			std::cout << ")  ";

		}

		std::cout << "]\n";

	}

}



int main()

{

	int laenge = 2; // spater verschieden

	srand(15);


	std::vector<int> M[zeilen][spalten];


	for(int i=0; i<zeilen; i++){

		std::cout << "\t[  ";

		for(int j=0; j<spalten; j++){

			M[i][j].resize(laenge);

			std::cout << "(";

			for(int k=0; k<laenge; k++){

				M[i][j][k] =  rand() % 9 + 1;

				std::cout << M[i][j][k] << ",";

			}

			std::cout << ")  ";

		}

		std::cout << "]\n";

	}

	std::cout << "**************************\n";


	h(M);


	std::cout << "\nprog ended successfully\n";

	return 0;

} // end main()[/code]

[uga_dawg]

Warum willst du denn mit einem Zeiger durch dein Array laufen?

Es ist so, dass in dem eigentlichen Programm die Funktion h() in einer anderen Klasse liegt und auch liegen soll. wenn ich dann ein mehrdimensionales Array uebergebe, erhalte ich ja nur einen Zeiger darauf. das (aus meiner sicht)groessere Probelem ist aber, dass die dimensionen des Arrays zwar zum Zeitpunkt der Funktion h() fest sind, aber eingabenabhaengig sind. daher geht soeien const zeilen = ...; nicht und ich koennte auch nicht sowas schreiben wie

h(std::vector<int> M[zeilen][spalten]);

denn zeilen und spalten sind wie gesagt von aufruf zu aufruf verschieden. falls es jedoche eine andere Moeglichkeit gibt das Array zu traversieren, dann bin ich mehr als bereit mir das anzuschauen und zu nutzen (sofern nuetzlich )

Und ist es wirklich unbedingt notwendig, dass die Elemente Zeiger sind?

na also ich dachte an zeiger, da ich wie in dem codebeispiel oben neue Objekte erstellen will und muss. Da ich hierfuer nicht immer einen kopierkonstruktor anschmeissen will, hab ich gehofft mit zeigerumbiegen das zu erreichen was ich will. also was ich eigentlich will ist praktisch nicht

std::vector<int> M[zeilen][spalten];

sondern

std::vector<*int> M[zeilen][spalten];

aber sowas wird wohl nicht funktionieren, oder ich hab noch nicht raus wie. kurzum ich will keinen Vector von objekten, sondern einen Vector mit zeigern auf diese Objekte um mir kopieraktionen zu sparen um effizienter zu arbeiten. gibt es eine anderen moeglichkeit, bin ich natuerlich offen. es kann natuerlich sein, dass mein fehler in der sprachkenntnis liegt. gibt es eine andere moeglichkeit einem vectoreintrag eine variable zuzuordnen ohne zu kopieren?

Und das hier:

*(new int(rand() % 9 + 1))

ist ein astreines Speicherleck. Die Zeiger kannst du nie wieder freigeben.

seh ich ein, schon bloed, danke, sowas soll natuerlich unbedingt vermieden werden

ich hoffe es ist ungefaehr klar was ich ueberhaupt will...

[VaNaTiC]

Wozu übergibst Du an h() die laenge? Du nutzt doch extra einen vector<>, der kennt doch seine Elementanzahl.

Ich find das alles ziemlich undurchsichtig.

Eventuell ist eine simple vector<vector<vector<int>>> ausreichend?

Hier findest Du was zu Zeigerarithmetik in C++:

Benchmark per Matrixmultiplikation von C++ <vector>, array und Fortran Dimension - Planet 3DNow! Forum

[Klotzkopp]

darauf. das (aus meiner sicht)groessere Probelem ist aber, dass die dimensionen des Arrays zwar zum Zeitpunkt der Funktion h() fest sind, aber eingabenabhaengig sind.

Dann empfehle ich, das zweidimensionale Array auf ein eindimensionales Array abzubilden, und die Positionen entsprechend auszurechnen. Etwas anderes macht der Compiler bei zweidimensionalen Arrays auch nicht. Andererseits sind mehrdimensionale Arrays immer ein furchtbares Gehampel, wie du ja sicher gemerkt hast.

na also ich dachte an zeiger, da ich wie in dem codebeispiel oben neue Objekte erstellen will und muss.

Mit Objekten meinst du jetzt die ints? Dann gibt es immer noch keinen Grund, warum die Vectoren (die dritte Dimension) Zeiger sein sollten.

Da ich hierfuer nicht immer einen kopierkonstruktor anschmeissen will, hab ich gehofft mit zeigerumbiegen das zu erreichen was ich will.

Kommt drauf an, wie aufwändig die Kopieroperationen sind. Wenn die Objekte eine ordentliche swap-Methode haben, kann das sehr schnell sein. Andererseits verbrauchen die Zeiger natürlich zusätzlichen Speicher.

also was ich eigentlich will ist praktisch nicht

std::vector<int> M[zeilen][spalten];

[/CODE]




sondern

[CODE]

std::vector<*int> M[zeilen][spalten];

aber sowas wird wohl nicht funktionieren, oder ich hab noch nicht raus wie.

Vermutlich meinst du std::vector<int*> M[zeilen][spalten];

Das geht, ist aber Blödsinn, zumindest für int. Kein Performancegewinn, doppelter Speicherbedarf.

kurzum ich will keinen Vector von objekten, sondern einen Vector mit zeigern auf diese Objekte um mir kopieraktionen zu sparen um effizienter zu arbeiten. gibt es eine anderen moeglichkeit, bin ich natuerlich offen.

Wie gesagt, das kommt stark auf die Objekte an. Wie groß sind die denn so?