Übergabe von mehrdimensionalen Arrays in C/C++

Entweder machst du karten zu einer globalen Variable oder du machst dir das Karten-Array schon in main und übergibst es dann an die Funktion.
Der Funktionskopf muss dann so aussehen:
void blatt(char [][3])
und in main:
char KartenM[32][3];
blatt(KartenM);

oder du benutzt eine etwas abstraktere technik

eine funktion:

void foo(int **_ptr);

irgendwo im programm:

int **pparray = new int *[grösse_x];
pparray[ 0 ] = new int [grösse_x * grösse_y];

for(int i = 0; i < grösse_y;i++)
     pparray[ i ] = array[ 0 ] + i * ny;

foo(pparray);

du kannst nun einfach den zeiges zeiger 'pparray' wie ein normales 2d array benutzen (klasse ned? ) und die funktion 'foo' kann beliebig grosse 2d arrays aufnehmen
(hoffentlich isses verständlich )

Unterstriche bei Bezeichnern sollten nicht vorangestellet werden,da diese für den Compiler reserviert sind.Ansonsten...erklär mal deinen Code.

Hi,

wenn ich das richtig verstanden habe, dann ist Dein Problem eher prinzipieller Natur. Ich gehe davon aus das Du das Array "karten[32][3]" welches Du am Anfang der Funktion anlegst "irgendwie" zurückgeben willst um damit weiterzuarbeiten. Falls dies so ist, wirst Du bei Deiner Funktion IMMER scheitern. Das Problem liegt darin, dass lokale Variablen einer Funktion immer auf dem STACK angelegt werden. Wenn die Funktion nun beendet ist existiert auch der STACK nicht mehr und somit ist auch dein Array futsch. Damit das nicht passiert musst Du das Array auf dem HEAP anlegen und zwar ganz einfach mit dem Schlüsselwort new ( ist C++ in C mit malloc ). Also z.B. so:

char** karten    //ein Zeiger auf ein Feld von chars

karten = new char*[2]; //Speicher für 2 char-pointer
karten[0] = new char[32]; //Speicher für 32 chars
karten[1] = new char[3];  //Speicher für 3 chars

Den Speicher den Du so mit new besorgt hast musst Du aber irgendwann auch wieder freigeben, damit keine memory leaks entstehen, das geht in dieserm Fall so:

delete []  karten[0];  //lösche die 32 chars
delete []  karten[1];  //lösche die 3 chars
delete []  karten;     //lösche die beiden Zeiger

Wenn Du C statt C++ verwendest machst Du das mit free.

Achja, zurückgeben kannste das folgendermassen:

char** blatt()
{
   char** karten;

   // Speicher mit new besorgen ....
   .
   .
   .
   .

   return karten;  //Das Array zurückgeben
}


Nun brauchst Du nur noch in deinem Hauptprogramm einen Zeiger deklarieren und ihm den return Wert zuordnen:


char** pArray;

pArray = blatt();

Nun kannst Du auf das Array zugreifen.

Huch,

der Code ist ein wenig verunstaltet worden beim posten, aber ich hofe Du weisst was gemeint ist

template<typename T>
T** dim2arr(int x,int y)
{
 T** ppArr = new T*[ x ];
 for(int i = 0;i < x;++i)
  ppArr = new T[y];
 return ppArr;
}

Aufruf:

blatt(dim2arr<char>(32,3));
Meinst du das 123?
Geht natürlich nur mit C++.

Unterstriche bei Bezeichnern sollten nicht vorangestellet werden,da diese für den Compiler reserviert sind.Ansonsten...erklär mal deinen Code.

Hmm,eigentlich ist dein Code sogar völlig in Ordnung, ein Unterstrich ist ok solange die Variable nicht global ist und nach dem _ kein Großbuchstabe ist.
 

@Windows.exe:

ok, nu hast Du das als template deklariert, aber was die Allozierung betrifft meine ich genau das.

Hallo!

Ersteinmal Danke für die Antworten! Leider habe ich nicht alle so ganz verstanden . Nun habe ich das ausprobiert was 123 meinte aber dabei bekomme ich leider eine für mich wilde Fehlermeldung:

------------------------------------------------------
Die Anweisung in "0x0041e522" verweist auf Speicher in 0x00000000. Der Vorgang "written" konnte nicht auf dem Speicher durchgeführt werden.
------------------------------------------------------

Mein jetziger Code:
......................................................
"header.h"

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include "string.h"
using namespace std;

extern void farbsymbole(char *karo_sym, char *herz_sym, char *pik_sym, char *kreuz_sym);
extern char** blatt();
......................................................
#include "header.h"

void farbsymbole(char *karo_sym, char *herz_sym, char *pik_sym, char *kreuz_sym)
{
*karo_sym  = 4; //Karosymbol &#9830;
*herz_sym  = 3; //Herzsymbol &#9829;
*pik_sym   = 6; //Piksymbol &#9824;
*kreuz_sym = 5; //Kreuzsymbol &#9827;
}
......................................................
#include "header.h"

char** blatt()
{
char karo_sym  = 0;
char herz_sym  = 0;
char pik_sym   = 0;
char kreuz_sym = 0;
int  i=0, j=0;
char** karten;    //ein Zeiger auf ein Feld von chars
karten    = new char*[2]; //Speicher für 2 char-pointer
karten[0] = new char[32]; //Speicher für 32 chars
karten[1] = new char[3];  //Speicher für 3 chars

/* In der Funktion(farbsymbole) sind die Symbolwerte festegelegt.  */
farbsymbole(&karo_sym, &herz_sym, &pik_sym, &kreuz_sym);

for(i=0;i<8;i++)
   {
   karten[  i ][ 0 ] = 4; //Symbol für Karo
   karten[i+8 ][ 0 ] = 3; //Symbol für Herz
   karten[i+16][ 0 ] = 6; //Symbol für Pik
   karten[i+24][ 0 ] = 5; //Symbol für Kreuz
   }
for (i=0;i<3;i++)
   {
   j = i + 55;//ASCII-Wert für 7,8 und 9
   karten[ i  ][1] = j;
   karten[i+8 ][1] = j;
   karten[i+16][1] = j;
   karten[i+24][1] = j;
   }
for (i=3;i<6;i++)
   {
   j = i + 47; //ASCII-Wert für 2,3 und 4
   karten[ i  ][1] = j;
   karten[i+8 ][1] = j;
   karten[i+16][1] = j;
   karten[i+24][1] = j;
   }
for (i=6;i<8;i++)
   {
   j = 49; //ASCII-Wert für 1
   karten[ i  ][1] = j;
   karten[i+8 ][1] = j;
   karten[i+16][1] = j;
   karten[i+24][1] = j;
   }
for (i=0;i<6;i++)
   {
   j=0; //Wert für alle Karten unter 10
   karten[ i  ][2] = j;
   karten[i+8 ][2] = j;
   karten[i+16][2] = j;
   karten[i+24][2] = j;
   }
for (i=6;i<8;i++)
   {
   j = i + 42; //ASCII-Wert für 11 und 12
   karten[ i  ][2] = j;
   karten[i+8 ][2] = j;
   karten[i+16][2] = j;
   karten[i+24][2] = j;
   }
return karten;
}
......................................................
#include "header.h"

void main()
{
char karten[32][3];
int i,j;
char** pArray;
pArray = blatt();
for(i=0;i<32;i++)//Ausgabe des Arrays
   for (j=0;j<3;j++)
      cout << karten[j];
delete []  karten[0];  //lösche die 32 chars
delete []  karten[1];  //lösche die 3 chars
delete []  karten;     //lösche die beiden Zeiger
}
......................................................

Es ist wohl noch immer mein Problem, dass ich die Zeigersyntax bei mehrdimensionalen Arrays nicht völlig verstehe. Der Versuch mit der abstrakten Technik von void ist bei mir auch mächtig in die Hose gegangen . Templates habe ich mir bisher noch nicht angelesen. Ich würde es gerne mit Zeigern machen da ich sonst Angst habe vielleicht Globale Variablen zu überschreiben.

Freundliche Grüsse
Daniel

Eigentlich sollten da viel viel mehr Fehlermeldungen kommen.
Ich hab an deinem Code jetzt ein paar Sachen geändert und das ganze mit dem Template realisiert.
----------------------------------------
#include <iostream>
using namespace std;
template<typename T>
T** dim2arr(int x,int y)
{
T** ppArr = new T*[ x ];
for(int i = 0;i < x;++i)
  ppArr = new T[y];
return ppArr;
}
void farbsymbole(char *karo_sym, char *herz_sym, char *pik_sym, char *kreuz_sym)
{
*karo_sym  = 4; //Karosymbol &#9830;
*herz_sym  = 3; //Herzsymbol &#9829;
*pik_sym  = 6; //Piksymbol &#9824;
*kreuz_sym = 5; //Kreuzsymbol &#9827;
}

void blatt(char** karten)
{
char karo_sym  = 0;
char herz_sym  = 0;
char pik_sym  = 0;
char kreuz_sym = 0;
int  i=0, j=0;    //ein Zeiger auf ein Feld von chars
/* In der Funktion(farbsymbole) sind die Symbolwerte festegelegt.  */
farbsymbole(&karo_sym, &herz_sym, &pik_sym, &kreuz_sym);

for(i=0;i<8;i++)
  {
  karten[  i ][ 0 ] = 4; //Symbol für Karo
  karten[i+8 ][ 0 ] = 3; //Symbol für Herz
  karten[i+16][ 0 ] = 6; //Symbol für Pik
  karten[i+24][ 0 ] = 5; //Symbol für Kreuz
  }
for (i=0;i<3;i++)
  {
  j = i + 55;//ASCII-Wert für 7,8 und 9
  karten[ i  ][1] = j;
  karten[i+8 ][1] = j;
  karten[i+16][1] = j;
  karten[i+24][1] = j;
  }
for (i=3;i<6;i++)
  {
  j = i + 47; //ASCII-Wert für 2,3 und 4
  karten[ i  ][1] = j;
  karten[i+8 ][1] = j;
  karten[i+16][1] = j;
  karten[i+24][1] = j;
  }
for (i=6;i<8;i++)
  {
  j = 49; //ASCII-Wert für 1
  karten[ i  ][1] = j;
  karten[i+8 ][1] = j;
  karten[i+16][1] = j;
  karten[i+24][1] = j;
  }
for (i=0;i<6;i++)
  {
  j=0; //Wert für alle Karten unter 10
  karten[ i  ][2] = j;
  karten[i+8 ][2] = j;
  karten[i+16][2] = j;
  karten[i+24][2] = j;
  }
for (i=6;i<8;i++)
  {
  j = i + 42; //ASCII-Wert für 11 und 12
  karten[ i  ][2] = j;
  karten[i+8 ][2] = j;
  karten[i+16][2] = j;
  karten[i+24][2] = j;
  }
}

int main()
{
int i,j;
char** ppKarten = dim2arr<char>(32,3);
blatt(ppKarten);
for(i=0;i<32;i++)//Ausgabe des Arrays
  for (j=0;j<3;j++)
      cout << ppKarten[j];
Sleep(3000);
}
--------------------------------------
Was für einen Compiler benutzt du,der noch void main zulässt?

Moin nochmal,

kann auch noch nicht funktionieren so wie Du das im Moment hast, bist aber schon nahe dran

Folgender Auszug aus Deinem Code:

...
for(i=0;i<8;i++)
{
  karten[  i ][ 0 ] = 4; //Symbol für Karo
  karten[i+8 ][ 0 ] = 3; //Symbol für Herz
  karten[i+16][ 0 ] = 6; //Symbol für Pik
  karten[i+24][ 0 ] = 5; //Symbol für Kreuz
}
...

Das schlägt schon fehl, weil es lauten muss:

for(i=0;i<8;i++)
{
  karten[ 0 ][  i ] = 4; //Symbol für Karo
  karten[ 0 ][i+8 ] = 3; //Symbol für Herz
  karten[ 0 ][i+16] = 6; //Symbol für Pik
  karten[ 0 ][i+24] = 5; //Symbol für Kreuz
}

da ja karten[ 0 ] Dein Array von 32 chars ist, also karten[ 0 ][ 0 ] bis karten[ 0 ][31]

entsprechend enthält karten[ 1 ] Dein Array von 3 chars, also
karten[ 1 ][ 0 ] bis karten[ 1 ][ 2 ].

Da Du oben die Indizes vertauscht hast greifst Du auf Speicher zu der Dir gar net gehört und somit gibt's die  Schutzverletzung.

Ich hoffe das ist Dir nun klar.

Hi!

@123: Erstmal wieder Danke! Ja hatte es bisher noch nicht begriffen wo nun wie die neu erstellten Zeiger drauf zeigen, aber ich werde es gleich mal testen, ob es so funktioniert, obwohl ich mittlerweile eine etwas küzere Funktion gefunden habe de mir mein Array auch füllt und ich es übergeben kann. Auch wenn leider nicht mit Zeigern. Verstehen tue ich sie auch noch immer nicht ganz in Fall eines zweidimensionalen Arrays. Weiß vielleicht jemand dazu einen guten Link ?

@windows.exe: Mmmhh *duck* ich benutze Windows mit Visual Studio.net 2003. Eigentlich komme ich damit relativ gut klar und über void main() meckert er nicht. Soweit ich weiß würde es unter Linux nur mit int oder so gehen. Bei Windows kann ich aber glaube so ziemlich "alles" vors main schreiben wozu ich Lust habe? Naja void main() funst auf jedenfall.

Was die Template Variante angeht bin ich mir relativ sicher, dass sie klappen wird, nur was sind Templates überhaupt ??? ? Ich habe mir Templates noch nicht angeschaut, sollte ich wohl mal unbedingt tun.

@alle die es interessiert:

Meine jetzige Funktion habe ich mit Strukturen gelößt ud ist viel kürzer geworden:

......................................................
"header.h"

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include "string.h"
using namespace std;

extern void farbsymbole(char *karo_sym, char *herz_sym, char *pik_sym, char *kreuz_sym);
extern void farbenwert(int *karo, int *herz, int *pik, int *kreuz, int *grand, int *grand_ouvert);
extern struct karte* blatt();

struct karte
{
char farbe;
int wert;
};  
......................................................
#include "header.h"

struct karte* blatt()
{
char karo_sym  = 0;
char herz_sym  = 0;
char pik_sym   = 0;
char kreuz_sym = 0;
int  i=0, j=0;
struct karte* karten = new karte[32];
/* In der Funktion(farbsymbole) sind die Symbolwerte festegelegt.  */
farbsymbole(&karo_sym, &herz_sym, &pik_sym, &kreuz_sym);

for(i=0;i<8;i++)
   {
   karten.farbe    = karo_sym;  //Symbol für Karo
   karten[i+8 ].farbe = herz_sym;  //Symbol für Herz
   karten[i+16].farbe = pik_sym;   //Symbol für Pik
   karten[i+24].farbe = kreuz_sym; //Symbol für Kreuz
   }
for(j=0;j<4;j++)
   {
   for(i=0;i<5;i++)
      {
   karten[i+j*8].wert=7+i;
      }
   for(i=5;i<8;i++)
      {
      karten[i+j*8].wert=i-3;
      }
   }
for(i=0;i<32;i++)
   {
   cout << karten.farbe << karten.wert;
   }
return karten;
}
......................................................
#include "header.h"

void main()
{
blatt();
}
......................................................

Nun sollte ich eigentlich mit struct vor die Funktion schreiben, in der ich die Funktion blatt() benutzen will, das Array mit meinen Karten weiter benutzen können, oder?

Mit freundlichen Grüßen
Daniel

Unter C++ sollte man,plattformunabhängig,kein void main verwenden,weil es gegen den Standard verstößt und eigentlich sollte man es nicht kompilieren können.

Guten Tag!

Das heißt das man Standardmäßig in der main auch einen Returnwert hat? Benutzt man dann return 1 oder return 0, oder wie ist es zu verstehen? Komplilieren läßt sich mein Programm auch mit int main(){return 1;}, int main(){return 0;} oder sogar einfach nur mit int main() { }. Aber was ist nun wie besser ??? ?

ein etwas verwirter
Daniel

Bei int main(){} setzt der Compiler das return 0; ein.
Was besser ist?
Wenn alles ok war wird 0 zurückgegeben,wenn etas schief gelaufen ist eine andere Zahl die für einen Error Code steht.Ich habe bis jetzt nie von Gebrauch gemacht.

Und schon wieder ich  !

@123: Ich habe den Code ausprobiert indem ich nun die Arrays vertauscht habe aber irgendwie kommt dann wieder ein ähnlicher Fehler auf mich zu:

------------------------------------------------------
Die Anweisung in "0x00416f98" verweist auf Speicher in "0xfdfdfdfd". Der Vorgang "written" konnte nicht auf dem Speicher durchgeführt werden.

------------------------------------------------------
Meine Funktion:
......................................................
#include "header.h"

void farbsymbole(char *karo_sym, char *herz_sym, char *pik_sym, char *kreuz_sym)
{
*karo_sym  = 4; //Karosymbol
*herz_sym  = 3; //Herzsymbol
*pik_sym  = 6; //Piksymbol
*kreuz_sym = 5; //Kreuzsymbol
}
char** blatt()
{
char karo_sym  = 0;
char herz_sym  = 0;
char pik_sym  = 0;
char kreuz_sym = 0;
int  i=0, j=0;
char** karten;    //ein Zeiger auf ein Feld von chars
karten    = new char*[2]; //Speicher für 2 char-pointer
karten[0] = new char[32]; //Speicher für 32 chars
karten[1] = new char[3];  //Speicher für 3 chars

/* In der Funktion(farbsymbole) sind die Symbolwerte festegelegt.  */
farbsymbole(&karo_sym, &herz_sym, &pik_sym, &kreuz_sym);

for(i=0;i<8;i++)
  {
  karten[ 0 ][  i ] = karo_sym;  //Symbol für Karo
  karten[ 0 ][i+8 ] = herz_sym;  //Symbol für Herz
  karten[ 0 ][i+16] = pik_sym;   //Symbol für Pik
  karten[ 0 ][i+24] = kreuz_sym; //Symbol für Kreuz
  }
for (i=0;i<3;i++)
  {
  j = i + 55;//ASCII-Wert für 7,8 und 9
  karten[1][ i  ] = j;
  karten[1][i+8 ] = j;
  karten[1][i+16] = j;
  karten[1][i+24] = j;
  }
for (i=3;i<6;i++)
  {
  j = i + 47; //ASCII-Wert für 2,3 und 4
  karten[1][ i  ] = j;
  karten[1][i+8 ] = j;
  karten[1][i+16] = j;
  karten[1][i+24] = j;
  }
for (i=6;i<8;i++)
  {
  j = 49; //ASCII-Wert für 1
  karten[1][ i  ] = j;
  karten[1][i+8 ] = j;
  karten[1][i+16] = j;
  karten[1][i+24] = j;
  }
for (i=0;i<6;i++)
  {
  j=0; //Wert für alle Karten unter 10
  karten[2][ i  ] = j;
  karten[2][i+8 ] = j;
  karten[2][i+16] = j;
  karten[2][i+24] = j;
  }
for (i=6;i<8;i++)
  {
  j = i + 42; //ASCII-Wert für 11 und 12
  karten[2][ i  ] = j;
  karten[2][i+8 ] = j;
  karten[2][i+16] = j;
  karten[2][i+24] = j;
  }
return karten;
}
......................................................
Meine "header.h":

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include "string.h"
using namespace std;

extern void farbsymbole(char *karo_sym, char *herz_sym, char *pik_sym, char *kreuz_sym);
extern char** blatt();
......................................................
meine main:

#include "header.h"

int main()
{
char karten[32][3];
int i,j;
char** pArray;
pArray = blatt();
for(i=0;i<32;i++)//Ausgabe des Arrays
  for (j=0;j<3;j++)
      cout << karten[j];
......................................................

Irgendwie verstehe ich das ganze halt leider nicht, die ganzen Zeiger verwirren mich.

Daniel
}

So, zum letzen

ich hatte wohl nicht so genau auf Deinen Code geschaut, deswegen hab ich Dir wohl ein anderes Array verpasst als Du wolltest.

Also wie's mir nu scheint willst Du ja ein Array der 'array[3][32]' haben, also ein 2D-Array mit 3*32 Feldern.


Das musste beim erzeugen des Arrays natürlich entsprechend machen:


... in der Funktion blatt():
karten = new char*[3]; //Speicher für 3 char-pointer
karten[ 0 ] = new char[32]; //Speicher für 32 chars
karten[ 1 ] = new char[32];  //Speicher für 3 chars
karten[ 2 ] = new char[32];  //Speicher für 3 chars
...

nun sollte das passen.
Falls das mit den Inizes noch anders gemeint war dann pass das halt entsprechend an, also ein x*y Feld erzeugst Du mit:

array = new char*[ x ];
for( int i=0; i<x; i++)
    array[ i ] = new char[ y ];

---------------------------

Allerdings hast Du noch andere Sachen verkehrt. Zum Beispiel in der main:

char karten[32][3];  <-- was soll das? brauchst Du gar net mehr, weil die Funktion Dir schon das Array erzeugt (allerdings nicht karten[32][3] sondern karten[3][32], also genau vertauschte Indizes). Du brauchst nur den Zeiger

char** pArray;

dann einfach:

pArray = blatt();

und ausgeben mit:

for( i=0; i<3; i++)
    for( j=0; j<32; j++)
         cout << pArray[j];

Bei Deiner Schleife in der main waren die Indizes allerdings schon wieder vertauscht, deswegen weiss ich nu nicht wie das gemeint ist, wenn Du nen [32][3] Array statt einem [3][32] haben willst musst Du das in der char** blatt() natürlich ändern.

Ausserdem scheint es so als ob Du die header.h in der entsprechenden .cpp in der Du die Funktionen definierst mit "includest". Ich weiss zwar im Moment nicht so genau ob das Ärger macht, aber scheint mir keine gute Idee innerhalb einer .cpp Datei Funktionen zu definieren und diese gleichzeitig (durch die header.h) als extern zu deklarieren.

Hi!

Mit der Header erschien die nur so. Wollte halt irgendwie kenntlich machen, dass es sich bei dem kommenden Abschnitt um meine Headerdatei handelt und habe darum "header.h" geschrieben. Ein Doppelpunkt dahinter hätte es vielleicht deutlicher gemacht.
------------------------------------------------------
Header-datei:

#include <blah.h>
------------------------------------------------------

Ich hätte eigentlich ein array[32][3] haben wollen. 32 Karten wobei jeder Karte 3 Zeichen lang ist. Bin jetzt aber zu einer Array aus 32 Strukturen übergegangen:
------------------------------------------------------
struct karte
{
char zeichen1;
char zeichen2;
char zeichen3;
};
------------------------------------------------------
Befürchte das ich aber auch den Gedanken wieder verwerfe werde und anstelle davon eine Liste aus 32 Karten mache. Dies hat den Vorteil, dass die benutzten Karten aus der Verkettenliste verschwinden. In meinem Array habe ich sie bisher einfach nur auf 0 gesetzt. Was den Nachteil hat, dass sobald ich "mische" auch Nullen als Zufallswert ausgeben werden können, wenn ich das nicht absicher. Bei einer Liste verbiege ich den Zeiger und die benutzte Karte verschwindet ganz.

Aber nochmal Danke für die ganzen Antworten! Ich werde sicher bei meinem Versuch irgendwann wieder zu Problemen kommen für die ich keine Lösung mehr sehe und da hat mir das Forum hier wirklich sehr geholfen  !

Mit freundlichen Grüßen
Daniel