3. zweidimensionales Array einer Funktion übergeben

zweidimensionales Array einer Funktion übergeben

  • 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
  • J

    Gartenzwerg schrieb:

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

    Das wäre dann die letzte Notlösung

    0
  • G

    wieso?

    0
  • R

    hi

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

    eigentlich 20**^**20 oder 😕
    cYa

    0
  • G

    hi,
    ich denke 20*20

    machen wir es mal im kleinen:

    char array[2][2];
// z.B.
// A A
// A A
// => 4 Elemente = 2*2 oder 2^2

char array[3][3];
// z.B.
// A A A
// A A A
// A A A
// => 9 Elemente = 3*3 oder 3^2

    deshalb meine ich 20*20 oder halt 20^2. Aber nicht 20^20.

    Tschau Gartenzwerg

    0
  • R

    hi

    char a[3][3];

a[0][0]='1';
a[0][1]='2';
a[1][0]='3';
a[1][1]='4';
a[2][2]='5';
a[2][1]='6';
a[1][2]='7';
a[0][2]='8';
a[2][0]='9';

    3^3 und nich 3*3

    🙄

    cYa

    0
  • G

    hi,
    sag ich doch. So wie du es gemacht hast ist es sogar noch etwas übersichtlicher.
    Irren ist menschlich. 😉

    Tschau Gartenzwerg

    0
  • E

    Also das hier funzt bei mir, es kommt wohl auf die Klammern um *arr an.

    #include <iostream>
using namespace std;

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

int main(){
char array[20][20];  

 function(array, 20,20);
}

    Und es sind 3*3 = 9 und nicht 3^3 = 27, aber was besaeftige ich mich ueberhaupt mit der Kinderk****

    0
  • J
     

    class GoL
{
    int columns;
    bool **cells;

public:
    void init();
    bool getCell(int index1, int index2);
    void setColumnCount(int cols);
}

void GoL::init()
{
    cells = &(new bool[columns]);
    for (int i=0; i<columns; i++)
        cells[i] = new bool[columns];

    // ...
}

bool GoL::getCell(int index1, int index2)
{
    return cells[index1][index2];
}

void GoL::setColumnsCount(int cols)
{
    columns = cols;
}

    So jetzt läuft das mit dem 2D Array so ungefähr.

    Aber wenn ich die Funktion getCell(...) aufrufe, dann bekomme ich einen Fehler.
    Warum ist das so?

    Weiter unten in der init() Funktion greife ich auf die gleiche Weise auf das Array zu, bekomme aber keinen Fehler.

    0
Anmelden zum Antworten