Programmieren Sie die Gehaltsabrechnung für einen Fußballverein. Dazu sollen
von einer Klasse Mitarbeiter die beiden Klassen Spieler und Trainer
abgeleitet werden.
Jedem Mitarbeiter wird eine Personalnummer vom Datentyp int zugeordnet.
Außerdem soll für jeden Mitarbeiter eine Methode void berechneGehalt() zur
Verfügung stehen.
Das Gehalt eines Spielers berechnet aus der Anzahl der geschossenen Tore
multipliziert mit 500 €. Die Tore sollen als Attribut des Spielers gespeichert
werden.
Das Gehalt des Trainers berechnet aus der Anzahl der geleisteten
Trainingsstunden (Datentyp int) multipliziert mit 20 €/h. Die Stunden sollen als
Attribut des Trainers gespeichert werden.
a) Zeichnen Sie das UML Klassendiagramm für die benötigten Klassen.
b) Programmieren Sie die Klassen und ein Hauptprogramm, dass mit
Hilfe dieser Klassen die im Testlauf wiedergegebene Ausgabe
erzeugt.
Hinweise, verbindlich:
- Es sind keine Konstruktoren oder Destruktoren erforderlich
- Die Eingabe von Personalnummer, Toren und Stunden ist im
Hauptprogramm zu realisieren.
- Die Berechnung und Ausgabe des Gehalts sind in der entsprechenden
Methode von Spieler und Trainer durchzuführen.
- Schreiben Sie ausschließlich in die vorbereiteten Rahmen!
- Ergänzen Sie alle fehlenden #include’s (Punktabzug für überflüssige!)

Testlauf (Eingaben unterstrichen):
Personalnummer des Spielers = ? 123456
Anzahl der Tore des Spielers 123456= ? 3
Personalnummer des Trainers = ? 987654
Anzahl der Trainingsstunden des Trainers 987654 = ? 50
Das Gehalt des Spielers mit der Nr. 123456 betraegt: 1500 Euro
Das Gehalt des Trainers mit der Nr. 987654 betraegt: 1000 Euro
Press any key to continue

Das main

#include "stdafx.h"
using namespace std;
#include "Spieler.h"
#include "Trainer.h"
#include "Mitarbeiter.h"

int main()
{
	Spieler Spieler;
	Trainer Trainer;

	cout << "Personalnummer des Spielers = ? ";
	cin >> Spieler.Personalnummer;
	cout << "Anzahl der Tore des Spielers " << Spieler.Personalnummer << " = ? ";
	cin >> Spieler.Tore;

	cout << "Personalnummer des Trainers = ? ";
	cin >> Trainer.Personalnummer;
	cout << "Anzahl der Trainingsstunden des Trainers " << Trainer.Personalnummer << " = ? ";
	cin >> Trainer.Trainingsstunden;

	//cout << "Das Gehalt des Spielers mit der Nr. " << Spieler.Personalnummer << " betraegt: " << /*Spieler.berechneGehalt() <<*/ endl;
	//cout << "Das Gehalt des Trainers mit der Nr. " << Trainer.Personalnummer << " betraegt: " << /*Trainer.berechneGehalt() <<*/ endl;
}

Mitarbeiter.h

#pragma once

class Mitarbeiter
{
public:
	int Personalnummer;
	void berechneGehalt();
};

Spieler.h

#pragma once
#include "Mitarbeiter.h"

class Spieler : public Mitarbeiter
{
public:
	int Tore;
};

Trainer.h

#pragma once
#include "Mitarbeiter.h"

class Trainer : public Mitarbeiter
{
public:
	int Trainingsstunden;
};

Mitarbeiter.cpp *hust* steht nicht viel drin ^^

#include "StdAfx.h"
#include ".\mitarbeiter.h"
#include "Spieler.h"

using namespace std;

void Mitarbeiter::berechneGehalt()
{

}

Ich schaffe trotz aller Fummelei nicht, die Berechnung in void Mitarbeiter::berechneGehalt() durchzuführen. Immer wenn ich versuche etwas zu übergeben dann meldet der compiler (VS 2003.net), dass ich es nicht richtig mache. Und ich weiß auch nicht wie ich der Methode klar machen soll, dass sie es grade mit Toren oder Arbeitsstunden zu tun hat, damit sie korrekt entweder mit 20 oder 500 multipliziert.

Hat hier jemand Mitleid mit einem kleinen Elektrotechniker der nicht wirklich viel Ahnung vom Programmieren hat? ^^

- Die Eingabe von Personalnummer, Toren und Stunden ist im
Hauptprogramm zu realisieren.

Hm, Aufrufe a lá "cin >> Spieler.Tore;" sind eigentlich schlecht, da dadurch das Prinzip der Datenkapselung verletzt wird. Benutze doch lieber stattdessen eine eigene Methode, die das dann natürlich private Atttribut "Tore" setzt. Dieser übergibst du dann ganz einfach die Anzahl der Tore über 'ne Variable, die die Benutzereingabe speichert. Das wäre die saubere Lösung. Rede mit deinem Kursleiter doch nochmal darüber. Dadurch lässt sich nämlich vieles vereinfachen: das Programm ist bspw. leichter erweiterbar oder andersweilig einsetzbar.

Außerdem solltest du die Klasse "Mitarbeiter" zu einer abstrakten Klasse machen. Abstrakt bedeutet in dem Zusammenhang, dass keine Objekte von dieser Klasse erzeugt werden können, was ja auch nicht erforderlich ist, da ein Mitarbeiter entweder ein Spieler oder ein Trainer ist. Die Mitarbeiter-Klasse fasst somit nur deren Eigenschaften und Methoden zur besseren Übersicht zusammen. Um die Klasse abstrakt werden zu lassen, muss mindestens eine rein virtuelle Methode vorhanden sein. Im Beispiel also berechneGehalt(). Virtuelle Methoden werden nach folgendem Schema deklariert: "virtual <Rückgabetyp> <Fkt.sname> () const = 0;". Es ist dabei noch möglich eine Standardimplementation hinzuzufügen, was in deinem Fall aber keinen Sinn macht, da das Gehalt nun mal unterschiedlich berechnet wird. Da lässt sich einfach nix abstrahieren.

So... jetzt wird auf unsere zwei Unterklassen vererbt, nämlich Spieler und Trainer. In diesen Klassen kannst du berechneGehalt() nun neu definieren. Die Funktion für den Trainerlohn multipliziert also den übergebenen Wert (der Stundenanzahl) mit dem Stundenlohn von 20€. Analoges gilt natürlich für die Funktion in der Spieler-Klasse. In der main()-Funktion musst dann wie du's auch schon gemacht hast, die zur jeweiligen Klassen passende Funktion aufrufen, wie bspw. "spieler.berechneGehalt();". (Benutze für die Objekte der Klassen lieber die Kleinschreibweise, wie mans auch bei Variablen der Grunddatentypen hält, also "spieler" statt "Spieler".)

- Die Berechnung und Ausgabe des Gehalts sind in der entsprechenden
Methode von Spieler und Trainer durchzuführen.

Hm, das passt nicht so ganz du deinen letzten zwei Zeilen in der main.cpp.
Du musst die Gehaltsfunktionen einen String zurückgeben lassen. Dafür musst du natürlich am besten in der Mitarbeiter-Klasse ein "#include <string>" einfügen. (Dieser include vererbt sich ja auf die beiden anderen Klassen weiter.)

Hoffe, ich konnte dich wieder ein bisschen motivieren und auf den richtigen Weg zurückbringen

~ moagnus

Da ich deine Ausführungen noch nicht ganz folgen konnte versuche ich mal die Aufgabenstellung so wiederzugeben wie ich sie verstanden habe. Vielleicht liege ich ja bereits da vollkommen falsch.

1. Ich lese im Hauptprogramm die Werte für den Spieler und den Trainer ein (gemacht)
2.1. Mitarbeiter enthält als Superklasse "int Personalnummer" und "void berechneGehalt()", auf die die beiden Subklassen zugreifen können (gemacht)
2.2. Spieler enthält "int Tore" (gemacht)
2.3. Trainer enthält "int Arbeitsstunden" (gemacht)
3. Spieler und Trainer greifen auf "berechneGehalt()" zu ihr ... naja ihr gehalt zu berechnen (verzweifelt versucht)

Und genau das ist der knackpunkt bei mir. Ich verstehe das so, dass keine weiteren Methoden in Spieler und Trainer eingefügt werden sollen. Ich habe keinen blassen schimmer davon wie ich der Methode "berechneGehalt()" begreifbar machen soll, dass gerade Spieler auf sie zugreift und sie damit mit 500 multiplizieren sollen.

Ich hatte schonmal eine ähnliche Aufgabe. Dort gab es die Klassen Kreis und Rechteck die auf die Superklasse Fläche zugreifen sollten.
Die Subklasse Kreis beinhaltete "int Radius" und Rechteck "int a, b" je nachdem wer zugriff sollten dann die Methode in Fläche erkennen ob es ein Kreis ist (und damit radius*3.14 rechnen) oder ein rechteck (dann eben a*b).

Kurzum: wie gebe ich den Methoden in Superklassen zu verstehe wer sie grade benutzt?

Vieleicht hast du es schon beantwortet, dann habe ich es aber nicht so richtig verstanden ^^

Es steht ja geschrieben:

- Die Berechnung und Ausgabe des Gehalts sind in der entsprechenden
Methode von Spieler und Trainer durchzuführen.

Das soll wohl bedeuten, dass ich doch Methoden für Spieler und Trainer schreiben soll.

Welchen Sinn ergibt denn dann noch die Methode berechneGehalt(); in Mitarbeiter?

----------------------------------------------------------------------------------------------------

Um nochmal auf diese andere Aufgabe einzugehen:

*Schreiben Sie ein C++Programm zur Erfassung von Geometrie-Elementen. Dazu
sollen die Klassen kreis und rechteck von der Basisklasse flaeche abgeleitet
werden.

Allen Klassen sind die Eigenschaft flaecheninhalt und die Methode
flaecheninhalt_berechnen() gemeinsam. Darüber hinaus soll die Klasse kreis
das Attribut radius erhalten, während die Klasse rechteck als Attribute die
Seitenlängen a und b erhält.

Der Konstruktor der Basisklasse soll den Text „Neues Flaechenelement “
ausgeben (vgl. Testlauf). Die abgeleiteten Klassen sollen über ihren Konstruktor
die Bezeichnung der Klasse ausgeben und die Werte ihrer jeweiligen Attribute
von der Tastatur einlesen.

Die Methode flaecheninhalt_berechnen() soll den Flächeninhalt nach
folgenden Formeln berechnen und in dem Attribut flaecheninhalt speichern:

Kreis: f = r * r *3.14
Rechteck: f = a * b

a) (3 Punkte) Zeichnen Sie das UML Klassendiagramm.
b) (14 Punkte) Programmieren Sie die Klassen und ein Hauptprogramm, dass
mit Hilfe dieser Klassen die im Testlauf wiedergegebene Ausgabe erzeugt.

Hinweise, verbindlich:
- Es sind keine Destruktoren erforderlich
- Alle Attribute sind vom Typ double.
- Ergänzen Sie alle fehlenden #include Direktiven (Punktabzug für
überflüssige!)
- Schreiben Sie ausschließlich in die vorbereiteten Rahmen!

Testlauf (Eingaben unterstrichen):
Neues Flaechenelement Kreis:
Radius = ? 1
Flaecheninhalt = 3.14
Neues Flaechenelement Rechteck:
a = ? 2
b = ? 3
Flaecheninhalt = 6
Press any key to continue*

Ich habe nochmal fett unterlegt worauf es mir ankommt. Es soll ja ganz offensichtlich ausschließlich in dieser Methode gerechnet werden. Bisher bin ich soweit gekommen:

#include "stdafx.h"
#include ".\flaeche.h"

using namespace std;

void flaeche::flaecheninhalt_berechnen()
{

}

flaeche::flaeche()
{
	cout << "Neues Flaechenelement ";
}

#pragma once

class flaeche
{
public:
	double flaecheninhalt;
	void flaecheninhalt_berechnen();
	flaeche();
};

#include "stdafx.h"
#include ".\kreis.h"

using namespace std;

kreis::kreis()
{
	cout << "Kreis:" << endl;
	cout << "Radius = ? " << endl;
	cin >> radius;
}

#pragma once
#include "flaeche.h"

class kreis : public flaeche
{
public:
	double radius;
	kreis();
};

#include "stdafx.h"
#include ".\rechteck.h"

using namespace std;

rechteck::rechteck()
{
	cout << "Rechteck:" << endl;
	cout << "a = ? ";
	cin >> a;
	cout << "b = ? ";
	cin >> b;
}

#pragma once
#include "flaeche.h"

class rechteck : public flaeche
{
public:
	double a;
	double b;
	rechteck();
};

Hier geht es um die flaeche.cpp. Ich soll dieser Klasse Werte übergeben, er soll entscheiden ob Kreis oder Rechteck und dann soll ich den Wert in Flaecheninhalt zurückgeben. Leider keine Ahnung wie man das macht ^^

- Die Berechnung und Ausgabe des Gehalts sind in der entsprechenden
Methode von Spieler und Trainer durchzuführen.

Naja, das sagt dir ja schon mal, dass du nicht die Gehalts-Funkion der Oberklasse aufrufen darfst.

zu 1) Ist zwar unschön, aber ok. Passt ja, da deine Attribute public sind.
zu 2.x) Jopp, passt.
zu 3) Hm, das ist vllt. wirklich ein bisschen schwierig zu kapieren. Ich schreib's dir mal meinen Vorstellungen entsprechend um:

#include <iostream> // für std::cout in der Gehalts-Funktion

class Mitarbeiter // abstrakte Klasse; Erstellung von Objekte nicht möglich/notwendig
{
public:
    int Personalnummer;
    virtual void berechneGehalt() = 0; // rein virtuelle Methode durch Zusatz von "=0" deklarieren; Standardimplementation nicht sinnvoll
};

class Spieler : public Mitarbeiter
{
public:
    int Tore;
    virtual void berechneGehalt() { // virtuelle Funktionen haben immer die gleiche Signatur, nur der Funktionskörper kann sich unterscheiden
         std::cout << Tore*500 << "€" << std::endl; // direkte Ausgabe innerhalb der Methode wie verlangt
    } // normalerweise wird Implementation und Deklaration getrennt; zu faul ;)
};

class Trainer : public Mitarbeiter
{
public:
    int Trainingsstunden;
    virtual void berechneGehalt() {
         std::cout << Trainingsstunden*500 << "€" << std::endl; // Attribute besser klein schreiben
    }
};

int main() {
Spieler spieler;
std::cin >> spieler.Tore; // 2 Tore
spieler.berechneGehalt(); // Ausgabe: 2 Tore * 500€ = 1000€
}

Kompiliert und arbeitet ohne Probleme.

Du musst die Gehaltsfunktionen einen String zurückgeben lassen. Dafür musst du natürlich am besten in der Mitarbeiter-Klasse ein "#include <string>" einfügen. (Dieser include vererbt sich ja auf die beiden anderen Klassen weiter.)

Das war natürlich vollkommener Krampf... Keine Ahnung, was ich mir dabei gedacht hab. Genau das soll man ja nicht machen...
Und virtuelle Funktionen müssen auch kein "const" am Ende haben. Sorry...

EDIT: Ähm, ich bin jetzt zu faul, deinen letzten Post durchzulesen, aber das Problem sollte sich auch mit einer abstrakten Basisklasse und rein virtuellen Funktionen lösen lassen.
Um deine Frage nach dem Sinn der Gehalts-Funktion in der Basisklasse zu beantworten: Durch rein virtuelle Funktionen wird es möglich, gemeinsame Eigenschaften eventuell schon vorher in ner Standardimplementation zusammenzufassen.

Außerdem soll für jeden Mitarbeiter eine Methode void berechneGehalt() zur
Verfügung stehen.

Hier wirds ja sogar explizit gefordert. Jeder Mitarbeiter (Objekt der Klasse Mitarbeiter) soll diese Funktion aufweisen.

Hier ists eigentlich sinnlos... um es halbwegs verständlich zu machen: Ich kann in der Standardimplementation beispielsweise noch hinschreiben, dass vor der Gehaltsausgabe "Gehalt: " auf den Bildschirm geschrieben wird. Das machts aber alles noch ein wenig komplizierter.

Übrigens: Wenn man virtuelle Funktionen verwendet sollte man auch virtuelle Destruktoren definieren. Ansonsten kann es zur Speicherverschwendung kommen (aber auch nur in speziellen Fällen, hier nicht). Inwieweit das deinem Lehrer egal ist, weiß ich nicht...

Vielen lieben dank schonmal

Ich melde mich morgen wieder

Naja, ich hatte nix zu tun und da hab ich mich mal an deine Aufgabe gemacht...

#include <iostream>
#include <cmath> // für M_PI bei Flächenfunktion vom Kreis
using namespace std;

class GraphObj { // Flaeche als Klassenname war mir zu sinnlos :P
	protected: // protected, damit von abgeleiteten Klassen darauf zugegriffen werden kann
		double flaecheninhalt;
	public:
		GraphObj();
		virtual void flaecheninhaltBerechnen(void) = 0;
};

 GraphObj::GraphObj() {
	cout<<"Neues geometrisches Objekt: ";
}
// Standardimplementation der rein virtuellen Methode
inline void GraphObj::flaecheninhaltBerechnen(void) {
	cout<<endl<<"Flaeche A";
}
// *******************************************
class Kreis : public GraphObj {
		double radius;
	public:
		Kreis(double);
		virtual void flaecheninhaltBerechnen(void);
};

Kreis::Kreis(double rad) : radius(rad) {
	cout<<"Kreis"<<endl;
}
inline void Kreis::flaecheninhaltBerechnen(void) {
	GraphObj::flaecheninhaltBerechnen(); // gibt "Flaeche A" aus
	cout<<"(Kreis) = ";
	double f = radius*radius*M_PI;
	flaecheninhalt = f; // im Attribut des Subobjekts speichern für eventuelle spätere Verwendung
	cout<<f<<endl; // und gleichzeitig ausgeben
}

// *******************************************
class Rechteck : public GraphObj {
		double laenge, breite;
	public:
		Rechteck(double, double);
		virtual void flaecheninhaltBerechnen(void);
};

Rechteck::Rechteck(double l, double b) : laenge(l), breite(b) {
	cout<<"Rechteck"<<endl;
}
inline void Rechteck::flaecheninhaltBerechnen(void) {
	GraphObj::flaecheninhaltBerechnen();
	cout<<"(Rechteck) = ";
	double f = static_cast<double>(laenge*breite);
	flaecheninhalt = f;
	cout<<f<<endl;
}

int main() {
	cout<<"\nRechteck: Bitte Laenge und Breite eingeben. (Komma als Punkt)"<<endl;
	double l, b;
	cin>>l;
	cin>>b;
	Rechteck rechteck(l, b);

	cout<<"\nKreis: Bitte Radius angeben. (Komma als Punkt)"<<endl;
	double r;
	cin>>r;
	Kreis kreis(r);

	rechteck.flaecheninhaltBerechnen();
	kreis.flaecheninhaltBerechnen();

	cout<<"<Enter> zum Beenden druecken."<<endl;
	// Tastaturpuffer leeren, damit Programm nicht automatisch beendet wird durch Reste im Puffer
	while(cin.get() != '\n') {cin.clear();}
	cin.get();
}

Code funktioniert einwandfrei, jedoch hab einige "verbindliche Hinweise" großzügig missachtet und ansonsten auch nur meinen eigenen Kopf durchgesetzt

Auswertung:
a) fehlt
b)
* 14 Punkte für fehlerfreie Kompilation ohne Warnungen
* -3 Punkte wegen "überflüssiger" include-Anweisung von cmath
* -3 Punkte wegen modifiziertem Testablauf mit direkter Instanziierung der Klassenobjekte
* -7 Punkte wegen Unvollständigkeit nach 20 Minuten

= 1/17 Punkten (Test bestanden?)

Eine Frage hab ich aber noch (ist vllt. etwas kleinkrämerisch, aber mir ist keine Lösung für dieses "Problem" eingefallen):
Wenn ich ganz sauber bleiben will, muss ich die rein virt. Funktion in der Oberklasse ja mit dem "const"-Zusatz versehen, weil nur eine Ausgabe getätigt wird, jedoch keine Veränderungen vorgenommen werden. Wenn ich nun ableite auf die beiden anderen Klassen muss die Signatur dieser Funktion gleich bleiben, damit sie überschrieben werden kann. In den Unterklassen jedoch wird dem Subobjekt-Attribut der Flächeninhalt zugewiesen. Die Methode kann also nicht "const" deklariert werden. Wie kann man sich da behelfen? Es ist ja auch nicht möglich, in der Basisklasse zwei Verschiedene (eine mit "const", eine ohne) zu deklarieren, da in den abgeleiteten Klassen dann nicht ersichtlich ist, welche aufgerufen wird, da das "const" hier nicht zum Funktionsaufruf hinzugefügt werden kann.
Fällt jemanden dazu was ein bzw. ... ist das überhaupt vertretbar?