while oder for - schleife ohne definiertes Ende

giebl0n

Hallo, bin neu hier und hoffe auf eure Unterstützung.
Vorweg, meine Kenntnisse sind bisher mehr als bescheiden.
Nun zu meinem Problem.
Ich möchte alle 500ms eine Messwert aufnehmen, solange der Wert größer z.b. 5 ist. Wenn der Messwert kleine 5 ist soll die Messreihe wieder beendet werden.

Danach soll der Spitzenwert ausgegeben werden, was ich denke ich hinbekommen sollte.

Meine Überlegung ist jetzt, dass ich hier

for(int i=0;i<?;i++)

i begrenzen muss, da ich sonst eine Endlosschleife habe.

Kann ich das durch eine weitere Variable begrenzen, die ich vorher in einer whileschleife die Anzahl der Messwerte mitzählen lasse?

Ich hoffe ihr könnt meine Frage nachvollziehen
Danke im Voraus!

giebl0n schrieb:

Ich möchte alle 500ms eine Messwert aufnehmen, solange der Wert größer z.b. 5 ist. Wenn der Messwert kleine 5 ist soll die Messreihe wieder beendet werden.

Danach soll der Spitzenwert ausgegeben werden, was ich denke ich hinbekommen sollte.

Meine Überlegung ist jetzt, dass ich hier
for(int i=0;i<?;i++)
i begrenzen muss, da ich sonst eine Endlosschleife habe.

Kann ich das durch eine weitere Variable begrenzen, die ich vorher in einer whileschleife die Anzahl der Messwerte mitzählen lasse?

Du hast geschrieben, du willst es beenden, wenn ein Messwert kleiner 5 ist. Dann machst du einfach, i>4 . Natürlich kannst du auch eine Variable nehmen. int lower_bound = 4 und dann i>lower_bound .

Was du für deine Aufgabe brauchst:
1. std::this_thread::sleep_for
2. std::vector
3. std::std::max_element

out schrieb:

2. std::vector
3. std::std::max_element

.. unnötig.

Einfacher:

float maximaler_messwert = hole_messwert(); // Vorbelegung
    for( float messwert; (messwert = hole_messwert()) >= 5.f; std::this_thread::sleep_for( std::chrono::milliseconds( 500 ) ) )
    {
        if( messwert > maximaler_messwert )
        {
            maximaler_messwert = messwert;
        }
    }
    // -> maximaler_messwert

Hallo giebl0n,
ja du kannst es mit der Variabel begrenzen, die du vorher für die Anzahl der Messwerte mitzählen lässt. Sie muss dann aber außerhalb der while-Schleife definiert sein, da sie sonst nur in der Schleife existiert.

int anzahlMesswerte;
while (...)
{
  ...
  anzahlMesswerte++;
}

for (int i = 0; i < anzahlMesswerte; i++)
{
  ...
}

Wenn du die Variabel nach der for-Schleife nicht mehr und i in der Schleife nicht brauchst, kannst du die Variabel in der for-Schleife auch wieder runter zählen.

for ( ; anzahlMesswerte > 0; --anzahlMesswerte)

hustbaer

giebl0n schrieb:

Meine Überlegung ist jetzt, dass ich hier
for(int i=0;i<?;i++)
i begrenzen muss, da ich sonst eine Endlosschleife habe.

Du kannst auch for (int i = 0; ; i++) schreiben, also die Bedingung einfach weglassen.
Und die Schleife dann explizit mit break abbrechen. Finde ich oft übersichtlicher als immer unbedingt dafür zu sorgen dass die Abbruchbedingung im Schleifenkopf stehen kann.
Also z.B.

for (int i = 0; ; i++)
{
    float messwert = hole_messwert();
    if (messwert < minimaler_messwert)
        break;
    // ...
}

hustbaer

Werner_logoff schrieb:

for( float messwert; (messwert = hole_messwert()) >= 5.f; std::this_thread::sleep_for( std::chrono::milliseconds( 500 ) ) )

Immer wenn du sowas schreibst tötet Gott ein Kätzchen.

Aber mal ehrlich: findest du das übersichtlich? Liest du gerne Code der so geschrieben ist?
Schon klar dass das total subjektiv ist, je nachdem was für Code man selbst schreibt und was man halt gewohnt ist, aber ich würde das wirklich eher mit break schreiben, und auch das Sleep in den Schleifenrumpf ziehen.
Anstatt den Wert einer geklammerten Zuweisung mit einem Grenzwert zu vergleichen.

Sone

Wenn du [...] i in der Schleife nicht brauchst[...]
for ( ; anzahlMesswerte > 0; --anzahlMesswerte)

while( anzahlMesswerte-- )

@Werner: Was wenn die erste Messung, deren Ergebnis du als Vorbelegung in maximaler_messwert speicherst, bereits unter 5 liegt? Überhaupt kann man mit deiner Version die Messreihe nicht vernünftig speichern, bzw. da kommt ein extra Einfüge-Statement vor die Schleife.

@hustbaer: Das wollte ich auch schreiben. Die Schleife ist der pure Wahnsinn.

Schon klar dass das total subjektiv ist, je nachdem was für Code man selbst schreibt und was man halt gewohnt ist, aber ich würde das wirklich eher mit break schreiben, und auch das Sleep in den Schleifenrumpf ziehen.

Ja, genau! Dachte, ich bin der einzige.

#include <random>
#include <chrono>

using namespace std;

float hole_messwert()
{
	static ranlux48 engine( chrono::system_clock::now().time_since_epoch().count() );
	static uniform_int_distribution<int> distribution{4, 10};
	return distribution(engine);
}

#include <iostream>
#include <limits>
#include <thread>
#include <iterator>

int main()
{
	float maximaler_messwert = numeric_limits<float>::min(); // Vorbelegung

	vector<float> messwerte;

    for(;;)
    {
    	float const messwert = hole_messwert();

    	if( messwert < 5.f )
			break;

	messwerte.emplace_back( messwert );

        if( messwert > maximaler_messwert )
            maximaler_messwert = messwert;

        this_thread::sleep_for( chrono::milliseconds( 500 ) );
    }

	copy( begin(messwerte), end(messwerte), ostream_iterator<float>(cout, " ") );
    cout << "\nMaximaler Messwert: " << maximaler_messwert;
}

Ist es erlaubt, dass includes irgendwo stehen? Dachte, sie müssen immer ganz am Anfang stehen?

out schrieb:

Ist es erlaubt, dass includes irgendwo stehen? Dachte, sie müssen immer ganz am Anfang stehen?

Ist doch nur eine Textersetzung.

It0101

hustbaer schrieb:

Werner_logoff schrieb:
for( float messwert; (messwert = hole_messwert()) >= 5.f; std::this_thread::sleep_for( std::chrono::milliseconds( 500 ) ) )
Immer wenn du sowas schreibst tötet Gott ein Kätzchen.

Ich hab den Eindruck, dass so mancher sich von der guten Usability der STL manchmal dazu verleiten lässt, solche tödlichen Einzeiler zu schreiben....