Variable übernimmt Wert nicht.

Christine0107

Hallo,
Ich habe folgendes Problem. Der unten skizzierte Code ist Teil einer Schleife, die immer ein neuen wert abgreift. Am Ende der Zeile soll der initialisierten double variable dieser wert gegeben werden.
Die variable übernimmt diesen aber nicht. Die Funktion funktioniert soweit, da wenn ich die variable deklariere mit zB variable = 5, die Funktion die Berechnung genauso macht, wie sie es soll.

/*Befehl c++*/;
double variable;

{

/*Funktion, in der variable und wert interagieren*/

variable = *wert*;
}

SeppJ

Dann wird wohl etwas nicht stimmen, an deinem Code. Vielleicht solltest du ihn herzeigen.

Christine0107

Naja wenn ich für "wert" und "variable" verschiedene Werte festlege, dann macht der Code auch das, was er soll. Mir geht es nur darum, warum in Zeile 8 der "wert" nicht übernommen wird? Kann es vielleicht daran liegen, dass die "variable" erst innerhalb dieses Befehls deklariert wird und bei jedem durchlauf des Codes diese neu initialisiert wird und dadurch der "gemerkte" Wert einfach gelöscht wird?

Das ist eigentlich kein Code ... allenfalls Pseudocode. Man kann daraus (zu) wenig ableiten.

Quiche Lorraine

@Christine0107 sagte in Variable übernimmt Wert nicht.:

Naja wenn ich für "wert" und "variable" verschiedene Werte festlege, dann macht der Code auch das, was er soll. Mir geht es nur darum, warum in Zeile 8 der "wert" nicht übernommen wird? Kann es vielleicht daran liegen, dass die "variable" erst innerhalb dieses Befehls deklariert wird und bei jedem durchlauf des Codes diese neu initialisiert wird und dadurch der "gemerkte" Wert einfach gelöscht wird?

Hör mal, wir können dir so nicht helfen, da wir dein Problem nicht verstehen. Das eine Zuweisung nicht funktionieren soll, wäre mir neu und ist mir noch nie untergekommen.

Ein Tipp: Schnapp dir doch mal eine IDE und spiele herum. Arbeite dich in den Debugger ein und lasse diese Zeile für Zeile dein Programm ausführen. Als Basis kannst du folgendes Programm nutzen:

#include <iostream>

int main()
{
    double v = 0;

    std::cout << "Variable v = " << v << "\n";  // Erwartetes Ergebnis: "Variable v = 0"
    for (int i = 0; i < 10; i++)
    {
        v = i;
        std::cout << "Variable v = " << v << "\n";  // Erwartetes Ergebnis: "Variable v = 0", "Variable v = 1",...
    }
    return 0;
}

Und wenn du dann etwas nicht versteht, stelle deinen aktuellen Code ins Forum und stelle deine Frage.

DirkB

@Christine0107 Wird wert evtl. außerhalb der Funktion (in einem Interrupt) geändert?

@Christine0107 Was soll denn überhaupt geschehen? Was soll das Programm tun? Vielleicht so einfacher ...

Btw., eine (Neu-)Zuweisung ist keine Initialisierung ... Eine Initialisierung ist Deklaration und Erstwertzuweisung in einem Schritt. Das sind alles klar definierte Begriffe.

hustbaer

@Christine0107 Wie @SeppJ schon geschrieben hat, du musst deinen Code herzeigen. Aus deiner "Skizze" können wir nicht herleiten wo genau die Zeilen stehen/wie der umgebende Code aussieht. Und das ist zur Beantwortung deiner Frage wichtig.

Christine0107

Hallo,

Vielen Dank für die Antworten. Hier nun der Code. Zur Erklärung: Der zufallswert wird automatisch generiert. Die Programmzeilen sollen dazu dienen einen nulldurchgang anzuzeigen. An die hilfsvariable soll immer der letzte zufallswert übergeben werden und durch einen Vergleich dieser beiden Werte der nulldurchgang erkannt werden. (Wenn ein Wert positiv ist und ein Wert negativ ist das ein nulldurchgang). Alles ist Bestandteil einer Schleife. Der zufallswert ist auch in double angegeben.

bool nulldurchgang=false;
double hilfsvariable;
{
{

if          (zufallswert< 0 && hilfsvariable > 0) nulldurchgang=true;
				
else if (zufallswert>0 && hilfsvariable<0) nulldurchgang=true;
				
else      nulldurchgang=false;
}

hilfsvariable = zufallswert;

}

SeppJ

Bitte nicht so sparsam bei der Problembeschreibung. Gib uns ein vollständiges Programmbeispiel, das dein Problem reproduziert! Mit so einem Fetzen können wir nur raten, und darauf hat keiner Lust. Da konnte ja allerlei passieren, bei der unbekannten Herkunft von Zufallswert und bei der unbekannten Art und Weise, wie du das bei dir im Programm eingebaut hast, und bei dem uns auch unbekannten genauem Problem.

Dein Codestück enthält einige offensichtliche Fehler (z.B. hat hilfsvariable keinen Wert zugewiesen, und du machst überhaupt nichts mit deinen Ergebnissen), aber die können halt genausogut durch deine übereifrige Kürzung entstanden sein.

Siehe bitte: Du brauchst Hilfe

Christine0107

@SeppJ

Welche Fehler enthält das Codestück denn noch? Ich habe der hilfsvariable testweise eine positiven bzw einen negativen wert zugewiesen, was dazu geführt hat, dass der nulldurchgang bei allen negativen bzw dann positiven zufallswerten angezeigt wurde, was den Verdacht erhärtet, dass die hilfsvariable nicht den Wert des zufallswert übernimmt. Genau da liegt mein Problem!

In der Hilfe steht explizit das Problem auf das Wesentliche runterzubrechen und keine 300 Zeilen Code anzugeben.

DocShoe

Du intialisierst hilfsvariable nicht, damit hat sie zur Laufzeit einen zufälligen Wert. Und damit sind auch deine if-else if-else Anweisungen zufällig.

Quiche Lorraine

@Christine0107

Dein Code ist unverständlich, ich würde diesen dringend aufräumen. Aber ich habe eine Vermutung. Du sprichst nämlich von Nulldurchgang. Und eigentlich würde ich da ein enum mit den folgenden Werten erwarten:

UNKNOWN
ABOVE
UNDER

DIeses enum würde die letzte bekannte Position des Signals speichern. Und einen Nulldurchgang würde dann auftreten wenn die letzte Position UNDER war und aktuell ABOVE oder die letzte Position ABOVE und nun UNDER ist.

Kann es sein dass das deine Variable hilfsvariable ist?

SeppJ

@Christine0107 sagte in Variable übernimmt Wert nicht.:

Welche Fehler enthält das Codestück denn noch? Ich habe der hilfsvariable testweise eine positiven bzw einen negativen wert zugewiesen, was dazu geführt hat, dass der nulldurchgang bei allen negativen bzw dann positiven zufallswerten angezeigt wurde, was den Verdacht erhärtet, dass die hilfsvariable nicht den Wert des zufallswert übernimmt. Genau da liegt mein Problem!

Gerade deshalb wäre es doch wichtig zu wissen, woher dieser Wert überhaupt kommt. Und auch, wie der fehlerhafte Code exakt aussieht. Nach hilfsvariable = zufallswert; hat hilfsvariable den Wert von zufallswert, dass garantiere ich dir. Deshalb müssen wir nachvollziehen können, was dich überhaupt zu der Annahme bringt, dass das nicht so sein könnte.

In der Hilfe steht explizit das Problem auf das Wesentliche runterzubrechen und keine 300 Zeilen Code anzugeben.

Ja, aber da steht auch, dass dein Code das Problem demonstrieren muss! Was du hier zeigst ist irgendetwas, wie du dir vorstellst, wie dein Code eventuell funktionieren könnte, zeigt das Problem nicht, und ist überhaupt reine Fantasie.

wob

Erstmal formatieren wir deinen Code (verwende irgendeinen automatischen Code-Formatierer, z.B. clang-format). Dann sieht er so aus:

bool nulldurchgang = false;
double hilfsvariable;
{
    {

        if (zufallswert < 0 && hilfsvariable > 0)
            nulldurchgang = true;

        else if (zufallswert > 0 && hilfsvariable < 0)
            nulldurchgang = true;

        else
            nulldurchgang = false;
    }

    hilfsvariable = zufallswert;
}

Es fällt auf, dass die beiden Klammernpaare nichts tun. Sie können also weg:

bool nulldurchgang = false;
double hilfsvariable;

if (zufallswert < 0 && hilfsvariable > 0)
    nulldurchgang = true;

else if (zufallswert > 0 && hilfsvariable < 0)
    nulldurchgang = true;

else
    nulldurchgang = false;

hilfsvariable = zufallswert;

Die ersten beiden ifs haben denselben then-Teil. Man kann sie also zusammenfassen.

if ((zufallswert < 0 && hilfsvariable > 0) || (zufallswert > 0 && hilfsvariable < 0)) ...

da im then- und else-Teil nur eine bool-Variable gestezt wird, kann man das weiter kürzen auf:

double hilfsvariable;

bool nulldurchgang = (
    (zufallswert < 0 && hilfsvariable > 0) || (zufallswert > 0 && hilfsvariable < 0)
);

hilfsvariable = zufallswert;

Hier siehst du jetzt sehr gut, dass der Code nicht sinnvoll ist. Wie schon gesagt, ist hilfsvariable undefiniert. Somit ist auch nulldurchgang undefiniert. nulldurchgang wird in deinem Beispiel aber nicht weiter verwendet und was zufallswert ist, ist auch nicht bekannt.

Christine0107

@Quiche-Lorraine
Genau, die Hilfsvariable soll den Zufallswert übernehmen und beim nächsten durchlauf mit dem neuen Zufallswert vergleichen. Mit enum habe ich noch nicht gearbeitet.

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.