mehrdimensionale Arrays als Parameter

[laparmakerli]

Hallo,
Ich habe ein kleines Verständnisproblem zur Übergabe von mehrdimensionalen Arrays als Parameter.

Code: Alles auswählen

#include <iostream>
using namespace std;

int test(int arr[4][3]){
	cout << sizeof(arr) << endl;
	cout << sizeof(arr[0]) << endl;
	return 0;
}

int main(){
	int arr[4][3] = {{1,2,3},{4,5,6},{7,8,9},{10,11,12}};
	test(arr);
	return 0;
}

Ausgabe:
8
12

Also, ich übergebe der Funktion <test(int arr[4][3])> ein zweidimensionales array, wobei ich explizit angebe wie viele "zeilen" und "spalten" das array haben soll. Ich weiß, dass eigentlich nur die 2. (und alle weiteren) Dimensionen angegeben werden müssen. Allerdings scheint es so als würde der Compiler die Angabe der ersten Dimension ignorieren, da "sizeof(arr)" 8-byte (also die größe eines zeigers bei 64 bit rechnern) und nicht die größe des arrays liefert. Er verhält sich also genauso, als hätte ich "int arr[][3]" als Parameter angegeben. Für sizeof(arr[0]) wird jedoch wie erwartet die grüße einer gesamten zeile (also 3 * 4 byte) ausgegeben. Hab ich da was falsch verstanden? oder wenn nicht, wieso ignoriert der Compiler die angabe?
lg Lars

[bowie_22]

Hallo laparmakerli,

ich habe mir Deinen Code mal angeschaut.
Was Du da machst ist aus meiner Sicht Folgendes:

Mit dem Aufruf test(arr) übergibst du mit Nichten eine Array der Größe 4x3 an Test, sondern einen Zeiger auf das erste Elemente von arr (in C ist der Name eines Arrays gleichzeitig ein Pointer auf sein erstes Element).

In der Signatur von test hast Du mit int arr[4][3] einen Parameter vom Typ Pointer auf Integer erzeugt.
Ich vermute, dass die Zahlen in den Klammern vom Compiler einfach ignoriert werden.

Hier spielt wieder eine Analogie eine Rolle, nämlich in der Signatur einer Funktion sind folgende Ausdrücke gleichbedeutend:

typ name[] und typ *name --> Beide stellen einen Pointer auf int dar.
In meiner Quelle ist typ name[] vorzuziehen, wenn man explizit klar machen will, dass man mit einem array arbeitet.

D.h. also Du übergibst an die Funktion test einen Pointer auf das erste Element von arr.

Deshalb bekommst Du mit dem sizeof(arr) die 8Byte für ein Pointer auf einem 64Bit System.
sizeof(arr[0]) ist 12 weil in arr[0] wiederum ein Array mit 3 Integerwerten zu je 4 Byte stehen: 3*4=12 Byte

Wenn Du in test mit arr arbeiten willst kannst Du das über den Pointer machen.
Die Übergabe von arrays erfolgt in C nicht über "call by value", sondern über "call by reference", also eben über einen Zeiger.

Gruß

Marcus

[Xin]

Hallo,
Ich habe ein kleines Verständnisproblem zur Übergabe von mehrdimensionalen Arrays als Parameter.

Ich vermute, dass hier kaum Feedback kommt, ist da C hier keine wirklich schöne Syntax zu bieten hat...

Also, ich übergebe der Funktion <test(int arr[4][3])> ein zweidimensionales array, wobei ich explizit angebe wie viele "zeilen" und "spalten" das array haben soll. Ich weiß, dass eigentlich nur die 2. (und alle weiteren) Dimensionen angegeben werden müssen. Allerdings scheint es so als würde der Compiler die Angabe der ersten Dimension ignorieren, da "sizeof(arr)" 8-byte (also die größe eines zeigers bei 64 bit rechnern) und nicht die größe des arrays liefert.

Er wird da vermutlich auch einen Zeiger übergeben und nicht das Array, denn etwas, was mit [] zugegriffen werden kann, muss ein Array sein. Arrays, also char[] gibt es in C aber gar nicht, sondern es gibt immer nur den Zeiger auf das erste Element.

Er verhält sich also genauso, als hätte ich "int arr[][3]" als Parameter angegeben. Für sizeof(arr[0]) wird jedoch wie erwartet die grüße einer gesamten zeile (also 3 * 4 byte) ausgegeben. Hab ich da was falsch verstanden? oder wenn nicht, wieso ignoriert der Compiler die angabe?

Mit einer klaren Erklärung tue ich mich hier auch schwer und kann eben nur auf das zuvor beschriebene verweisen. Entweder verlangt der Standard es so oder es ist tatsächlich ein Fehler. Ich stimme mit Dir überein, dass ich die gleiche Erwartungshaltung wie Du hätte, nämlich 4*3*sizeof(int) => 48. Dieses Konzept würde allerdings bedeuten, dass C/C++ ein statisches Konzept Array haben müsste, dass die Verschachtlung von Arrays ausdrücken könnte.

Die Verwendung von mehrdimensionalen Arrays in C/C++ sehe ich sehr selten. In meinem Fall auch der Tatsache geschuldet, dass die Typinformationen nicht sauber über Funktionsaufrufe zu leiten sind.
Üblicher ist es, diese Dinge in Strukturen zu packen:

Code: Alles auswählen

struct DataRow
{
  int _data[3];
};

struct DataBlock
{
  struct DataRow _data[4];
};

Der Zugriff ist aufwendiger, bzw. in C++ musst Du halt operator [] definieren.
Dafür wird die Sache weniger fraglich.

[Orioner]

Ohne jetzt alles innerhalb dieses Threads komplett gelesen zu haben, möchte ich euch mitteilen, was ich darüber denke: Ich meine mich daran zu erinnern, einmal gelesen zu haben, dass es weder in C noch in C++ möglich ist, mehrdimensionale Arrays als Parameter an Funktionen zu übergeben. (Korrigiert mich, wenn ich mich irre!)

Verwende stattdessen lieber Zeiger! Ich bin mir gerade nicht sicher, aber ich glaube, es ist auch möglich, nur eine Dimension mit Zeigern anzusprechen und die andere wie gehabt.

Eine recht brauchbare Einführung in die Thematik "Zeiger" findest du hier. Solltest du damit auf keinen grünen Zweig kommen oder noch weitere Fragen haben, melde dich noch einmal, dann versuche ich dich selbst ein wenig zu briefen. Ich müsste mir das Thema aber auch selber erst wieder angucken (da ich so vieles nicht mehr im Kopf habe).

[sebix]

Am besten entweder in Zeigerarithmetik einarbeiten, mit Structs/Klassen arbeiten oder die STL verwenden.

Mit der STL kannst du dir auch viel Arbeit ersparen in C++:

Code: Alles auswählen

#include <iostream>
#include <vector>
 
void f (std::vector<std::vector<int> > matrix, int a, int b) {
    std::cout << matrix[a][b] << std::endl;
}
 
void f2 (std::vector<std::vector<int> > *matrix, int a, int b) {
    std::cout << (*matrix)[a][b] << std::endl;
}
 
int main() {
        std::vector<std::vector<int> > matrix(100, std::vector<int>(100, 0));
    
    matrix[3][34] = 35;
    f(matrix, 3, 34);
    matrix[3][34] = 34;
    f2(&matrix, 3, 34);
        return 0;
}

Hier mit Syntax-Highlighting

Vectoren sind btw Arrays dynamischer Größe. http://www.cplusplus.com/vector