Ich komme aus dem Java Bereich und hab jetzt ein paar kleine Probleme in meinem C++ Programm wenn es darum geht Arrays zwischen Funktionen zu übergeben.
Ich weiß noch das man da mit den Pointern rumhantieren muß (das hat mich immer sehr verwirrt) aber leider nicht mehr genau wie. Ich Poste mal hier einen Beispielcode, der zeigt wo mein Problem liegt:

int max = 10;

Myclass* myarray[max];      //Arrays erstellen
Myclass* myparray1[max];	
Myclass* myparray2[max];	

for (loop=0;loop<max;loop++)	//Arrays zuweisen		
	{
	myarray1[loop] = new Myclass();
	myarray2[loop] = new Myclass();

	}

void myfunktion(Myclass* param1){  // Funktion soll Array erhalten 

myarray = *param1;  //Dies ist vielleicht gar nicht nötig, myarray sollte     
                    //Speicherplatz von param1 haben.
}

void mymain(){

myfunktion(*myarray1);  //Array wird übergeben
myfunktion(*myarray2);

}

Also kurz beschrieben, ich will zwei(und mehr) Arrays aus Klassenelementen erstellen. Diese Array füll ich vorher. Dann will ich die Funktion "myfunktion" aufrufen können und die soll dann mit dem Array arbeiten welches ich als Parameter übergebe (call by reference).

So, ich hoffe jemand kann mir helfen und zeigen wie ich diese Pointer setzten muß, ich denke das ich sicherlich nur ein leichtes Anfängerproblem

mfg Mari2k

Myclass myarray[max];      //Arrays erstellen
Myclass myparray1[max];   
Myclass myparray2[max];

Du hast ja mit

Myclass* myarray[max];

einen Zeiger auf ein Array oder so erstellt!

Und da du ein Array mit fester Anzahl hast, wurde bereits beim erstellen Speicher für max Objekte angefordert, also musst du die Zuweisung nicht mit

myarray1[loop] = new Myclass();

machen, da

new

ja wieder Speicher anfordert...
Ich hoffe mal das stimmt soweit, bin auch grad dabei C++ zu lernen...

Also das "new" ist ja nur dazu da um mir eine neue Instanz für die Klasse zu erstellen, die wird dann in dem Array (auf dem bestimmten Platz) gespeichert. Das hat soweit auch alles geklapt, habe halt nur Probleme bei der Übergabe von dem Array (call by reference) Mymain zu Myfunktion.

Also das "new" ist ja nur dazu da um mir eine neue Instanz für die Klasse zu erstellen

Du kannst in C++ (im Gegensatz zu Java) Instanzen auch ohne new erstellen. Oder hat das einen tieferen Sinn, dass du Zeiger benutzt?

void myfunktion(Myclass* param1){  // Funktion soll Array erhalten

myarray = *param1;  //Dies ist vielleicht gar nicht nötig, myarray sollte    
                    //Speicherplatz von param1 haben.
}

und das ist glaub ich so nicht möglich! Dazu müsstest du evtl. den Zuweisungsoper überladen!
Ausserdem erwartet deine Funktion myfunktion nen Zeiger als Argument, und du übergibst das Array ja mit *myarray1 ja dereferenziert!
Weiss nicht ob das so stimmt, aber das ist mir noch aufgefallen!

Dazu müsstest du evtl. den Zuweisungsoper überladen!
Ausserdem erwartet deine Funktion myfunktion nen Zeiger als Argument, und du übergibst das Array ja mit *myarray1 ja dereferenziert!
Weiss nicht ob das so stimmt, aber das ist mir noch aufgefallen!

Ja, also mein Code ist auch nicht richtig, wahrscheinlich sind die Pointer zeichen total falsch. Ich weiß halt nicht genau wie ich das komplette Array an die Funktion übergeben soll. Bisher arbeitet die Funktion mit einen globalen Array, das funktioniert auch ganz gut, nur wollte ich das jetzt mit Parameter übergabe machen.

Wär nett wenn jemand ein mir anhand eines Beispiels zeigen könnte wie sowas geht

Beispiel:

void arrayfunc(int* array, int numberelements)
{
   for (int i=0;i<numberelements;i++)
      std::cout << array[i];                        //Array wird ausgegeben
   std::cout << std::endl;
}

void arrayfunc2(int* array, int numberelements)
{
   for (int i=0;i<numberelements;i++)
      array[i] = 5*i;                         //originales Array wird überschrieben
}

int main()
{
int iarray[10]={1,2,3,4,5,6,7,8,9,10};        //erstellt neues int-Array mit den
                                              //Werten 1 2 3 4 5 6 7 8 9 10 
arrayfunc(iarray,10);                       //ruft arrayfunc() auf und übergibt 
                                              //einen Zeiger auf das erste Element des Arrays
                                              //->es wird keine Kopie erstellt!!!

arrayfunc2(iarray,10);                      // es wird der gleiche Zeiger übergeben
                                              //->wieder keine Kopie! Orginal-Array wird überschrieben!!!

arrayfunc(iarray,10);                       //verändertes Array wird ausgegeben
return 0;
}

Edit: das gleiche müsste auch mit Referenzen anstatt Zeigern funktionieren!
Und falls du dein originales Array nicht direkt benutzen möchtest, sondern eine Kopie davon haben willst, dann kannst du das Array in eine Struktur verpacken und die übergeben!

struct iarray               //Struktur definieren
{
   int a[10];
};

iarray myarray;            //Struktur mit Namen myarray erstellen

func(myarray);             //Struktur wie Variable übergeben

void func(iarray array);   //Prototyp von func()

Ich glaube ich habs jetzt hinbekommen, allerding war es noch ein stück komplizierter da ich von vornerein schon ein Pointer Array hatte.

Also im endeffekt (wenn ich dein beispiel nehme):

Funktion aufrufen mit :
arrayfunc(iarray);

Und bei der Funktion dann:
void arrayfunc(int** array)

Damit scheint jetzt alles zu klappen

int array[10];

ist ja

array

schon ein Zeiger auf das erste Element!

classname objectname;
classname *objectpointer;
objectpointer = new classname;
objectname.memberfunction();                  // wie Struktur
objectpointer->memberfunction();                // ist dann so wie du es machst oder?
                                              // ist aber meines Wissens nach völlig gleichwertig!