dwhassom

hallo Panke,

so weit bin Ich, sag mir ob dass schon gut aussieht bitte!

Dave

vielen Dank...

Bis bald

Ich weisse nicht wie Ich das anfangen kann.

Wenn du mir die code gibst, versuche Ich es weiter zu machen

Danke für deine Antwort!

Dave

Hallo, ich brauche Hilfe für das Programm bitte!

Danke im voraus

Dave

Ein Programm Schreiben zur Verwaltung von Klausurobjekten.

Der Aufbau des Programms bestehe aus

- der Deklaration einer Klasse Klausur in einer Header-Datei, Klausur.h

- der Definition der unten angegebenen Klassen- und Objektelementen in einer

Implementierungsdatei Klausur.cpp sowie

- einem Verwaltungsprogramm in der Datei, KlausurAdmin.cpp, das Klausur.h inkludiert und Klausur.cpp benutzt.

Die Attribute eines jeden Klausurobjekts seien: Vorname, Nachname, Matrikelnummer sowie erzielbare

und erzielte Punkte. Eingegebene Klausurdaten können auf dem Bildschirm ausgegeben werden.

Zusätzlich soll jede Klausur eine eigene Nummer aufweisen, die automatisch berechnet wird und die

tatsächliche Nummer der Klausur in der Reihenfolge der Eingabe wiedergibt.

Die Attribute sollen über einen Konstruktor initialisiert werden, der demnach vier formale Parameter

aufweisen soll.

Unmittelbar nach Erzeugung des jeweiligen Klausurobjekts sollen aus dem Rumpf des Konstruktors die

laufende Nummer der Klausur sowie die Initialisierungswerte ihrer anwendungslogischen Attribute auf

dem Bildschirm ausgegeben werden.

Die Klasse Klausur kapselt ein Klassenattribut int klausurZ in dem zu jedem Zeitpunkt die Anzahl

der bis dahin eingegebenen Klausuren verwaltet wird.

Zum inkrementieren dieses Klassenattributs sei eine

private Funktion void increKlausuren() bereitgestellt.

Zum Auslesen des Werts des Attributs sein eine public-Funktion int getKlausurZ()

bereitgestellt.

Zur Ermittlung der Note stellen Klausurobjekte eine public-Funktion double getNote()

öffentlich bereit.

Zur Berechnung der Note kapseln Klausurobjekte außerdem eine

private-Funktion double berechneNote(), die auf der Basis der erzielten und erzielbaren

Punktzahl eines jeden Klausurobjekts ermittelt wird.

Außerdem soll jede Klausur eine öffentliche Funktion public void zeigAtte() aufweisen, die

zur Ausgabe sämtlicher Attributwerte eines jeden Klausurobjekts auf dem Bildschirm benutzt wird.

Das Programm soll die Eingabe von 5 Klausuren erlauben, die Sie entweder über 5 Objektvariablen oder

in einer geeigneten Objekt-Sammlungsstruktur (Collection, wie array, vector etc.) verwalten. Die

Maximalzahl kann selbstverständlich durch eine Zahl > 5 verändert werden, wozu eine geeignete

Datenstruktur gewählt werden muss.

Es muss mindestens eine Klausur, es können aber durchaus weniger als 5 Klausuren eingegeben werden.

Sofern versucht wird mehr als 5 (Maximalzahl von Klausuren) einzugeben, soll eine Meldung auf dem

Bildschirm erscheinen, eine Eingabe weiterer Attributwerte unterbleiben, die Ausführung des Programms

jedoch fortgesetzt werden.

Die Durchschnittsnote der erzielten Klausurergebnisse soll berechnet und ausgegeben werden. Sie ergibt

sich aus der Division der aufaddierten Noten der einzelnen Klausuren durch die Anzahl der eingegebenen

Klausuren.

Zum Kontrollfluss.

Der Benutzer kann solange Klausuren eingeben, bis er Q/q für Ende eingibt.

Ist die Eingabe beendet werden hintereinander weg

- die Attributwerte jeder eingegebenen Klausur ausgegeben

- die Anzahl der eingegebenen Klausuren sowie

- die ermittelte Durchschnittsnote über alle Klausuren.

Hallo, helfen Sie mir dieses Programm zum schreiben. Ich bin noch nicht fertig aber es gibt ein Fehler an diese Stelle (:confused:)

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) {

(:confused:) 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;

}