3. zweidimensionales Array einer Funktion übergeben

zweidimensionales Array einer Funktion übergeben

  • G

    hi,
    jo wie mach ich das?
    Bei eindimensionales Array:

    char array[20];

void function(char _array[])
{
  // mach was mit _array[]
}

// Übergabe
function(array);

    Deshalb würde ich es bei zweidimensionalen Arrays folgendes machen:

    char array[20][20];

void function(char _array[][])
{
  // mach was mit _array[][]
}

// Übergabe
function(array);

    doch erhalte ich dann den Compilerfehler:

    declaration of `array' as multidimensional array must have bounds

    damit kann ich leider nichts anfangen 😞

    please help!

    Tschau Gartenzwerg

    0
  • T
     

    void foo(TYP **array, size_t dim1, size_t dim2);
    0
  • ?

    Oder als Kurzversion:

    funktion (*arr[], size_t dim1, size_t dim2);
    0
  • H

    Taurin schrieb:

    void foo(TYP **array, size_t dim1, size_t dim2);

    Das ist nicht richtig.
    Ein Array "verwest" 😉 (von engl. decay) wenn nötig in den Typ "Zeiger auf Elementtyp". Für ein eindimensionales int Array z.B. heißt das "Pointer auf int" = int*. Die Elemente eines zweidimensionalen Arrays sind aber keine primitven Typen sondern sondern *Arrays* von solchen.
    "Zeiger auf Elementtyp" ist also gleich "Zeiger auf Array".
    Hat man also ein zweidimensionales int-Array ergibt sich:
    int (*)[seconDim].

    0
  • T

    .... und wieder was dazu gelernt 🙂

    0
  • G

    hi,
    bin ich dumm oder wie?

    ich habe jetzt:

    char array[20][20];

void function(char *arr[], int dim1, int dim2)
{
  // mach was mit arr
}

// Übergabe
function(array,20,20);

    und erhalte den Fehler:

    no matching function for call to `function(char[20][20],int,int)'
candidates are: void function(char**,int,int)

    😞
    Was mach ich falsch?

    Tschau Gartenzwerg

    0
  • C

    Hi,
    könnte man das Array nicht in eine struct "verpaken" ?

    struct DA {
char array[10][10]
};

void myfunc(DA param)
{
//Tu was mit param.array
}
    0
  • G

    hi,
    ich würde es aber nicht so gerne in einer Struktur "verpacken".
    Ich fände es besser, wenn es ein zweidimensionales Array ohne Zusätze bleibt.

    0
  • T

    So hab jetzt mein Schulskriptum rausgekramt. KEIN Anspruch auf Vollständigkeit. Hat ja ein Lehrer geschrieben *g*

    Es gibt 3 Arten:

    1. Feld Parameter über Feldklammern Angabe:

    int sum(int [],int);
int main()
{  int feld[]={5,10,15,20};
   int size;
   size= sizeof(feld)/sizeof(int); //Bestimmung der Anzahl der Feldelemente
   cout<<"sum(feld,size);
}

int sum(int a[],int s)
{  int sum=0,i;
   for (i=0;iys;i++)
    sum+=a[i];
   return sum;
}

    2. Feld Parameter über Feldtyp Angabe:

    #define MAX 5
typedef int TypFeld[MAX];

void init(TypeFeld, int);
int main()
{  TypFeld feld1;
   init feld1,5);
}

void init(TypFeld a, int s)
{  int i;
   for (i=0;i<MAX;i++)
    a[i]=s;
}

    3. Feld Parameter über Zeigerparameter

    void init(float *, float, int);
int main()
{  float feld2[10], value;
   cin>>value;
   init(feld2,value,10);
}

void init(float *a, float s, int n)
{  int i;
   for(i=0;i<n;i++)
    a[i]=s;
}

    zu 1.
    Wenn ein Feld ab einer Funktion übergeben wird, so entspricht der Wert des Feldnamens feld in Wirklichkeit der Speicheradresse des ersten Feldes (&feld[0])!
    Die Übergabe eines Feldes gleicht daher der Übergabe einer Variable als Verweis, obwohl die Feld Variable als Wert übergeben wird.
    Die Feldelemente können daher durch die Funktion verändert werden!!
    Beachte, dass die Größe eines übergebenen Feldes der Funktion bekanntgegeben werden muss, denn in C++ kann die Funktion selbst nich die Größe des übergebenen Feldes nicht erkennen!

    sizeof(x) bestimmt die Anzahl der Bytes von x.
    d.h. sizeof(feld) gibt die Anzahl der Elemente mal bytes(Typ) an !
    hier: 4*4=16 Bytes bzw. 4*2=8 Bytes (Rechnerabhängig)

    zu 2.
    Mit der typedef - Anweisung wird für eine Variable ein eigener Typ definiert. Es wird dabei ein neuer Name für einen bestehenden Typ (hier int Feld[]) vereinbart.
    Beachte, dass die Anzahl der Elemente eines Feldes nicht Bestandteil seines Typs sind.

    zu 3.
    Der *-Operator bezeichnet einen sogenannten Zeiger auf eine Variable. Ein Zeiger ist eine Adresse der Variablen, d.h. es wird nicht der Inhalt, sondern der Speicherplatz der Variablen bestimmt ( *float a ist ein Zeiger der float-Variablen a ).

    Der Funktionsaufruf ist in allen Fällen gleich!

    So ich hoffe ich hab keinen allzugroßen Mist abgeschrieben 😉

    0
  • G

    hi,
    @T0mmy: Danke für die Mühe, die du dir gemacht hast, aber außer der zweiten Variante kannte ich das schon. Mein Problem liegt darin, dass ich nicht weiß, wie ich ein zweidimensionales Array einer Funktion übergeben soll. Ich habe die Vorschläge deiner Vorredner angenommen und bekomme das weiter oben beschriebene Ergebnis. Entweder mache ich etwas falsch oder es liegt ein Verständigungsproblem vor. Hope for help!

    Tschau Gartenzwerg

    0
  • ?

    Die zweite Dimension muss festgelegt sein. Hast du aber nicht gemacht.

    0
  • G

    😕
    wie meinst du das? hast du mal ein Bsp.?

    Tschau Gartenzwerg

    0
  • E

    Er meint:

    char array[20][20]; 

void function(char *arr[20], int dim1, int dim2) 
{ 
  // mach was mit arr 
} 

// Übergabe 
function(array,20,20);

    Das liegt an der Art wie der das uebergiebt, wenn ich das richtig verstanden habe.

    0
  • J

    Und wie ist es mit 2D Arrays als Klassenmember?

    class GoL
{
    bool* cells[];
    const int columns;
public:
    GoL();
    ~GoL();
    GoL(int cols);

    int getColumnCount()    {return columns;}
    // ...
};

GoL::GoL()
: columns(3)
{
    cells = new bool[][columns];
}

// ...

    Wo ist da der Fehler?

    0
  • H

    Wo ist da der Fehler?

    Das:

    bool* cells[];

    Ist ein Array von Zeigern auf bool. Gleichzeitig aber auch ein Fehler, da die Arraygrenzen fehlen.

    new bool[][columns];

    Das liefert einen Zeiger auf ein Array von bools. Du hast also "Array von Zeigern auf bool" auf der linken und "Zeiger auf Array von bool" auf der rechten Seite. Dazwischen gibt es dummerweise keine Konvertierung.
    Desweiteren fehlt auch hier noch eine Arraygrenze.

    0
  • G

    hi,

    @ Entyl_Sa: so funktioniert es leider auch nicht.

    Aber darauf aufbauend habe ich es jetzt so gemacht:

    char array[20][20]; 

void function(char arr[20][20], int dim1, int dim2) 
{ 
  // mach was mit arr 
} 

// Übergabe 
function(array,20,20);

    so wirklich gefallen, tut es mir nicht, da das Array jetzt auf die 20*20 char's beschränkt ist.

    Aber es funktioniert erstmal. Im nächsten Projekt werde ich garantiert auf vector umsteigen und dann die Zweidimensionalität mit einer Funktion wie "y*GEWÜNSCHTER_DIMENSIONSGRÖSSE_1+x" oder so machen.

    Danke für die Hilfe!

    Tschau Gartenzwerg

    0
  • J

    Dann sag mir bitte wie du das lösen würdest. Ich hab schon rumprobiert, aber ich komme auf nichts.

    0
  • T

    So hab jetzt was geschrieben. Damit kannst du ein 2Dimensionales Feld an ein Unterprogramm übergeben. Funktioniert einwandfrei 🙂
    Ist aber mit typedef realisiert:

    #define MAX 5

typedef int TypFeld[MAX][MAX]; //Definition eines neuen Types

void init(TypFeld);//Prototyp des Unterprogramms

int main(int argc, char *argv[])
{
   TypFeld feld1; //Deklaration des neuen Types
   init (feld1);
   system("PAUSE");	
  return 0;
}

void init(TypFeld a) 
{   
 //So hier kannst du nun dein Feld beliebig bearbeiten
}
    0
  • H

    Hallo,
    irgendwie verstehe ich euer Problem nicht.

    // 1. Übergabe per Pointer -> erste Dimension ist beliebig. 
// Zweite *muss* angegeben werden
#include <iostream>

void f1(int (*p)[10], int firstDim)
{
     for(int i = 0; i < firstDim; ++i)
         for (int j = 0; j < 10; ++j)
             std::cout << p[i][j];
}

// 2. Übergabe als Pointer andere schreibweise. 
// Erste Dimension ist beliebig. 
// Zweite *muss* angegeben werden.
void f2(int p[][10], int firstDim)
{
    for(int i = 0; i < firstDim; ++i)
         for (int j = 0; j < 10; ++j)
             std::cout << p[i][j];
}

// 3. Übergabe per Referenz.
// Beide Dimensionen *müssen* angegeben werden.
void f3(int (&p)[8][10])
{
    for(int i = 0; i < 8; ++i)
         for (int j = 0; j < 10; ++j)
             std::cout << p[i][j];
}

// 4. Als Template -> Übergabe per Pointer
template <class T, unsigned N>
void f4(T (*p)[N], int firstDim)
{
    for(int i = 0; i < firstDim; ++i)
         for (int j = 0; j < N; ++j)
             std::cout << p[i][j];
}

// 5. Als Template -> Übergabe per Referenz
// Dimensionen werden automatisch ermittelt
template <class T, unsigned N, unsigned M>
void f5(T (&p)[N][M])
{
    for(int i = 0; i < N; ++i)
         for (int j = 0; j < M; ++j)
             std::cout << p[i][j];
}

int main()
{
    int arr[8][10];
    f1(arr, 8);
    f2(arr, 8);
    f3(arr); 
    f4(arr, 8);
    f5(arr);
}
    0
  • G

    hi,

    @ HumeSikkins: Es hat bei mir wie gesagt nicht funktioniert. Jetzt wo beide Dimensionen bekannt sind funzt es.

    @ Jover: Ich würde ein 2D-Array in ein 1D-Array auf folgende Weise umwandeln:

    const int ARRAY_X=3;
const int ARRAY_Y=3;

char array[ARRAY_X*ARRAY_Y];  

int setIndex(int x, int y)  
{  
  return y*ARRAY_X+x; // Index zurückgeben
}  

// Array füllen
for(int i=0; i<ARRAY_X; i++)
{
  for(int j=0; j<ARRAY_Y; j++)
  {
     array[setIndex(i,j)]='A';
  }
}

// Array sieht jetzt so aus:
// A A A A A A A A A 
// so wird es auch im Speicher des PCs dargestellt, egal wieviele Dimensionen es hat.
// Ich weiß nicht genau, ob der Compiler die mehrdimensionalen Arrays umwandelt oder wie das geht.
// wenn du dir das zweidimensional vorstellst sieht unser Array so aus:
// A A A
// A A A
// A A A

// Array verändern
array[setIndex(2,1)]='B';

// jetzt sieht das Array so aus:
// A A A A A A B A A 
// 2D:
// A A A
// A A A
// B A A
// Wie du siehst an Stelle 2, 1 liegt unser B

    Ich hoffe, das hilft dir irgendwie. Müsste eigentlich auch bei vector funktionieren.
    Bitte berichtigt mich, wenn ich falsch liege.

    Tschau Gartenzwerg

    0
Anmelden zum Antworten