Variable übernimmt Wert nicht.

Christine0107

@wob
Vielen Dank für das Feedback,
Der zufallswert wird automatisch generiert. Allerdings kann ich den genauen Zeilenabschnitt nicht erkennen und wie das genau gemacht wird (Das Programm hat mehr als 300 Zeilen). Wenn ich die hilfsvariable definiere (zB hilfsvariable = 1), würde das am Problem was ändern?

SeppJ

@Christine0107 sagte in Variable übernimmt Wert nicht.:

Der zufallswert wird automatisch generiert. Allerdings kann ich den genauen Zeilenabschnitt nicht erkennen und wie das genau gemacht wird (Das Programm hat mehr als 300 Zeilen). Wenn ich die hilfsvariable definiere (zB hilfsvariable = 1), würde das am Problem was ändern?

Unwahrscheinlich. Wenn du in 300 Zeilen nicht erkennen kannst, wo eine Variable ihren Wert herbekommt, oder wenn das Programm so ein Kuddelmuddel ist, dass man das tatsächlich nicht erkennen kann, dann ist eher davon auszugehen, dass du einfach völlig auf dem Holzweg bist und die ganz falsche Frage zu ganz falschem Code stellst. Wie dir ja schon wiederholt gesagt wurde, brauchen wir Code, der das Problem repräsentiert. Wenn du nicht einmal weißt, wo und wie in deinem echten Code eine der entscheidenden Variablen ihren Wert ändert, wie soll dein Beispielcode dann korrekt dein Problem zu einer nicht-Änderung eines Wertes darstellen? Wahrscheinlicher ist da doch, dass du fälschlicherweise davon ausgehst, dass sich da was ändern sollte, wenn das gar nicht der Fall ist, sondern du das Programm nicht richtig verstehst. Daher um so wichtiger, dass du dein Problem systematisch reduzierst.

Th69

@Christine0107 sagte in Variable übernimmt Wert nicht.:

Genau, die Hilfsvariable soll den Zufallswert übernehmen und beim nächsten durchlauf mit dem neuen Zufallswert vergleichen.

Du meinst, in einer Schleife wird dieser gesamte Code wieder neu durchlaufen?
Dann verstehst du das Speichermodell von C++ (bzw. auch schon von C) nicht. Bei jedem Aufruf dieses gesamten Codes werden alle lokalen Variablen (hier also auch hilfsvariable) neu erzeugt und selbst, wenn sie nicht initialisiert werden, behalten sie nicht den vorherigen Wert bei, sondern haben einen undefinierten Wert (da diese üblicherweise auf dem Stack bzw. in einer Registervariablen gehalten werden, in denen vorher andere Werte drin stehen).

Abhilfe könnte hier entweder die Übergabe der Variablen hilfsvariable als Funktionsparameter (sofern dein Code selber als Funktion implementiert ist) schaffen oder das Schlüsselwort static (s. z.B. static in Funktionen).

Wenn dein Code jedoch direkt Teil dieser Schleife ist, dann müßte es auch reichen, einfach die Deklaration dieser Variablen vor die Schleife zu setzen, so daß diese nur einmalig initialisiert wird (du müßtest jedoch noch einen passenden Initialwert setzen, damit beim ersten Durchlauf nicht wieder ein undefinierter Wert dort drin steht - das müßtest du logisch entscheiden).

Quiche Lorraine

@Christine0107 sagte in Variable übernimmt Wert nicht.:

Genau, die Hilfsvariable soll den Zufallswert übernehmen und beim nächsten durchlauf mit dem neuen Zufallswert vergleichen.

Und was machst du am Anfang wo du noch keinen Wert hast? Ich glaube deine Logik stimmt so nicht ganz.

Mit enum habe ich noch nicht gearbeitet.

Oh je, ich bin mal lieb:

#include <iostream>



class ZeroDetection
{
private:
    enum class State
    {
        UNKNOWN,
        ABOVE,
        UNDER
    };


private:
    State gState = State::UNKNOWN;      ///< Zustand des letzten bekannten Put() Aufrufs


public:
    /**
    *
    *
    * \return true, wenn ein Nulldurchgang erfolgte, sonst false
    **/
    bool Put(double v)
    {
        if (gState == State::UNKNOWN)
        {
            gState = (v > 0) ? State::ABOVE : State::UNDER;
            return false;
        }
        else if (gState == State::ABOVE)
        {
            if (v > 0)
            {
                gState = State::ABOVE;
                return false;
            }
            else
            {
                gState = State::UNDER;
                return true;
            }
        }
        else // if (gState == State::UNDER)
        {
            if (v > 0)
            {
                gState = State::ABOVE;
                return true;
            }
            else
            {
                gState = State::UNDER;
                return false;
            }
        }
    }
};


int main(int argc, char const *argv[])
{
    ZeroDetection zd;

    if (zd.Put(1))
        std::cout << "1. Nulldetektion\n";
    if (zd.Put(-1))
        std::cout << "2. Nulldetektion\n";
    return 0;
}

So ungefähr würde ich die Funktion implementieren.

SeppJ

@Quiche-Lorraine : Was ist bei Tangieren der Null?

Quiche Lorraine

@SeppJ sagte in Variable übernimmt Wert nicht.:

Was ist bei Tangieren der Null?

Das überlasse ich der Threaderstellerin.

BTW: Ich glaube hier könnte es für die Threaderstellerin auch übungstechnisch Sinn machen einen Zustandsdiagramm zu malen und dieses dann zu implementieren.

Christine0107

@Th69

Naja ich bin auch nicht so fit in C++. Die Aufgabe ist Teil einer Hausarbeit und nach Grundkurs C++ ist für mich alles noch nicht so einfach bzw einleuchtend.

Anforderung in der Aufgabe ist auch, dass die Programmierung im modularen Konzept umgesetzt wird, dh ich darf außerhalb meiner Programmierung nichts verändern.

Christine0107

@Quiche-Lorraine

Vielen Dank für die Mühe.
Ich muss mir das mal in Ruhe nach der Arbeit anschauen, da mir der Datentyp in den Skripten noch nicht über den Weg gelaufen ist.

Christine0107

@SeppJ

Wie gesagt das ist Teil einer Hausarbeit und ich bin in dem Thema noch nicht so sattelfest. Der Code, in dem da gearbeitet wird ist zumindest für mich alles andere als verständlich und hat mit dem Niveau in den Skripten nichts mehr zu tun.

SeppJ

Sind all diese Ausflüchte jetzt wirklich weniger Mühe, als einfach mal den konkreten Code zu deinem Problem zu zeigen? Tut mir leid, aber man kann dir nur helfen, wenn du es auch willst.