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