??Zeiger auf Feld von Klassen-elementen??

operator void

vector<T*> und T*[n] sind beides Container für T*. Wo man die Zeiger herbekommt (in diesem Fall wohl über new) hat damit nichts zu tun. Ein statisches Array braucht sogar eine Allokierung auf dem Heap weniger (im Idealfall also gar keine, wenn man ein Kleingeld-Objekt auf dem Stack erstellt).

also ist das Array schneller?

Und die Dereferenzierung ist doch kein Problem...

int *ar;
ar = new int[100];
ar[10] = 12;

mhhh, überzeugt, aber ich wollte Vector<T> satt Vector<T*>

mfg
Glamdring

operator void

Nein, das ist jetzt ein dynamisches Array. Das ist nur noch minimal schneller als ein Vektor (und dafür unkomfortabler). Der Vergleich war hier zwischen:

// Original und so, wie es laut OP sowieso sein _muss_
class Kleingeld
{
    Muenze* muenzen[100];
...
};

und

// vector<T*>-Version
class Kleingeld
{
    vector<Muenze*> muenzen; // Wird entsprechend vergrößert
...
};

Ja, klar, aber irgendwo muss auch vector<T> seine Ts ablegen. Und dass das auf dem Stack passiert, glaub ich weniger, also auch mit new ( oder malloc() ), aber das tut ja hier auch nciths zur Sache Der Threadersteller hat sich ja auch nicht mehr gemeldet

Gruß, maxi

Jupp

startupboy

Hi...
Ich danke euch erstmal über die Zahlreichen antworten!!!

Bin jetzt auch so weit gekommen...
nur ralle ich es jetzt wieder nicht wie ich den ganzen krempel ausgebe...
ich rufe eine methode aus kleingeld auf...
was mache ich in dem überladenen operator<< falsch?

Kleingeld &operator=(const Kleingeld &K) <--- dies Methode soll ich in Kleingeld schreiben, nur wie?

? ist es möglich im main-programm das private objekt Anzahl auszugeben, oder ist es so wie ich es gemacht habe schon gar nicht so verkehrt?

Fällt euch irgendwas auf in dem Programm was ich noch falsch mache?
Ich danke für jede Antwort...

___________________________________________________________________________
Mainprogramm :

#include "muenze.h"
#include "kleing.h"

using namespace std;

// Zeit für die Zufallsfunktion...
time_t time(), zp;
struct tm *localtime(), *tp;

int main() {

int auswahl,empt,zufall;

Kleingeld boerse;
Muenze neue;

do{

cout << endl << endl << endl;
empt=boerse.empty();
if (empt == 0) cout << "Es sind keine Muenzen in der Geldboerse !" << endl;
if (empt == 1) cout << "Es es sind " << boerse.anzahle() << " Muenze(n) in der Geldboerse !" << endl;
cout << "__________________________________________________________________";
cout << "\nWelche Aktion soll ausgefuehrt werden ?" << endl;
cout << "(1)Neue Muenze (2)Muenze entfernen (3)Inhalt anzeigen " << endl;
cout << "(4)Muenze werfen (5)Summe des Geldes (6)Inhalt sortieren " <<endl;
cout << "(0)Beenden : ";
cin >> auswahl;

if (auswahl == 1) {
cout << "__________________________________________________________________";
cout << "\n\nMuenze Nr. " << (boerse.anzahle())+1 << " wird hinzufuegen :";
boerse >> neue;

}
if (auswahl == 2) {
cout << "__________________________________________________________________";
cout << "\n\nMuenze entfernen :" << endl;

}
if (auswahl == 3) {
cout << "__________________________________________________________________";
cout << "\n\nInhalt anzeigen :" << endl;
boerse.ausgabe();

}
if (auswahl == 4) {
cout << "__________________________________________________________________";
cout << "\n\nMuenze werfen :" << endl;
// Zeit holen
zp=time(0);
tp=localtime(&zp);
cout << "\nIn Sekunde " << tp->tm_sec << " wurde " << neue.muenzwurf(tp->tm_sec) << " geworfen !"<<endl;

}
if (auswahl == 5) {
cout << "__________________________________________________________________";
cout << "\n\nSumme des Geldes :" << endl;

cout << endl;

}
if (auswahl == 6) {
cout << "__________________________________________________________________";
cout << "\n\nInhalt sortieren :" << endl;

}
}while(auswahl);

cout << "\n\nProgramm wurde beendet!" << endl;

return 1;
}

_________________________________________________________________________
kleing.h

class Kleingeld {
friend class Muenze;
friend ostream &operator<<(ostream &o, Muenze *m);

private:
class Muenze *M[100];
int Anzahl; //Anzahl der Muenzen

public:
Kleingeld(){ // Konstruktor von Kleingeld
Anzahl = 0;
cout << "\t-> K-Konstrukt";
}

~Kleingeld(){ // Destruktor von Kleingeld
for (int i=0; i<=Anzahl ; i++){
delete M[i];
}
cout << "\t-> K-Destrukt";
}

int anzahle() { // Gibt die Anzahl der muenzen zurueck, da Anzahl private
return Anzahl;
}

bool empty() {
if (Anzahl >= 1) return 1;
else return 0;
}

Kleingeld &operator=(const Kleingeld &K) {

//Anzahl=K;
return *this;
}

Kleingeld &operator>>(Muenze &neu){
int nwert,ok;
M[Anzahl] = new Muenze;
*M[Anzahl] = neu;
Anzahl++;

do {
cout << "\n\nWert der Muenze in Cent eingeben :";
cin >> nwert;
if ( (nwert == 1) || (nwert == 2) || (nwert == 5) || (nwert == 10)
|| (nwert == 20) || (nwert == 50) ) {
neu.wert = nwert;
neu.art = "Cent";
ok = 0;
}
if ((nwert == 100) || (nwert == 200)) {
neu.wert = nwert;
neu.art = "Euro";
ok = 0;
}

} while(ok);

return *this;
}

void ausgabe(){
for(int i=0;i<Anzahl;i++){
cout << *M[i];
cout << endl;
}
}

};

// ausgabe als friend
ostream &operator<<(ostream &o, const Muenze *m){
o << m???wert << " " << m???art << " Muenze" << endl;

return o;
}

___________________________________________________________________________
Muenze.h

class Muenze {
friend class Kleingeld;

private:
string art;
int wert;

public:

//Standardkonstruktor: Wert=0, Art=""
Muenze(){
art ="";
wert =0;
cout << "\t\t-> M-Konstrukt";
}

~Muenze(){
cout << "\n-> M-Destrukt";

}

string muenzwurf(int start) {
int zufall;
string koza;
srand(start);
// Zufallszahl aus zweien...
zufall=rand()%2;
if (zufall == 1) koza="Kopf";
else koza="Zahl";
return koza;

}

};

... Es wäre besser, wenn du nur die Teile deines Prgrammes zeigen würdest, wo noch Problemem entstehen. Außer dem ist es besser lesbar, wenn du die Code-Tags benutzt (C/C++) ganz unten.

Also: Kleingeld &operator=(const Kleingeld &K) ist der Zuweisungsoperator, damit kannst du zB sowas machen:

Kleingeld K1, K2;
K1.Machwas();
K2 = K1 // <-- hier wird der Zuweisungsoperator aufgerufen.
Ich denke du sollst das Kleingeld in eine andere Instanz kopieren, also musst du jedes Element der Klasse in das Ausgabeobjekt(K2) kopieren, in dem operator-Aufruf.
Wenn der Operator direkt zur Klasse gehört, dann musst du das so machen:

Kleingeld& Kleingeld::operator=(const Kleingeld&)
{
// Anweisungen
}

ich denke, ostream-operaot soll ja den Inhalt von Kleingeld ausgeben, oder?
Dann müsste das ja dann in etwa so sein, aber ich kenn mich mit operatoren nicht so gut aus

ostream& Kleingeld::operator<<(ostream& o, Kleingeld K)
{
// Gib den Inhalt aus etwa so:
o << "Inhalt" << endl;
}

So, zur dritten Frage:
Das mit KLeingeld::Anzahele() ist richtig so, denn eine Klasse soll ihre eigenen Elemente nicht von anderen verändern lassen dürfen. Sie soll nur über Schnittstellen(Methoden) mit der Außenwelt kommunizieren. Daher ist das schon richtig so.

Gruß, Maxi

startupboy

danke erstmal...
Ok, wer das nächste mal versuchen dran zu denken die c/c++ tags zu setzen...

was aber meine eigentliche frage ist wie rufe ich in...

ostream &operator<<(ostream &o, const Muenze *m){
	o << mwert << " " << m*.art << " Muenze" << endl;	

	return o;
}

die objekte (m??wert und m??art) auf?

Du meinst also, wie du über einen Zeiger auf das Objekt zugreifen kannst?

Das ist ganz einfach:

int zahl = 5;
int* zeiger = &zahl;  // zeiger zeigt jetzt auf Zahl

// zahl kann man über den zeiger so verändern:
*zeiger = 5;  // zahl ist ejtzt 5

// mit * vor der Variablen wird niht die Adresse sondern der Wert, wo die Adresse hinzeigt als Operand genommen, das nennt man dereferenzieren
// genauso geht das mit Zeigern auf Objekte:
Klasse* k;

// Also das ganze machen wie mit dem int-zeiger: erst dereferenzieren, dann ausführen
(*k).Machwas();

// gleichwertig und schöner anztufsehen ist diese Schreibweise:
k->Machwas();  // macht aber genau das gleiche wie (*k).Machwas()

Hoffe habs gut genug erklärt

Maxi