Schleife

Firefighter

Weil bei der nächsten Berechnung die Temperatur sonst unter 21° fallen würde, und das wolltest du ja nicht, zumindest habe ich das so verstanden. Von 90° bis 21°

@Firefighter: Formel falsch, setzen, 6. Außerdem ist 21°C die Umgebungstemperatur, nicht die Endtemperatur.

Äh, also eigentlich sollte das hier eher den Anforderungen entsprechen (Kopfgesteuert, 10 Min. Betrachtungszeitraum, Berechnung jede Minute):

double dWasserTemp, dUmgebTemp;
int iMinuten, iMinutenMax;

iMinuten = 10;
iMinutenMax = iMinuten;
dWasserTemp = 90.0;
dUmgebTemp = 21.0;
while (iMinuten >= 0)
{
	cout<<"Temp nach "<<iMinuten<<" Min.: "<<DWasserTemp<<endl;
	dWasserTemp -= (dWasserTemp - dUmgebTemp) / 10;
	--iMinuten;
}

Was ist denn nun die Aufgabenstellung? Die ist nicht klar ersichtlich, respektive teilweise widersprüchlich....

Ein Topf Wasser kühlt pro minute um 10% seiner differenz aus Wassertemperatur und Umgebungstemperatur ab. Es soll die Temperatur des Wassers nach jeder Minute angegeben werden, wenn man als Anfangstemperatur 90 °C annimmt. Die Umgebungstemperatur liegt in der Regel bei 21 °C.

Über welchen Zeitraum? 10 Minuten? Respektive, was ist die Abbruchbedingung?
War da nicht noch was mit Kopf- oder Fußgesteuerter Schleife?
Sollte nicht die Berechnung in eine Funktion ausgelagert werden?

Firefighter

@Joe_M. wie gemein :), Naja wusste ebend nicht genau was er wollte und habe dann versucht aus seinen Fetzen was zusammenzubauen.

Ja, so bin ich eben. Ist möglicherweise ein Spätschaden von zu viel Alf...

wandrer

huhu schrieb:

Ich soll mit einer Kopfgesteurten Schleife die Temperatur bis zu 10 min ausgeben.
(...)
Dafür soll eine Fußgesteuerte Schleife verwendet werden.
(...)
Ein Topf Wasser kühlt pro minute um 10% seiner differenz aus Wassertemperatur und Umgebungstemperatur ab. Es soll die Temperatur des Wassers nach jeder Minute angegeben werden,
wenn man als Anfangstemperatur 90 °C annimmt. Die Umgebungstemperatur liegt in der Regel bei 21 °C.
(...)
Die Verarbeitungsphase der Daten soll in ein Unterprogramm ausgelagert werden.

#include <iostream>
#include <vector>

using namespace std;

void berechne_temperatur( double sup, double um, vector<double>& erg, int min )
{
	int i = 0;
	erg.resize(min);
	do
	{
		sup -= ( sup - um ) * 0.1;
		erg[i] = sup;
		++i;

	} while( i < min );
}

void zeige_werte( vector<double> const& erg )
{
	int min = erg.size();
	int i = 0;
	while( i < min )
	{
		cout << endl << (i + 1) <<" min:\t" << erg[i] << " C;";
		++i;
	}
	cout << endl; 
}

int main( int, char** )
{
	double um, sup;
	int min;
	vector<double> erg;

	cout<<"Wassertemperatur: ";
	cin>>sup;

	cout<<"Umgebungstemperatur: ";
	cin>>um;

	cout<<"Minuten: ";
	cin>>min;

	berechne_temperatur(sup,um,erg,min);
	zeige_werte(erg);

	system("PAUSE");
	return 0;
}

Fuß- und Kopfgesteuert.

Ausgelagert

restliches Zeugs

als Klasse verpackt

Ja, so kann man das machen. Ich hätte nur noch die Anfangstemperatur des Wassers mit in den Ergebnisvektor genommen.

Was heissen den diese Vector Sachen hab sowas noch nie gesehen

Werner Salomon

Das ist ja ein lustiger Thread hier .
Und da wäre mein Beitrag zur Verwirrung des Fragestellers:

#include <iomanip>
#include <iostream>

struct TopfWasser  // der Typ 'ein Topf mit Wasser'
{
    TopfWasser()
        : m_time_cnt( 0 )
        , m_temp_wasser()
        , m_temp_umgebung()
        , m_dtemp_dt()
    {}
    TopfWasser& operator++()    // Übergang zum nächsten Zeitpunkt; zur nächsten Minute
    {
        m_temp_wasser -= (m_temp_wasser - m_temp_umgebung) * m_dtemp_dt;
        ++m_time_cnt;
        return *this;
    }

    // --  Topf Einlesen
    static const char* Format() // das Eingabeformat; siehe operator>>
    { 
        return "'Wassertemperatur Umgebungstemperatur Angleichung-pro-Minute[%]'";
    }
    friend std::istream& operator>>( std::istream& in, TopfWasser& x )
    {
        double dtemp_dt_prz;
        if( in >> x.m_temp_wasser >> x.m_temp_umgebung >> dtemp_dt_prz )
        {
            x.m_time_cnt = 0;
            x.m_dtemp_dt = dtemp_dt_prz / 100;
        }
        return in;
    }

    // --  Topf ausgeben
    friend std::ostream& operator<<( std::ostream& out, const TopfWasser& x )
    {
        using namespace std;
        return out << setw(3) << x.m_time_cnt << " min  "
            << setw(6) << fixed << setprecision(1) << x.m_temp_wasser << " Grad";
    }

    int zeit() const { return m_time_cnt; }

private:
    int m_time_cnt;
    double m_temp_wasser;
    double m_temp_umgebung;
    double m_dtemp_dt;
};

int main()
{
    using namespace std;
    cout << "Geben Sie die Daten fuer den Temperaturverlauf im Format:" << endl;
    cout << TopfWasser::Format() << " ein" << endl;
    TopfWasser topf;
    int bis;
    if( cin >> topf && (cout << "Wieviele Minuten? \n", cin >> bis))
    {
        for( ; topf.zeit() <= bis; ++topf )
            cout << topf << endl;
    }
    return 0;
}

als Klasse verpackt

hiho schrieb:

Was heissen den diese Vector Sachen hab sowas noch nie gesehen

Guckst Du hier

Gruß
Werner

wandrer

Der vector ist die schönere Form vom array { double erg[10]; }.
ich hab das array/ den vector benutzt, um die Temperaturwerte zwischenzuspeichern, da du
1. die Verarbeitung der Werte auslagern wolltest.
2. das selbst so gemacht hast { double erg1, erg2; }.
wenn du die Ausgabe der Werte mit in die Verarbeitung reinnimmst kannst du auch Joe_M's Variante nehmen.
Ausgelagert sähe das dann wie folgt aus

void wassertemperatur( double wtemp, double um, int min = 10, double faktor = 0.1 )
{
	cout
		<< endl << "Wassertemperatur   : " << wtemp
		<< endl << "Umgebungstemperatur: " << um
		<< endl << "Wassertemperatur nach jeweils einer Minute:";
	while(min > 0)
	{
		wtemp -= ( wtemp - um ) * faktor;
		cout << endl << wtemp;
		--min;
	}
}