Schleife



  • 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?



  • @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...



  • 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;
    }
    






  • 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 😞



  • 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;
    }
    

    hiho schrieb:

    Was heissen den diese Vector Sachen hab sowas noch nie gesehen 😞

    Guckst Du hier

    Gruß
    Werner



  • 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;
    	}
    }
    

Anmelden zum Antworten