zweidimensionales Array einer Funktion übergeben

Entyl_Sa

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.

Jover

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?

HumeSikkins

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.

Gartenzwerg

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

Jover

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

T0mmy

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
}

HumeSikkins

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);
}

Gartenzwerg

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

Jover

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

Gartenzwerg

wieso?

rulzmaker

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

Gartenzwerg

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

rulzmaker

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

Gartenzwerg

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

Tschau Gartenzwerg

Entyl_Sa

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****

Jover

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.