Schreiben Sie eine Klasse (mit Konstruktor, Destruktor, Kopierkonstruktor, Zuweisungsoperator), die zu jedem Zeitpunkt „weiß“, wieviele Instanzen dieser Klasse gerade existieren. Diese Information soll über eine Methode [FONT=Courier new] anzahlInstanzen() [/FONT] dieser Klasse (Rückgabetyp [FONT=Courier new] unsigned int[/FONT]) abfragbar sein.
Schreiben Sie ein Hauptprogramm zum gründlichen Testen der Klasse und lösen Sie folgende Teilaufgaben:[LIST]
[*] Implementierung der Klasse wie oben beschrieben
[*] Überladen Sie den Operator +, so daß Additionen zwischen Klassenobjekten und die Addition eines Integers (von links und von rechts) zu einem Klassenobjekt möglich sind. D.h. folgendes Hauptprogramm soll fehlerlos kompilieren (Das Ergebnis des Operators + soll wieder ein Objekt der Klasse sein. Der Wert des Resultats ist aber unerheblich). void main()
{
Klasse x,y;
int i;
x+y,(i=Klasse::anzahlInstanzen());
cout<<i<<",";
x+y;
i=Klasse::anzahlInstanzen();
cout<<i<<endl;
}
[*] Lassen Sie das gegebene Programmstück laufen. Vergleichen Sie die Ausgaben der Version der Klasse mit Kopierkonstruktor und einer Version ohne Kopierkonstruktor. Interpretieren Sie die Ergebnisse.[/LIST]
Alles anzeigen
Lösung:
//IntWrapper.h
#ifndef INTWRAPPER_H
#define INTWRAPPER_H
#include "IntWrapperCount.h"
namespace IntWrapper
{
class IntWrapper
{
//Attributes
private:
int content;
static IntWrapperCount intWrapperCount;
//Constructors & Destructors
public:
IntWrapper():
content(0) { intWrapperCount.IncreaseWrapperCount(); }
IntWrapper(const IntWrapper &aIntWrapper):
content(aIntWrapper.GetContent()) { intWrapperCount.IncreaseWrapperCount(); }
IntWrapper(int aInt):
content(aInt) { intWrapperCount.IncreaseWrapperCount(); }
~IntWrapper() { intWrapperCount.DecreaseWrapperCount(); }
//Methods
inline int GetContent() const { return content; }
inline void SetContent(int aContent) { content = aContent; }
static inline unsigned int GetIntWrapperCount() { return intWrapperCount.GetWrapperCount(); }
//Operators
inline IntWrapper& operator=(const IntWrapper &aIntWrapper)
{
content = aIntWrapper.GetContent();
return *this;
}
inline IntWrapper& operator=(const int &aInteger)
{
content = aInteger;
return *this;
}
inline IntWrapper& operator+=(const IntWrapper &aIntWrapper)
{
content += aIntWrapper.GetContent();
return *this;
}
inline IntWrapper& operator+=(const int &aInteger)
{
content += aInteger;
return *this;
}
const IntWrapper operator+(const IntWrapper &aIntWrapper) const
{
return IntWrapper(*this) += aIntWrapper;
}
const IntWrapper operator+(const int &aInteger) const
{
return IntWrapper(*this) += aInteger;
}
//Implementations
};
}
#endif
Alles anzeigen
//IntWrapperCount.h
#ifndef INTWRAPPERCOUNT_H
#define INTWRAPPERCOUNT_H
namespace IntWrapper
{
class IntWrapperCount
{
//Attributes
private:
unsigned int wrapperCount;
//Constructors & Destructors
public:
IntWrapperCount():
wrapperCount(0) {}
//Methods
public:
inline unsigned int GetWrapperCount() const { return wrapperCount; }
inline void IncreaseWrapperCount() { wrapperCount++; }
inline void DecreaseWrapperCount() { if(wrapperCount > 0) wrapperCount--; }
//Implementations
};
}
#endif
Alles anzeigen
main, halt die die vorgegeben war
//main.cpp
#include <iostream>
#include "IntWrapper.h"
using namespace std;
IntWrapper::IntWrapperCount IntWrapper::IntWrapper::intWrapperCount;
void main()
{
IntWrapper::IntWrapper x,y;
int i;
x+y,(i=IntWrapper::IntWrapper::GetIntWrapperCount());
cout<<i<<",";
x+y;
i=IntWrapper::IntWrapper::GetIntWrapperCount();
cout<<i<<endl;
}
Alles anzeigen
ergebnis mit copy constrkutor 3, 2
interpretation: najaa also dieser , operator... (ist es überhaupt ein operator) bewirkt halt dass x + y ausgeführt wird, dabei wird ein neues IntWrapper objekt erstellt, noch bevor es aber wieder gelöscht wird, wird i initialisiert, dahier ist i zuerst 3
beim zweiten mal wird einfach x+y; in einem schritt ausgeführt, neues objekt wird erstellt und gleich wieder verworden, dann wird i initialisiert, dahier ist i = 2
wenn man den copy construktor wegkommentiert kommt 1, 0 raus, sieht so aus als würde es also einen default copy constructor geben der einfach nichts macht (also auch nicht den count inkrementiert)
ich hätte eigentlich erwartet dass bei der ersten ausgabe eine 2 kommt, nach den beiden durch , getrennten operationen der count 1 ist und nach dem x + y; auf 0 fällt also dass die ausgabe 2, 0 ist
ich weiß ehrlich gesagt nicht wieso es 1, 0 ist.. wäre nett wenn das jemand erklären könnte
ich wollte zuerst eigentlich die linked list machen aber wie gesagt, ich weiß nicht wie das mit referenzen only gehen sollte (und mit pointern hatte ich keine lust, wollt was neues probieren weil ich vorher in c++ noch nie referenzen verwendet habe so richtig) wegen diesem next pointer, also, aus meinem 2t-vorherigen post
Zitat
hm... ich hab mir das grad so überlegt, man sollte ja keine pointer verwenden sondern referenzen, aber lässt sich das überhaupt mit referenzen lösen?
node muss ja ein next haben, wenn next vom typ Node& ist dann muss ich im default konstruktor von Node next einen wert geben
referenzen können in c++ nicht NULL sein, also muss ich ein new Node() darauf erstellen, das new Node muss wieder nen next haben etc etc, endlos rekursiver konstruktor
hab ich da nen denkfehler drin oder lässt sich ne linked list in c++ halt nur über pointer realisieren
wäre auch nett wenn jemand dazu auch was sagen könnte
