[Anfänger]: zweidimisionales Array an Funktion Übergeben.
-
Hallo, ich bin in C noch Anfänger und beschäftige mich mit dem Arduino Uno.
Ich habe einmal ein Programm in dem sich das Array INNERHALB der Funktion Befindet./*zweidimensionales Array INNERHALB einer Funktion*/ void funktion() { int feld[3][15] = { { 0xB0,0xB1,0xB2,0xB3,0xB4 }, { 7,11,13,17,23 }, { 0b0001,0b0010,0b0011,0b0100,0b0101 } }; int anzahl_im_array =sizeof(feld) / sizeof(int) / 3 / 3; int erste_Zeile; int zweite_Zeile; int dritte_Zeile; for(int zaehler = 0 ; zaehler<anzahl_im_array ; zaehler++) { Serial.begin(115200); //Serial.println(anzahl_im_array); /*Die Zahlen im Array ausgeben*/ Serial.println(" "); Serial.println(" "); Serial.println(feld[0][erste_Zeile],HEX); Serial.println(feld[1][zweite_Zeile]); Serial.println(feld[2][dritte_Zeile],BIN); erste_Zeile++; zweite_Zeile++; dritte_Zeile++; } } void setup() { funktion(); } Serieller Monitor: C!(j 7 1 !j B1 11 10 B2 13 11 B3 17 100 B4 23 101Aber nun möchte ich die Arrays AUSSERHALB der Funktion haben und ihre daten in die Funktion bekommen nach folgendem Schema:
/*Array AUßERHALB einer Funktion*/ /*zweidimensionales Array an eine Funktion übergeben*/ int array_eins[3][21] = { { 0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6 }, { 4,6,8,10,12,14,16 }, { 0b100000,0b100001,0b100010,0b100011,0b100100, 0b1000101,0b100110 } }; int array_zwei[3][15] = { { 0xB0,0xB1,0xB2,0xB3,0xB4 }, { 7,11,13,17,23 }, { 0b0001,0b0010,0b0011,0b0100,0b0101 } }; void funktion(int feld) { int anzahl_im_array =sizeof(feld) / sizeof(int) / 3 / 3; int erste_Zeile; int zweite_Zeile; int dritte_Zeile; for(int zaehler = 0 ; zaehler<anzahl_im_array ; zaehler++) { Serial.begin(115200); /*Die Zahlen im Array ausgeben*/ Serial.println(" "); Serial.println(" "); Serial.println(feld[0][erste_Zeile],HEX); Serial.println(feld[1][zweite_Zeile]); Serial.println(feld[2][dritte_Zeile],BIN); erste_Zeile++; zweite_Zeile++; dritte_Zeile++; } } void setup() { funktion(array_eins); }Aber leider funktioniert das so nicht. Der Kompiler Meckert und ich verstehe nicht warum.
-
Deine Frage?
-
Sorry war noch nicht ganz fertig mit dem Veröffentlichen.
Wie übergebe ich ein zweidimensionales Array an eine Funktion ?
-
Ardo-Uno schrieb:
Sorry war noch nicht ganz fertig mit dem Veröffentlichen.
Wie übergebe ich ein zweidimensionales Array an eine Funktion ?Grundaätzlich auf die gleiche Weise wie eindimensionale Arrays.
Beachte dabei, dass C keine mehrdimensionalen Arrays im eigentlichen Sinne kennt, wohl aber können die Elemente eines Arrays selbst Arrays sein.
Wenn ein Array in einen Zeiger auf den Elementtyp zerfällt, ist danach Schluss: es spielt es keine Rolle, ob der Elementtyp selbst ein Array ist. Ein Zeiger auf ein Array zerfällt nicht weiter.
-
camper schrieb:
Ardo-Uno schrieb:
Sorry war noch nicht ganz fertig mit dem Veröffentlichen.
Wie übergebe ich ein zweidimensionales Array an eine Funktion ?Grundaätzlich auf die gleiche Weise wie eindimensionale Arrays.
Beachte dabei, dass C keine mehrdimensionalen Arrays im eigentlichen Sinne kennt, wohl aber können die Elemente eines Arrays selbst Arrays sein.
Wenn ein Array in einen Zeiger auf den Elementtyp zerfällt, ist danach Schluss: es spielt es keine Rolle, ob der Elementtyp selbst ein Array ist. Ein Zeiger auf ein Array zerfällt nicht weiter.Ich habe ja leichte Zweifel, dass ein Anfänger diese Erklärung versteht.
Was Camper sagen wollte: Vielleicht hast du schon einmal gesehen, dass in C Array über Zeiger übergeben werden:
void foo(int size, int *array); int main() { int mein_array[123]; foo(123, mein_array); }Ein Array kann sich wie ein Zeiger auf sein erstes Element verhalten, daher geht das. Jetzt kommen Leute manchmal auf solche Ideen:
void foo_2D(int size_x, int size_y, int **array); int main() { int mein_2D_array[123][456]; foo_2D(123, 456, mein_array); }Das ist aber falsch! mein_array kann sich zwar wie ein Zeiger auf sein erstes Element verhalten, das erste Element ist aber vom Typ int[456]. Das heißt man hat einen Zeiger auf int[456], was eben kein Zeiger auf einen Zeiger ist, was die Funktionssignatur von foo verlangt. Ein Array ist eben kein Zeiger, auch wenn es sich manchmal so verhält.
Wie geht es richtig?
Wenn man genau weiß, wie groß die innere Dimension ist, kann man diese Größe einfach fest in den Funktionsparameter einbauen. Um beim obigen Beispiel zu bleiben:void foo_2D(int size_x, int (*array)[456]); int main() { int mein_2D_array[123][456]; foo_2D(123, mein_array); }Nun verlangt foo_2D nach einem Zeiger auf int[456], was genau passt.
Aber was, wenn man nicht im Vorhinein weiß, wie groß die innere Dimension ist?
Eine Möglichkeit ist, selber die Indexberechnungen vorzunehmen. Dazu lässt man sich einen Zeiger auf das allererste Element geben und berechnet sich selber ,wo der Rest liegt:void foo_2D(int size_x, int size_y, int *array) { int element_an_34_56 = *(array + 34*size_y + 56); // mein_array[34][56] } int main() { int mein_2D_array[123][456]; foo_2D(123, 456, &mein_array[0][0]); }Das ist die normale Vorgehensweise.
Es gibt in C99 auch noch die berüchtigten VLAs, das ist eine Möglichkeit, Arrays mit erst zur Laufzeit bekannter Länge zu definieren. Das wird von vielen Anfängern falsch benutzt, aber für 2D-Arrays als Funktionsparameter ist es genau das richtige:
void foo_2D(int size_x, int size_y, int array[size_x][size_y]); int main() { int mein_2D_array[123][456]; foo_2D(123, 456, mein_array); }Damit braucht man dann nicht mehr selber zu rechnen, sondern kann das Array ganz wie gewohnt benutzen.
-
0b0001ist kein Standard sondern nur eine CompilererweiterungSerial.println(feld[1][zweite_Zeile]);du verwechselst Zeilen mit Spalten
- wenn du mit wirklichen Arrays von Arrays arbeitest, hast du auch die Möglichkeit, den Compiler für dich Typprüfungen machen zu lassen; da musst du aber selbst explizit tätig werden:
void fkt(int x,int y,int a[3][4]) {printf("%d",a[0][0]);} int main() { int a[3][4]; fkt(3,4,a); /* OK */ ... } int main() { int a[1][4]; /* Typ ändert sich... */ fkt(3,4,a); /* ...Compiler gibt aber keine Warnung */ ... }deshalb setzt man hier Zeiger auf (Doppel)Arrays ein, und der Compiler warnt dann:
void fkt(int x,int y,int a[][3][4]) {printf("%d",(*a)[0][0]);} int main() { int a[1][4]; /* Typ ändert sich... */ fkt(3,4,&a); /* ...Compiler gibt Warnung aus */ ... }Du kannst davon ausgehen, dass in der Praxis solche Diskrepanzen nicht so übersichtlich dicht beieinander stehen wie hier im Beispiel sondern über viele Zeilen und Module verstreut, der Compiler hier also gute Dienste leisten kann, denn dem sind verstreut liegende Diskrepanzen egal.
-
Wenn man ein 2D-Array "am Stück" braucht, oder aus anderen Gründen mit "Array aus Arrays" hadert, kann man auch ein einfaches Array nehmen
int *array = malloc (breite*hoehe*sizeof(int));und dann so darauf zugreifen
int get (unsigned x, unsigned y) { return array[x%breite+y*breite]; }
-
Das mit dem Zeiger habe ich jetzt so einigermaßen verstanden. Ich habe mir noch mal
ein einfacheres Beispiel ausgedacht um mein Anliegen noch verständlicher zu machen.Ich verstehe nämlich leider das Beispiel von SeppJ nicht:
void foo_2D(int size_x, int (*array)[456]); int main() { int mein_2D_array[123][456]; foo_2D(123, mein_array); }Was bedeutet foo ? Wieso dieser Zeiger *array ?
void foo_2D(int size_x, int size_y, int *array) { int element_an_34_56 = *(array + 34*size_y + 56); // mein_array[34][56] } int main() { int mein_2D_array[123][456]; foo_2D(123, 456, &mein_array[0][0]); }In Zeile3 hast du mein_array[34][56] und in Zeile8 mein_2D-array[123][456].
Jetzt bin ich total verwirrt.
Kannst du mir bitte das Gezeigte noch mal mit meinem Beispiel erklären ?
Ist wirklich schwierig wenn zwei Menschen unterschiedliche Denkweisen haben.
Bitte nicht Böse sein./*2D-Arrays und Zeiger*/ /* INTERN werden mehrdimensionale Arrays(mit fest vorgegebenen Elementen */ /* und bekannter Größe) eindimensional angelegt. */ /* Wenn also z. B. ein Array deklariert ist mit int mein_ertses_Array[3][5] */ /* dann sind die Aufrufe: mein_Array[Zeile][Spalte] */ /* mein_Array[0][Zeile * Breite + Spalte] gleichwertig.*/ void main() { int mein_erstes_Array[3][5] = { /*Spalte 0*/ /*Spalte 1*/ /*Spalte 2*/ /*Spalte 3*/ /*Spalte 4*/ { 7, 11, 13, 17, 19, /*Zeile 0*/ }, { 23, 29, 59, 61, 67, /*Zeile 1*/ }, { 71, 73, 79, 83, 89, /*Zeile 2*/ } }; int mein_zweites_Array[3][7] = { /*Spalte 0*/ /*Spalte 1*/ /*Spalte 2*/ /*Spalte 3*/ /*Spalte 4*/ /*Spalte 5*/ /*Spalte 6*/ { 2, 4, 6, 8, 10, 12, 14 /*Zeile 0*/ }, { 12, 14, 16, 18, 110, 112, 114 /*Zeile 1*/ }, { 22, 24, 26, 28, 210, 212, 214 /*Zeile 2*/ } }; int gesamtanzahl_Elemente_a1 = sizeof(mein_erstes_Array) / sizeof(int); printf ("Gesamtanzahl der A1-Elemente: %d\n", gesamtanzahl_Elemente_a1); int *zeiger = &mein_erstes_Array[0][0]; /*Position des Zeigers auf das erstes Element des Array setzen. */ for(int i = 0 ; i < gesamtanzahl_Elemente_a1 ; i++) { printf ("Primzahlen aus mein_erstes_Array: %d\n", *zeiger ); zeiger++; } printf("\n\n"); int gesamtanzahl_Elemente_a2 = sizeof(mein_zweites_Array) / sizeof(int); printf ("Gesamtanzahl der A2-Elemente: %d\n", gesamtanzahl_Elemente_a2); int *zeiger2 = &mein_zweites_Array[0][0]; /*Position des Zeigers auf das erstes Element des Array setzen. */ for(int i = 0 ; i < gesamtanzahl_Elemente_a2 ; i++) { printf ("Zahlen aus mein_zweites_Array: %d\n", *zeiger2 ); zeiger2++; } }AUSGABE:
Gesamtanzahl der A1-Elemente: 15
Primzahlen aus mein_erstes_Array: 7
Primzahlen aus mein_erstes_Array: 11
Primzahlen aus mein_erstes_Array: 13
Primzahlen aus mein_erstes_Array: 17
Primzahlen aus mein_erstes_Array: 19
Primzahlen aus mein_erstes_Array: 23
Primzahlen aus mein_erstes_Array: 29
Primzahlen aus mein_erstes_Array: 59
Primzahlen aus mein_erstes_Array: 61
Primzahlen aus mein_erstes_Array: 67
Primzahlen aus mein_erstes_Array: 71
Primzahlen aus mein_erstes_Array: 73
Primzahlen aus mein_erstes_Array: 79
Primzahlen aus mein_erstes_Array: 83
Primzahlen aus mein_erstes_Array: 89Gesamtanzahl der A2-Elemente: 21
Zahlen aus mein_zweites_Array: 2
Zahlen aus mein_zweites_Array: 4
Zahlen aus mein_zweites_Array: 6
Zahlen aus mein_zweites_Array: 8
Zahlen aus mein_zweites_Array: 10
Zahlen aus mein_zweites_Array: 12
Zahlen aus mein_zweites_Array: 14
Zahlen aus mein_zweites_Array: 12
Zahlen aus mein_zweites_Array: 14
Zahlen aus mein_zweites_Array: 16
Zahlen aus mein_zweites_Array: 18
Zahlen aus mein_zweites_Array: 110
Zahlen aus mein_zweites_Array: 112
Zahlen aus mein_zweites_Array: 114
Zahlen aus mein_zweites_Array: 22
Zahlen aus mein_zweites_Array: 24
Zahlen aus mein_zweites_Array: 26
Zahlen aus mein_zweites_Array: 28
Zahlen aus mein_zweites_Array: 210
Zahlen aus mein_zweites_Array: 212
Zahlen aus mein_zweites_Array: 214Process returned 21 (0x15) execution time : 0.232 s
Press any key to continue.
-
Ardo-Uno schrieb:
Was bedeutet foo ?
Das ist ein Platzhaltername.
https://de.wikipedia.org/wiki/Fubar#Foo_im_IT-UmfeldWieso dieser Zeiger *array ?
Vorsicht: Du musst den ganzen Ausdruck betrachten. Da steht
int (*array)[456]. Das ist eine Variable namens Array vom Typ Zeiger auf Array[456] von int. Ich demonstriere hier, dass man ein Array von Arrays auf die gleiche Weise an eine Funktion übergeben kann, wie ein Array von irgendwas anderes. Wenn man ein z.B. Array von double hätte, könnte man dieses schließlich über einen Zeiger auf double an eine Funktion übergeben. Und bei Arrays von Arrays entsprechend über einen Zeiger auf ein Array.Wie schon erläutert, ist dieser Ansatz aber selten praktikabel, weil man die Größe des inneren Arrays (im Beispiel 456) im Voraus kennen muss, was meistens nicht der Fall ist.
In Zeile3 hast du mein_array[34][56] und in Zeile8 mein_2D-array[123][456].
Das letztere ist die Definition des Arrays, das erstere soll als Erläuterung dienen, was der Beispielcode macht. Er greift auf das 56. Element der 34. Zeile des Arrays von Arrays zu.
[...dein restlicher Beitrag...]
Hast du eine Frage dazu?
PS: Googel mal nach "Plenken"!
-
Sooo - Jetzt klappt es so wie ich es mir vorgestellt habe. Noch mal vielen Dank für die Tipps.
PS: Die Plenken-Sünden habe ich auch beseitigt
#include <stdio.h> #include <stdlib.h> int mein_erstes_Array[3][5] = { { 7, 11, 13, 17, 19, }, { 23, 29, 59, 61, 67, }, { 71, 73, 79, 83, 89, } }; int mein_zweites_Array[3][7] = { { 2, 4, 6, 8, 10, 12, 14 }, { 12, 14, 16, 18, 110, 112, 114 }, { 22, 24, 26, 28, 210, 212, 214 } }; int zeige_Grafik(int zeile, int spalte, int unbek_array[zeile][spalte]) { printf("\n\n"); //int gesamtanzahl_Elemente = sizeof(unbek_array) / sizeof(int); int gesamtanzahl_Elemente = zeile * spalte; printf ("Gesamtanzahl der Elemente: %d\n", gesamtanzahl_Elemente); int *zeiger = &unbek_array[0][0]; /*Position des Zeigers auf das erstes Element des Array setzen. */ for(int i = 0 ; i < gesamtanzahl_Elemente ; i++) { printf ("Zahlen aus dem Array: %d\n", *zeiger ); zeiger++; } } int zeige_Grafik2(int zeile, int spalte, int unbek_array[zeile][spalte]) { printf("\n\n"); int gesamtanzahl_Elemente = zeile * spalte; int zeilenzaehler0 = 0; int zeilenzaehler1 = 0; int zeilenzaehler2 = 0; for(int i = 0 ; i < gesamtanzahl_Elemente / 3 ; i++) { printf("\n\n"); printf("Zahlen aus dem Array: %d\n", unbek_array[0][zeilenzaehler0]); printf("Zahlen aus dem Array: %d\n", unbek_array[1][zeilenzaehler1]); printf("Zahlen aus dem Array: %d\n", unbek_array[2][zeilenzaehler2]); zeilenzaehler0++; zeilenzaehler1++; zeilenzaehler2++; } } void main() { zeige_Grafik(3,7,mein_zweites_Array); printf("\n\n"); zeige_Grafik2(3,5,mein_erstes_Array); }AUSGABE am Terminal:
Gesamtanzahl der Elemente: 21
Zahlen aus dem Array: 2
Zahlen aus dem Array: 4
Zahlen aus dem Array: 6
Zahlen aus dem Array: 8
Zahlen aus dem Array: 10
Zahlen aus dem Array: 12
Zahlen aus dem Array: 14
Zahlen aus dem Array: 12
Zahlen aus dem Array: 14
Zahlen aus dem Array: 16
Zahlen aus dem Array: 18
Zahlen aus dem Array: 110
Zahlen aus dem Array: 112
Zahlen aus dem Array: 114
Zahlen aus dem Array: 22
Zahlen aus dem Array: 24
Zahlen aus dem Array: 26
Zahlen aus dem Array: 28
Zahlen aus dem Array: 210
Zahlen aus dem Array: 212
Zahlen aus dem Array: 214Zahlen aus dem Array: 7
Zahlen aus dem Array: 23
Zahlen aus dem Array: 71Zahlen aus dem Array: 11
Zahlen aus dem Array: 29
Zahlen aus dem Array: 73Zahlen aus dem Array: 13
Zahlen aus dem Array: 59
Zahlen aus dem Array: 79Zahlen aus dem Array: 17
Zahlen aus dem Array: 61
Zahlen aus dem Array: 83Zahlen aus dem Array: 19
Zahlen aus dem Array: 67
Zahlen aus dem Array: 89
-
Uuups, jetzt sind mir die Arrays doch verutscht, obwohl ich die Leerzeichen entfernt hatte
-
Eine Frage hätte ich dann doch noch: Bei
funktion_2d(3,5,&mein_Array[0][0]);Übergibst du der Funktion funktion_2d die Anfangsadresse des Arrays als Parameter.
In der Funktionsdeklaration gibst du aber nicht an wohin der Zeiger zeigen soll sondern erst später bei der Parameterübergabe.Ich habe außerdem ausprobiert ob es auch OHNE &-Zeichen geht. Und siehe da es liefert ebenfalls das richtige Ergebnis 61.
funktion_2d(3,5,mein_Array);Wie ist das Möglich ? Der Zeiger zeigt ja dann IRGENDWO hin, was man ja nicht machen soll.
Hier noch mal SeppJ Vorschlag:#include <stdio.h> #include <stdlib.h> int mein_Array[3][5] = { { 7, 11, 13, 17, 19, }, { 23, 29, 59, 61, 67, }, { 71, 73, 79, 83, 89, } }; void funktion_2d(int zeile, int spalte, int *unbek_array) { int element_an_1_3 = *(unbek_array + 1 * spalte + 3); printf("\n\n"); printf("element in Zeile-1 und Spalte-3: %d\n", element_an_1_3); // gibt die Zahl 61 aus. } void main() { funktion_2d(3,5,&mein_Array[0][0]); }
-
&mein_Array[0][0] liefert eine Adresse von einem
int. Hier vom ersten Element vom ArraymeinArray liefert eine Adresse von einem
int[3][5]. Das ist die Anfangsadresse von dem Array.Beide Adressen sind hier identisch, jedoch nicht die Typen. Dies wird jedoch beim Funktionsaufruf verdeckt, so dass die Funktion weiterhin funktioniert.
-
Habe ich richtig verstanden ?
Dieser Ausdruck liefert den Anfang des Arrays&mein_Array[0][0]);Und dieser Ausdruck liefert mir ebenfalls den Anfang des Arrays.
Der Name eines Arrays OHNE Indexangaben und OHNE Adressoperator
gibt immer die Startadresse des Arrays zurück?mein_Array
-
Ardo-Uno schrieb:
Habe ich richtig verstanden ?
Dieser Ausdruck liefert den Anfang des Arrays&mein_Array[0][0]);Und dieser Ausdruck liefert mir ebenfalls den Anfang des Arrays.
Der Name eines Arrays OHNE Indexangaben und OHNE Adressoperator
gibt immer die Startadresse des Arrays zurück?mein_ArrayZu deiner Verwirrung: Es geht sogar sowas:
&mein_ArrayAber frag mich nicht warum.
Adresse von Adresse?
Ist wohl ein Bug in der C-Grammar-Definition, der nie jemanden gestört hat.
-
Klappe halten wenn man keine Ahnung hat heißt es da.
Die C-Altvorderen eines Bugs zu verdächtigen kann nur einem Dorftrottel ohne Ahnung aber mit übersteigertem Mitteilungsbedürfnis passieren.
-
Fricky667 schrieb:
Zu deiner Verwirrung: Es geht sogar sowas:
&mein_ArrayAber frag mich nicht warum.
Adresse von Adresse?
Ist wohl ein Bug in der C-Grammar-Definition, der nie jemanden gestört hat.&mein_Arrayist ein Zeiger, der auf das Array zeigt:int mein_array[5];&mein_arrayist einint(*mein_array)[4]. Ein Zeiger auf das Array als Ganzes.mein_arrayzerfällt in Ausdrücken zu einem Zeiger auf das erste Element des Array:int*.&mein_array[0]ergibt explizit einen Zeiger auf das erste Element.
Edit: Mist, der C-Guru hat bereits zugeschlagen.
-
Wutz schrieb:
Klappe halten wenn man keine Ahnung hat heißt es da.
Die C-Altvorderen eines Bugs zu verdächtigen kann nur einem Dorftrottel ohne Ahnung aber mit übersteigertem Mitteilungsbedürfnis passieren.Ach, mein lieber Proll-Troll ist wieder da.
Willst du, dass gleich der nächste Thread wegen deiner Scheiße zugemacht wird?
-
Techel schrieb:
&mein_array ist ein int(mein_array)[4]
mein_array zerfällt in Ausdrücken zu einem Zeiger auf das erste Element des Array: int.Gibt es denn eine Situation in der man '&mein_array' nehmen muss und nicht einfach 'mein_array' hinschreiben kann?
-
Ah, folgendes ...
void test (int(*array)[4]){} int main() { int array[4]; test (&array); // geht test (array); // fehler }Alles klar. Thx Techel!
