#include <iostream>
using namespace std;

class Temperatur
{
    private:
        double celsius;
        double fahrenheit;
    public:
        double leseC(void) { return celsius; }
        double leseF(void) { return fahrenheit; }
        void speicherC(void);
        void speicherF(void);
};

void Temperatur::speicherC(void)
{
    cout << "\nBitte Celsius eingeben: ";
    cin >> celsius;
    fahrenheit = 9.0 / 5.0 * celsius + 32.0;
}

void Temperatur::speicherF(void)
{
    cout << "\nBitte Fahrenheit eingeben: ";
    cin >> fahrenheit;
    fahrenheit = 5.0 / 9.0 * (fahrenheit - 32.0);
}   

int main()
{
    Temperatur templ;
    temp1.speicherC();
    cout << "\nWert in Celsius   : " << temp1.leseC();
    cout << "\nWert in Fahrenheit: " << temp1.leseF();

    fflush(stdin); cin.peek();
    return 0;
}

Und ich versteh da einige Sachen nicht dran...
wieso steht da als Parameter void, wenn man celsius oder fahrenheit übergeben muss?

und was heißt private? man kann die variablen mit ihren werten doch sowieso ändern...

und die speicherfunktionen geben auch was zurück und haben auch void wieso??

außerdem wird speicherF gar nicht aufgerufen in main oder sonst wo, aber wenn man das programm laufen lässt, dann wird es ausgeführt... versteh icht...

helft mir mal bitte!!
danke!

Kommen wir gleich zum Begriff private: Der legt fest, dass auf die Daten in diesem Bereich nicht außerhalb der Klasse zugegriffen werden kann. Variablen sollten in der Regel immer in diesem Bereich liegen, bei Klassen empfiehlt es sich über Methoden auf die Daten zuzugreifen (private ist auch der Standardbereich). Unter public stehen die Elemente, auf die auch auch von außerhalb zugegriffen werden kann. Hier deklariert man normalerweise die Methoden, mit denen man passiv auf die gespeicherten Werte zugreift. Definiert werden sie bei diesem Programm teilweise weiter unten.

Nur leseC() und leseF() haben einen Rückgabewert. speicherF() und speicherC() nehmen direkt eine Benutzereingabe entgegen und speichern den eingelesenen Wert in der Klasse ab. speicherF wird nicht aufgerufen - könnte aber aufgerufen werden. Das Programm fragt schließlich aber Grad Celsius ab.

Hier der Programmablauf:

int main()
{
    Temperatur templ;   // Klasseninstanz wird angelegt
    temp1.speicherC();  // speicherC wird aufgerufen, -> Benutzerabfrage
    cout << "\nWert in Celsius   : " << temp1.leseC(); // leseC() liefert Grad Celsius zurück
    cout << "\nWert in Fahrenheit: " << temp1.leseF(); // leseF() liefert Grad Fahrenheit zurück

    fflush(stdin); cin.peek(); // "Aufräumen"
    return 0;                  // main() gibt 0 zurück, Programm erfolgreich beendet
}

hab aber noch ein paar kleine Fragen

Da die 2 Variablen private ist, können nur die Methoden auf sie zugreifen und sie ändern, ja? Aber wenn ich jetzt in main was ändern wollen würde, indem ic celsius = andererwert schreiben würde, ginge das nicht?

Ja und das mit den Void versteh ich immernoch nicht ganz...
ist das jetzt so, dass wenn die Methoden auf die Variablen zugreifen, sie dann automatisch als Parameter haben?

und nur eins noch, dann ist mir alles klar
Wenn das Programm gestartet wird und ich zum Beispiel 100 eingebe für Celsius, dann kommt folgende Ausgabe:
Wert in Celsius: 100
Wert in Fahrenheit: 212
das heißt, dass die funktion speicherF ausgeführt wird, ohne dass sie irgendwo aufgerufen wird. das versteh ich gar nicht...

Tschöö!

Wenn das Programm gestartet wird und ich zum Beispiel 100 eingebe für Celsius, dann kommt folgende Ausgabe:
Wert in Celsius: 100
Wert in Fahrenheit: 212
das heißt, dass die funktion speicherF ausgeführt wird, ohne dass sie irgendwo aufgerufen wird. das versteh ich gar nicht...

Ne die wird nirgends aufgerufen aber sieh dir speicherC mal genau an

void Temperatur::speicherC(void)
{
    cout << "\nBitte Celsius eingeben: ";
    cin >> celsius;                           // celsius wird gelesen
    fahrenheit = 9.0 / 5.0 * celsius + 32.0;  // und nach fahrenheit umgerechnet
}

Übrigens die funktion speicherF ist falsch. Sollte so sein

void Temperatur::speicherF(void)
{
    cout << "\nBitte Fahrenheit eingeben: ";
    cin >> fahrenheit;                        // fahrenheit wird gelesen
//    fahrenheit = 5.0 / 9.0 * (fahrenheit - 32.0); // falsch
    celsius = 5.0 / 9.0 * (fahrenheit - 32.0); // und nach celsius umgerechnet
}

Kurt

Da bleibt nur noch:

Da die 2 Variablen private ist, können nur die Methoden auf sie zugreifen und sie ändern, ja? Aber wenn ich jetzt in main was ändern wollen würde, indem ic celsius = andererwert schreiben würde, ginge das nicht?

Ja und das mit den Void versteh ich immernoch nicht ganz...
ist das jetzt so, dass wenn die Methoden auf die Variablen zugreifen, sie dann automatisch als Parameter haben?

Da die 2 Variablen private ist, können nur die Methoden auf sie zugreifen und sie ändern, ja? Aber wenn ich jetzt in main was ändern wollen würde, indem ic celsius = andererwert schreiben würde, ginge das nicht?

nee das ginge nicht. Wenn du von aussen auf die membervariablen zugreifen können willst dann müsstest du der klasse setter-funktionen spendieren. z.b

void Temperatur::setzeC(double c )
{
    celsius = c;                              // celsius setzen
    fahrenheit = 9.0 / 5.0 * celsius + 32.0;  // und nach fahrenheit umgerechnet
}

natürlich könntest du die beiden membervariablen auch public declarieren. Das wäre in diesm Fall aber sehr schlecht da dann nicht mehr gewährleistet wäre das celsius und fahrenheit die gleiche temperatur darstellen.

Ania87 schrieb:

Ja und das mit den Void versteh ich immernoch nicht ganz...
ist das jetzt so, dass wenn die Methoden auf die Variablen zugreifen, sie dann automatisch als Parameter haben?

Das void bedeutet nur dass du die funktionen nur ohne parameter aufrufen darfst ( glaube ich auf jeden fall, hab das aber noch nicht oft gesehen dass das überhaupt gemacht wird ). Normalerweise würde ich das void weglassen.
Kurt

Lieb von euch!!