Programm
Vereinbaren Sie bitte eine Klasse namens KlasseA und vereinbaren Sie darin die
folgenden Elemente:
1. Ein privates Objektatrribut namens zahl vom Typ int.
2. Ein privates Klassenattribut namens anz vom Typ int.
3. Einen öffentlichen Standardkonstruktor, der das Attribut zahl mit 17 initialisiert und anz
um 1 erhöht.
4. Einen öffentlichen Allgemeinkonstruktor mit einem int-Parameter, der das Attribut zahl
mit seinem Parameter initialisiert und anz um 1 erhöht.
5. Einen öffentlichen Allgemeinkonstruktor mit einem string-Parameter s, der s mit atoi in
einen int-Wert umwandelt, mit dem Ergebnis das Attribut zahl initialisiert und ausserdem
anz um 1 erhöht.
6. Einen öffentlichen Kopierkonstruktor, der das neue Objekt mit demdoppelten Wert des zahl-
Attributs des alten Objekts initialisert und anz um 1 erhöht.
7. Einen öffentlichen Destruktor, der anz um 1 vermindert.
8. Eine öffentliche Objektfunktion namens getZahl, die 0 Parameter hat und den Wert des
Attributs zahl liefert.
9. Eine öffentliche Klassenfunktion namens getAnz, die 0 Parameter hat und den Wert des
Attributs anz liefert.
A4.2 Vereinbaren Sie bitte in derselben Quelldatei eine int main()-Funktion, deren Ausführung

die folgende Ausgabe auf dem Bildschirm erzeugt.
Ausgabe des Programms KlasseA:
KlasseA: Jetzt geht es los!
-----------------------------------
STANDARDkonstruktor, zahl: 17
ALLGEMEINkonstruktor 1, zahl: 23
ALLGEMEINkonstruktor 2, zahl: 10
KOPIERkonstruktor, zahl: 20
-----------------------------------
a1.getZahl() : 17
a2.getZahl() : 23
a3.getZahl() : 10
a4.getZahl() : 20
KlasseA::getAnz(): 4
-----------------------------------
ALLGEMEINkonstruktor 1, zahl: 15
ALLGEMEINkonstruktor 1, zahl: 30
-----------------------------------
a1.getZahl() : 15
a2.getZahl() : 30
-----------------------------------
KlasseA::getAnz(): 6
-----------------------------------
KlasseA::getAnz(): 4
-----------------------------------
KlasseA: Das war's!

was Ich geschrieben habe:

//Datei KlasseA.cpp
#include<string>
#include<iostream>

using namespace std;

//Definition der KlasseA
class KlasseA {
private: //Eigenschaften sind private und damit
// gegen den direkten Zugriff geschuetzt
int zahl;
int anz;

public: //Klassenelemente (Memberfunktionen) müssen public sein sonst
// kann mit der Klasse nicht gearbeitet werden

KlasseA(); //Standardkonstruktor (K1)
KlasseA(int zahl, int anz); //Allgemeinerkonstruktor (K2)
KlasseA(string * s); //Allgemeinerkonstruktor (K3)
KlasseA(KlasseA const & a); //Kopier-Konstruktor (K4)
~KlasseA(); //Destruktor (D)

public: //Objectelemente
string getString(); //get-Methode
void setString(string s); //set-Methode

//Zuweisungs-Operator (=)
KlasseA const & operator = (KlasseA const & zahl);

//Inkrementierungs-Operator (++)
bool operator == (KlasseA const & anz);

private: //Objektelemente sind private und damit
// gegen den direkten Zugriff geschuetzt
string * atoi; //Attribut

//Freunde
//Ausgabeoperator
friend ostream & operator << (ostream & os, KlasseA const & a);
}; //KlasseA

//Definition der Methoden der KlasseA

//StandardKonstruktor (K1)
KlasseA::KlasseA() {
zahl = 17; //zahl initialisiert
anz = anz++; //anz inkrementiert
atoi = new string(" ");
cout <<"K1:" << atoi << endl;
}

//Allgemeinerkonstrucktor (K2)
KlasseA::KlasseA(int zahl, int anz) {
atoi = new string(zahl, anz);
cout <<"k2:" << atoi <<endl;
}

//Allgemeinerkonstruktor (K3)
KlasseA::KlasseA(string * s) {
( ) atoi = new string(s);
cout <<"K3:" << atoi << endl;
}

//Kopier-konstruktor (K4)
KlasseA::KlasseA(KlasseA const & a) {
atoi = new string(*t.atoi);
cout <<"K4:" << atoi << endl;
}
//Destruktor (D)
KlasseA::~KlasseA() {
cout <<"D:" << atoi << endl;
delete atoi;
}
string KlasseA::getString() //get-Methode
return *atoi;
} //getString

void KlasseA::setString(string s) { //set-Methode
*atoi = s;
} //setString

KlasseA const &
KlasseA::operator = KlasseA const & zahl) { //Zuweisungs-Operator(=)
*this->atoi = *zahl.atoi;
return zahl;
} //Operator (=)

bool KlasseA::operator ++ (KlasseA const & anz) { //Inkremntierungs-operator (++)
return *atoi ++ *anz.atoi;
} //Operator (++)

//AusgabeOperator <<
ostream & operator << (ostream & os, KlasseA const & a) {
os << *a.atoi;
return os;
} //Operator <<

//Eine speicherhungrige Prozedur
void machWas() {
KlasseA a1(10*1000*1000, '!'); //10 MB gefüllt mit Ausrufezeichen
cout << '.' << flush; //Ein Punkt '.' wird sofort ausgegeben
} //machWas
/----------------------------------------------------------
//int main() {
cout <<"KlasseA: Jetzt geht's los!" << endl;
Cout <<"STANDARDkonstruktor, zahl:" << endl;
cout <<"ALLGEMEINERkonstruktor 1, zahl:" << endl;
cout <<"ALLGEMEINERkonstruktor 2, zahl:" << endl;
cout <<"KOPIERkonstruktor, zahl:" << endl;

KlasseA a1("zahl:");
KlasseA a2("zahl:");
KlasseA a3("zahl:");
KlasseA a4("zahl:");

cout <<"a1.getZahl():" << a1.getZahl() << endl;
cout <<"a2.getzahl():" << a2.getzahl() << endl;
cout <<"a3.getzahl():" << a2.getZahl() << endl;
cout <<"a4.getZahl():" << a2;getZahl() << endl;
cout <<"KlasseA::getAnz():" << endl;

cout <<"KlasseA : Das war's!" << endl;
}

- atoi ist eine Funktion in <cstdlib>, die du benutzen sollst.
- Du brauchst keinen einzigen Zeiger.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

edit:
Und achja. Bitte benutzt das nächste mal einen besseren Titel. Es geht hier allem um C++..