Übergabe 2d Matrix an Funktion

9 Beiträge18.11.2009Archiviert
movco18.11.2009 · Beitrag #20603
Avatar
Mitglied seit: 08.10.2007
Forenbeiträge: 264
Besuche: 1383
Hallo ich hab ein Problem, was banal ist, aber wo ich momentan nicht drauf komme ........
Also ich habe eine 2d Matrix
int matrix[2][400] und möchte es jetzt der Funktion int bla übergeben. So in der *.h datei schreibe ich die Funktion unter Public als int bla(matrix[2][400]) hin und in der cpp als Klasse::bla(matrix[2][400]). übergabe ist bla(matrix[2][400]). Nur übergibt er mir die Matrix von der einen Funktion in die andere nicht. Wo ist mein Denkfehlrer ... ich komm grad net drauf 17 h. Programmieren hinter mir und seh die einfachsten sachen net mehr. Werde wahnsinnig. Bitte um hilfe. C++

LG
Bene18.11.2009 · Beitrag #20604
Avatar
Mitglied seit: 19.04.2005
Forenbeiträge: 147
Besuche: 2161
Du musst doch einen Übergabetyp angeben, also
Klasse::bla(int matrix[2][400])

Einen Rückgabetyp für die Funktion brauchst du natürlich auch noch, falls du den auch vergessen hast
movco18.11.2009 · Beitrag #20605
Avatar
Mitglied seit: 08.10.2007
Forenbeiträge: 264
Besuche: 1383
ja das habe ich schon gemacht ... natürlich hab ich Klasse::bla(int matrix[2][400]) gemacht. und in der *.h hab ich auch bla(int matrix[2][400]) gmacht. (ist ja nur ein verkürztes Bsp. jetzt.) Aber irgendwie übergibt er mir die Matrix net. Rückgabetyp hab i auch definiert ... und dann wäre der error anders.

LG
Vellas18.11.2009 · Beitrag #20606
Avatar
Mitglied seit: 13.04.2007
Forenbeiträge: 232
Besuche: 3982
Also eigentlich müsste das funktionieren, folgendes funktioniert bei mir (VS2008, sollte aber auch mit g++ kein Problem sein):
[cli]
void print(int matrix[2][5]) {
for(int i=0; i<2; ++i)
for(int j=0; j<5; ++j)
cout << matrix[j] << endl;
}

int main() {
int matrix[2][5] = {
{
0,1,2,3,4
},
{
5,6,7,8,9
}
};

print(matrix);
}
[/cli]

Ansonsten gäbe es noch folgende Möglichkeit:
[cli]void print(int *matrix, int row, int col) {
for(int i=0; i<row; ++i)
for(int j=0; j<col; ++j)
cout << matrix[col*i+j] << endl;
}[/cli]
bzw.
[cli]void print(int *matrix, int row, int col) {
for(int i=0; i<row*col; ++i)
cout << matrix << endl;
}[/cli]
Die Übergabe sieht bei den beiden letzteren Funktionen wie folgt aus:
[cli]print(&matrix[0][0], 2, 5);[/cli]

// Edit:
Ah, die Übergabe bei dir hab ich übersehen. Kein Wunder das es nicht funktioniert. bla(matrix[2][400]) kann ja nicht funktionieren. Damit würdest du ein Element übergeben. Aber da das Array mit 2 und 400 deklariert ist, wäre das in diesem Fall eine Speicherzugriffsverletzung, weil du außerhalb der Grenzen auf das Array versuchst zuzugreifen. Du musst die Funktion natürlich ohne [2][400] aufrufen, also nur den Variablennamen angeben: bla(matrix). Siehe dazu mein erstes Beispiel.
Und wenn du die Funktion definierst, hast du hoffentlich nicht nur Class::method(...), sondern auch bei der Definition den Rückgabetyp angegeben, also:
type Class::method(...).

Aber nach 17 Stunden ist es auch kein Wunder mehr, wenn man die einfachsten Dinge nicht mehr sieht. Selbst bei Termindruck höre ich spätestens nach 15 Stunden auf. In der Regel um dann zu schlafen. Aber nach so vielen Stunden sieht man einfach nichts mehr. Da braucht man zwischendurch auch einfach mal eine Pause. Programmieren geht ausgeruht besser. Lieber mit 100%, 2 Stunden dran sitzen, als mit 20% 10 Stunden. ;)

// Edit 2:
col*i+j statt row*i+j.

Greetz

[ Bearbeitet Fr, 20. Nov 2009, 09:42 ]
movco18.11.2009 · Beitrag #20608
Avatar
Mitglied seit: 08.10.2007
Forenbeiträge: 264
Besuche: 1383
Haha ja das mit dem Aufruf ... das ist mir auch klar, das waren nur die 17 h die das hingeschrieben haben. Danke für deine ausführliche Erklärung. Ich habe jetzt komischerweise alles neu deklariert, ganz gleich wie zuvor (denk ich halt mal) und jetzt klappt es.
Übergabe:
calcnimbers(stapelgeteilt, nimbermatrix);

Funktion (cpp):
int CalcNim::calcnimbers(vector <vector<int> > stapeln, int nimbermatrix[2][400])
{

}
Funktion(h):
int calcnimbers(std::vector <std::vector<int> > stapeln,int nimbermatrix[2][400]);

So müsste das jetzt passen oder? Oder sollte die Übergabe so sein?:
calcnimbers(stapelgeteilt, &nimbermatrix);

Übrigens schlussendlich sollte das Prog. unzählige/unendliche Heap-Games mittels Nimbers berechnen können.

Aber etwas anderes. Und zwar übergebe ich der Funktion Nimbers eine Variable "maxheapsize". Mit der Habe ich zuerst die nimbermatrixspeicherreservierung def. Also nimbermatrix[2][maxheapsize]. So nun benötige ich aber auch die gleiche Größe der Matrix in der Funktion Calcnimbers(...). Da ich aber die Matrix (Array) schon in den Funktionsparametern def. kann ich ja nicht auf maxheapsize zugreifen. Ich könnte diese als Globale-Variable def. aber wie funktionert das in der *.h datei? Sonst arbeite ich halt mit 400, ist die maximale size, aber halt eine größere Speicherverwaltung.

LG und danke für eure Hilfe / Erklärung(en)
[ Bearbeitet Mi, 18. Nov 2009, 20:32 ]
Vellas18.11.2009 · Beitrag #20610
Avatar
Mitglied seit: 13.04.2007
Forenbeiträge: 232
Besuche: 3982
Du könntest das ganze dynamisch programmieren und dann auch entsprechend anders übergeben, als int **arr. Dann per new[]/delete[] den Speicher allokieren bzw. freigeben. Beim Funktionsaufruf Zeilen und Spalten mit übergeben, ähnlich dem zweiten Beispiel von mir. Aber kannst du nicht direkt mit Vektoren arbeiten, statt mit normalen Arrays?

Greetz
movco19.11.2009 · Beitrag #20611
Avatar
Mitglied seit: 08.10.2007
Forenbeiträge: 264
Besuche: 1383
Ja wiest siehst hab ich eh sonst vektoren verwendet (bei dem kleinen Einblick. Code will ich nicht posten wegen Uni und Plagiatssoftware). Ka da hat mich halt irgendwann ein Hund geritten und ich habe mit der Matrix angefangen. Jetzt zieht sich halt die durch den code ;). Aber ich hab das ganze jetzt dynamisch gemacht. Bin net rum kommen das umzuschreiben.
Vektor hab ich da glaube ich nicht verwendet, da ich zu beginn schon die maximale und zugleich minimale Größe des Arrays durch die maxstapelgröße bestimmen konnte. Dadurch ist es ja besser als dynamisch da ich genau meinen benötigten Speicher allokiere. Aber da das jetzt mit der globalen Variable und Co. so umständlich wird, hab ich das ganze jetzt dynamisch gemacht.

LG
movco22.11.2009 · Beitrag #20612
Avatar
Mitglied seit: 08.10.2007
Forenbeiträge: 264
Besuche: 1383
Eine andere Frage. Wie schaut das aus wenn ich die Matrix jetzt returnen will?
Dh funktion int Bla::bla() soll die Matrix gra[2][400] returnen. Ist ja nicht möglich daweil. Wenn ich jetzt int **Bla::bla() mache sollte es ja mit return &gra klappen oder? Aber bei mir klappt das net.

Kann mir das wer kurz erklären? LG
Vellas22.11.2009 · Beitrag #20619
Avatar
Mitglied seit: 13.04.2007
Forenbeiträge: 232
Besuche: 3982
In diesem Fall würde man ebenfalls wieder nur einen Zeiger auf das erste Element zurückgeben, wie bei der Übergabe oben. Man würde also &v[0][0] nutzen und int* als Rückgabetyp. Man muss sich immer vor Augen halten, dass die Elemente in einem mehrdimensionalen Array hintereinander liegen. Daher kann jedes n-dimensionale Array eindimensional abgebildet werden. Es reicht, also wenn du den Zeiger auf das erste Element zurück gibst. Und als Rückgabetyp int* verwendest. Beachte jedoch immer, dass deine Matrix nicht zerstört wird und anschließend noch Zugriffe auf diese statt finden. Du musst bei dieser Rückgabe darauf achten, dass der Zeiger nicht mehr verwendet wird, wenn dein Objekt der Klasse, dass das Array beherbergt, zerstört wurde.

Man kann Arrays nicht einfach nur Zuweisen, man müsste sie entsprechend kopieren. Ein Zeiger, als Verweis um sich das Kopieren zu sparen, wird man wohl immer mit einem einfachen Zeiger machen müssen. Bei der Parameterübergabe gibt es diverse Varianten um ein mehrdimensionales Array zu übergeben (siehe Link).

Du solltest dir mal einiges über Arrays anlesen. Sowohl in entsprechenden Büchern, als auch im Internet gibt es so einiges zu diesem Thema. Arrays und Zeiger sind wohl eines der komplexesten Themen in C und C++.

Sehr gute FAQ zu diesem Thema: http://www.dclc-faq.de/kap2.htm

Greetz
[ Bearbeitet Mo, 23. Nov 2009, 00:58 ]