Doppelpointer (int **) in Funktionen

[FritziFoppel]

Tach, da bin ich mal wieder.

Ich hab ein Problem mit der Funktionsweise von Doppelpointern in Funktionen.
Folgendes Beispiel:

Code: Alles auswählen

int array [][2] = {};

void function(int  ** arrayFunction)
{
     for(int i = 0; i < 5; i++)
     {
          //mach irgendwas mit arrayFunction[i][0];
          //mach irgendwas mit arrayFunction[i][1];
     }
}

Nun weiß ich nicht wirklich, wie ich das Array in main() der Funktion übergeben kann.
Hätte jemand da einen Anreiz für mich? Ich bin mir nicht ganz sicher, aber ich steh glaub total auf dem Schlauch.
Hätte sonst auch keinen Beitrag geschrieben, wenn ich nicht weiter kommen würde.

Danke für die Mühe

[cloidnerux]

Deine Funktion ist vom Typ

Code: Alles auswählen

 int **

Daher brauchst du entweder ein zweidimensionales Array:

Code: Alles auswählen

int array[a][b];
function(array)

oder eben nen Pointer auf nen Pointer:

Code: Alles auswählen

int * p;
function(&p);     //Das Funktioniert, ist aber nicht sinnvoll/gefährlich

Was deine Funktion ja nur haben will, ist ein Pointer auf einen Pointer. Was gemeint ist, dass du einen Pointer auf ein Set aus Pointer gibst, also ein Array an Pointern, die dann jeweils auf ein Wert verweisen, bzw ein Array aus werten. Hier bei muss man größte Sorgfalt walten lassen, dass man ja die Array-grenzen einhält!

[FritziFoppel]

Ich glaube, da hab ich mich falsch ausgedrückt, bzw. falsch angefangen. Sorry!
Ich weiß worauf du hinaus willst, aber ich denke, der Punkt ist bei mir klar. Es geht mehr um die Funktion in main(), also der Übergabe.

Mein Ausgangspunkt ist das Array int array [][2] = {};.
In main() versuche ich dann mit den Werten, in diesem Fall, von array[0] und array[1] etwas anzufangen, bzw- Werte diesen Zuzuweisen.
Ich hab schon versucht mit den verschiedenen Adressoperatoren zu hantieren, leider erfolglos.

Für eine Funktion void func(int * a), übergebe ich in main(), die Variable mit func(&a).
Meine Frage ist, was ich dann der Funktion übergebe, wenn ich int **a habe?

[cloidnerux]

Für eine Funktion void func(int * a), übergebe ich in main(), die Variable mit func(&a).
Meine Frage ist, was ich dann der Funktion übergebe, wenn ich int **a habe?

Das habe ich dir egt schon so beantwortet.
Betrachte bitte nur die Datentypen:

Code: Alles auswählen

int a;
int * p = &a,
int **pp = &p;

Die Beiden Sternchen bedeuten: Pointer auf einen Pointer, damit ist

Code: Alles auswählen

*(pp)

vom Typ

Code: Alles auswählen

int*

Deine Funktion will einen Pointer auf einen Pointer haben.
Entweder du hast ein zweidimensionales Array

Code: Alles auswählen

int array[][];

wobei array ohne einen Indexoperator vom Typ

Code: Alles auswählen

int**

ist.
Oder du legst dir einen Pointer auf einen Pointer an:

Code: Alles auswählen

int **pp = (int**)malloc(SOME_BYTES * sizeof(int**));

Mein Ausgangspunkt ist das Array int array [][2] = {};.

Was ist denn

Code: Alles auswählen

int array[][2] = {};

für eine Initialisierung?

[FritziFoppel]

Mein Ausgangspunkt ist das Array int array [][2] = {};.

Was ist denn

Code: Alles auswählen

int array[][2] = {};

für eine Initialisierung?

Eine Initialisierung die scheinbar von MinGW akzeptiert wird.

Hab mich heute noch mal rangesetzt und gegrübelt. Weiß jetzt was ich machen muss.
Das Problem lag wahrscheinlich wie du schon gesagt hast an der Initialisierung. Die Variable liegt im Header, aber der Compiler nimmt das so an.

Danke

[cloidnerux]

Hab mich heute noch mal rangesetzt und gegrübelt. Weiß jetzt was ich machen muss.
Das Problem lag wahrscheinlich wie du schon gesagt hast an der Initialisierung. Die Variable liegt im Header, aber der Compiler nimmt das so an.

Auch wenn er es annimmt, ist es logisch einfach nur grausam.
C/C++ bietet dir zwar die Möglichkeit, die Größe des Arrays implizit durch die Angabe der Arrayelemente an zu geben, sowas hier:

Code: Alles auswählen

int array[] = {1, 2, 3, 4, 5};

Wenn du aber keine Elemente angibst, müsste es Faktisch ein Array mit der Dimension 0 sein:

Code: Alles auswählen

int array[] = {} == array[0];

Ein Array mit 0 Elementen ist also anscheinend möglich, aber nicht sinnvoll.
Was willst du mit einem Array, das keins ist?

[Xin]

Eine Initialisierung die scheinbar von MinGW akzeptiert wird.

1.) scheinbar!?
2.) Nicht alles, was kompiliert ist sinnvoll.

Du solltest Deinen Quelltext schon verstehen. Selbst wenn er funktioniert ist er solange als falsch zu betrachten, bis Du verstanden hast, warum er zufälligerweise funktioniert und ausschließen kannst, dass er unter anderen als den getesteten Bedingungen auch richtig funktioniert.

Hab mich heute noch mal rangesetzt und gegrübelt. Weiß jetzt was ich machen muss.
Das Problem lag wahrscheinlich wie du schon gesagt hast an der Initialisierung. Die Variable liegt im Header, aber der Compiler nimmt das so an.

Vielleicht postest Du mal die Funktion, die den (int **) übergeben bekommt, damit man nachvollziehen kann, was Du eigentlich vorhast.

Ein Array vergrößert sich nicht und &pointerToInt ist nur dann sinnvoll, wenn Du den Parameter als (int *)-Out-Referenz verwendest.
Da Du offenbar auf die Elemente einzeln zugreifen willst, musst Du ein echtes Array mit int * aufbauen:

Code: Alles auswählen

int row1[] = { 11, 12, 13 };
int row2[] = { 21, 22, 23 };
int row3[] = { 31, 32, 33 };

int * matrix[] = { row1, row2, row3 };

function( matrix );

Du sollstest allerdings auch die Ausmaße des Arrays im Auge behalten.

Code: Alles auswählen

function( matrix, 3 /* rows */, 3 /* elements per row */ );

[cloidnerux]

Ich habe gerade diesen Thread auf SO gefunden: http://stackoverflow.com/questions/1963 ... -to-double
und muss daher nochmal kurz ein paar Dinge klar stellen, die ich nicht ganz richtig Präsentiert hatte:
"int **pp" kann ein zweidimensionales Array sein, muss es aber nicht. Eine Initialisierung der Form

Code: Alles auswählen

int array2d[4][4];

Wird 4 * 4 * sizeof(int) Bytes an kontinuierlichen Speicher reservieren. pp Kann darauf zeigen, du kannst aber mit dem Doppelpointer auch ein "jagged"-Array realisieren, ein Array dessen Elemente nicht kontinuierlich sind:

Code: Alles auswählen

int **pp = (int**)malloc(sizeof(int*) * n);
for(int i = 0; i < n; ++)
{
    pp[i] = (int*)malloc(sizeof(int) * m);
}

Wird ein n x m Array initialisieren, bei dem die einzelnen 1D-Arrays nicht zusammenhängend sind.

[FritziFoppel]

Vielleicht postest Du mal die Funktion, die den (int **) übergeben bekommt, damit man nachvollziehen kann, was Du eigentlich vorhast.

Ich programmiere gerade mit SDL ein kleines Spiel: Ein Ball wird mit Pfeilen ins Ziel gelenkt.
Meine Überlegung war, dass ich bei einem Mausklick einen Pfeil, aus einer Leiste am rechten Bildrand, auswählen kann und diesen dann irgendwo auf dem Bildschirm platzieren kann. Da mehrere Pfeile vorhanden sind, hab ich eine Funktion geschrieben, die beim platzieren, den Namen des Pfeiles und die Position speichert. Also die x und y Koordinate. Dafür das Array [][2], was, wie ich jetzt ja gemerkt habe, falsch initiiert ist.
Falls der Ball über den Pfeil rollt, soll der Pfeil ja neu gedruckt werden, deshalb schien es mir am besten, ein zweidimensionales Array zu benutzen.

Im Nachhinein habe ich jetzt aber die x un y Koordinaten, nacheinander in einem normalen Array gespeichert und es funktioniert.

[cloidnerux]

Im Nachhinein habe ich jetzt aber die x un y Koordinaten, nacheinander in einem normalen Array gespeichert und es funktioniert.

Hier würde eine Kapselung helfen:

Code: Alles auswählen

struct cords
{
    float x;
    float y;
};
[...]
struct cords[4];

Weil du ja, rein aus dem Verständnis der Sache, ein Array an Koordinaten haben willst.
Das kannst du natürlich auch mit einem 2D-Array machen, aber da ist die Eindeutigkeit nicht so stark

Code: Alles auswählen

float cords[10][2];

Du solltest aber überlegen, für ein dynamisches System wie ein Spiel, eine dynamische Datenstruktur zu verwenden und kein Array.