Mehrdimensionales Array als Funktion zurückgeben

[Mathias K. (underworldgamer)]

Hallo Leute ich habe da ein kleines Problem mit mehrdimensionalen Array 
und Rückgabe durch eine Funktion.

Vielleicht könnt ihr mir weiterhelfen.

anbei der Code

mfg Mathias

#include <stdio.h>

int *caffeine(int *array1,int *array2,int size);

void main()
{
    int joe[2][2] = { {9, 8},{3,3}};
    int java[2][2] = { {9, 8},{3,3}};
    int *coffee;

    coffee = caffeine(joe,java,2);

      
}


int *caffeine(int *array1,int *array2,int size)
{
    int static total[2][2];
    int x;

    for(x=0;x<2;x++)
            total[x][x]=array1[x][x]+array2[x][x];

    return(total);
}

mit der Fehlermeldung

subscripted value is neither array nor pointer|

[Karl H. (kbuchegg)]

Mathias K. schrieb:

beantworte mal ganz schnell die Frage:
Wie soll der Compiler ausrechnen, der weivielte int, vom Beginn des 
Arrays aus gerechnet, denn array1[x][x] sein soll, wenn alles was er hat 
die Startadresse des Arrays ist.

Auch ein 2D Array muss im Speicher abgebildet werden, indem die Elemente 
alle hintereinander liegen

   2D Array (konzeptionell)  3 Spalten, 2 Zeilen

     0   1   2
   +---+---+---+
0  | a | b | c |
   +---+---+---+
1  | d | e | f |
   +---+---+---+


  dasselbe Array im Speicher

  +---+---+---+---+---+---+
  | a | b | c | d | e | f |
  +---+---+---+---+---+---+


um zu berechnen, dass das Element in Zeile 1, Spalte 0 (also 'd') das 4. 
Element ab Beginn des Arrays ist, muss der Compiler die Anzahl Spalten 
pro Zeile kennen (in diesem Fall sind es 3 Spalten).

  Adresse des Elements = Startadresse +
                         gewünschte_Zeile * Anzahl_Spalten +
                         gewünschte_Spalte

Die Anzahl der Spalten muss bekannt sein, sonst kann man die Position 
nicht ausrechnen.

Du gibst ihm aber nur einen Pointer. Das reicht für den 1D Fall, aber 
nicht für 2D. Auch ein Compiler kann nicht zaubern.

... caffeine(int array1[2][2], int array2[2][2])
{
  ...
}

und für den Returnwert musst du dir sowieso was anderes ausdenken. 
Arrays kann man nicht als Ganzes zuweisen und daher kann man sie auch 
nicht als ganzes aus einer Funktion heraus als Returnwert übergeben. 
Denn dazu müsste ein Array zuweisbar sein

     coffee = func( ... )

was sie aber nicht sind.

[Yalman (Gast)]

Hallo,

du musst mit einem Zeiger auf Zeiger auf int als "formaler Parameter" 
(der Parameter in deiner Caffein-Funktion) arbeiten.

caffeine(int **zgrzgr1, int **zgrzgr2, int size) { }

durch das erste dereferenzieren *(zgrzgr+i) erhaelst du die Zeile i,und 
durch das zweite dereferenzieren *(*(zgrzgr+i)+j) erhälst du die
Spalte j mit dem int Wert A(i,j)=X.

Gruß

[Yalu X. (yalu) (Moderator)]

Yalman schrieb:
> du musst mit einem Zeiger auf Zeiger auf int als "formaler Parameter"
> (der Parameter in deiner Caffein-Funktion) arbeiten.
>
> caffeine(int **zgrzgr1, int **zgrzgr2, int size) { }

Das ist aber wieder etwas anderes: Jetzt erwartet die Funktion einen
Zeiger auf einen Zeiger bzw. ein Array von Zeigern. Der Aufruf

    coffee = caffeine(joe,java,2);

liefert aber weder das eine noch das andere.

Richtig ist der Vorschlag von Karl Heinz:

... caffeine(int array1[2][2], int array2[2][2])

Der Typ des Rückgabewerts und der Variable coffee muss natürlich auch
noch korrigiert werden. Da C-Funktionen keine Arrays zurückgeben können,
nimmt man stattdessen einen Zeiger auf eine Zeile des zweidimensionalen
Arrays, der den Typ (*)[2] hat und wie ein zweidimensionales Array
benutzt werden kann. Hier ist das komplette Programm:

#include <stdio.h>

int (*caffeine(int array1[2][2], int array2[2][2]))[2];

int main()
{
    int joe[2][2]  = {{9, 8}, {3,3}};
    int java[2][2] = {{9, 8}, {3,3}};
    int (*coffee)[2];

    coffee = caffeine(joe, java);
    printf("%2d %2d\n%2d %2d\n",
            coffee[0][0], coffee[0][1], coffee[1][0], coffee[1][1]);

    return 0;
}

int (*caffeine(int array1[2][2], int array2[2][2]))[2]
{
    int static total[2][2];
    int x;

    for(x=0; x<2; x++)
        total[x][x]=array1[x][x]+array2[x][x];

    return total;
}

[DirkB (Gast)]

In diesem Fall (kleines Array) kann man das Array auch in einer struct 
verstecken.

Denn structs kann man direkt zuweisen und auch als Rückgabeparameter 
benutzen.