Wo liegt der Fehler?

  • Ich habe nun seit kurzem C++ angefangen zu lernen...
    Bei einem kleinen Test Spiel komm ich nicht weiter!
    Könnt ihr mir sagen wo der Fehler ist?



    Danke

  • Zitat

    for(zahl2; != zahl;)

    Das ist nicht der korrekte Syntax einer For Schleife. Der richtige wird so beschrieben

    for(variableninitiierung;Bedingung;variablenänderung)

    und sieht z.B. so for(int i=0;i<durchgänge;i++) aus


    Ich würde die while Schleife verwenden da du hier nur eine Bedingung hast bei der die schleife ausgeführt werden soll:

    while(zahl2!=zahl)
    {
    //...
    }

    ansonsten habe ich keine Fehler entdeckt

  • Naja, eigentlich for(Anweisung; Boolesche Anweisung; [eventuell eine weiter Anweisung]).
    Dabei ist zu beachten:
    i = 0, j = 0; ist eine Anweisung, ebenso ++i, ++j. i != 12, j != 12; wird aber nicht zum gewünschten Ergebnis führen, da der Wahrheitswert von j != 12 zurückgegeben wird, dann muss i != 12 && j != 12; sein.

    Egal, den Standardfall hat Caed gut beschrieben. ;)

  • Das ist nicht richtig. C/C++ haben umfangreiche implizite Typkonversionen. Das ist unter anderen ein großer Kritikpunkt an diesen Sprachen.

    Aber um das mal hier auf das Beispiel zu beschränken: mehr oder weniger alles was ungleich 0 ist, bedeutet "true".

    Folgender Code:

    Code
    for(double x = 0.001; d; d=0)
       cout << "klappt" << endl;


    "klappt" wirklich. Und warum ist das jetzt schlecht? Ein Beispiel:

    Code
    double x;
    x = true;


    Das funktioniert wirklich! Und zwar weil der Boolean Datentyp ein integraler Typ ist und damit auch einem double zugewiesen werden kann. Bei sowas wird mir wirklich schlecht, üble Sache. Sowas sollte nur explizit erlaubt sein...

  • Wasserleiche:
    Wer aber schreibt "couble x = true;", der ist selbst schuld wenn es zu fehlern kommen kann.
    Muss zwar nicht sein, kann aber
    Da kann man auch gleich "=1" oder "=1.0" schreiben...

    Something big is coming. And there will be pirates and ninjas and unicorns...

  • Dodo:

    Setz doch mal deine Fantasie ein, natürlich schreibt keiner explizit "double = true". Aber stell dir folgendes vor:

    Du arbeitest mit Kollegen an einer großen Software. Du hast dir eine Funktion geschrieben, die abhängig von einem oder zwei Parameter etwas ausrechnet:

    Code
    double computeSomething(double param1)
    {
       // ...
    }
    
    
    double computeSomething(double param1, param2)
    {
       // ...
    }


    Nach einer Weile fällt dir auf, dass in der Funktion auch etwas schief gehen kann. Aber wie teilst du das dem Aufrufer mit? Du machst es also anders:

    Code
    bool computeSomething(double &retValue, double param1)
    {
       // ...
    }
    
    
    bool computeSomething(double &retValue, double param1, param2)
    {
       // ...
    }


    Bei einem Fehler gibst du false zurück, den eigentlich Wert gibst du by-reference zurück.

    Du compilierst, alles Ok. Du testest deinen Code, alles wunderbar. Du kannst auf den Fehler reagieren. Das Programm wird an einen Kunden ausgeliefert der sich nach ein paar Tagen meldet. Er schreit, tobt, ist sauer... Die Produktion steht, tausende Euro schaden. Was ist passiert?

    Du hast vergessen, dass ein Kollege deine Hilfsfunktion auch nutzt:

    Code
    double x, y, z;
    y = 0.001;
    z = 12.7;
    x = computeSomething(y, z);


    Aber leider macht die Funktion jetzt nicht mehr das was dein Kollege vermutet und die Software hat einen Bug. Und der Compiler hat nicht gemeckert, nichtmal eine Warning ausgegeben. Finde mal so einen Fehler in einem großen Projekt - viel Spaß!

    Rate mal warum die casting Operatoren in C++ so "komisch" aussehen (z.B. dynamic_cast<int>(value)) im Gegensatz zum c-style cast . Damit erkennt man sofort an welcher Stelle im Code gecastet wird. Und das ist gut, weil man casten so weit es geht vermeiden sollte.

  • Ja okey aber bei Funktionsänderungen die andere Verwenden, sollte man gröbere Änderungen wie Parameteränderungen mitteilen ;)
    Sonst kann es ja nur böse enden ;)

    Something big is coming. And there will be pirates and ninjas and unicorns...

  • Tja, das sollte geschehen, aber genauso können Bugs entstehen.

    Programme stürzen nicht aus Böswilligkeit der Entwickler ab, sondern entstehen durch solche Situationen. Eine Sprache die sowas verhindert, in dem Typkonversion fast nur explizit ausgeführt werden kann, ist einfach sicherer.

    Operatorüberladung ist auch so ein Kritikpunkt an C/C++. Dieser syntaktischen Zucker beherbergt einige Tücken.

    Aber ich sollte jetzt aufhören, bin schon lange vom Thema abgewichen...

  • Man könnte es natürlich auch so machen, damit der kompiler nix meldet.



    Warum haben alle Programmiersprachen bugs - immer wenn ich etwas schreibe funtzt des ned^^

  • Sag mal, was hast du denn gegen Operatorüberladung?
    Ich finde das eine Riesen Stärke von C++ - am wichtigsten ist natürlich der operator=, aber eigentlich können es einem alle Operatoren gehörig vereinfachen.

  • The User:
    Eigentlich nicht der richtige Thread für sowas, aber:

    Ich hab prinzipell nichts gegen Operatorüberladung. Es macht mir viele Dinge einfacher zu schreiben. Super Sache!
    Doch Operatorüberladung ist nur syntaktischer Zucker. Soll heißen, alles was man damit machen kann, geht auch ohne Operatorüberladung (ist ja nur ein Funktionsaufruf). Es gibt Leute die meinen, C++ hätte die Operatorüberladung zu weit getrieben, da man fast alles überschreiben kann. Nutzt man fremde Bibliotheken, bekommt man unter umständen garnicht mit, dass eine aufwändige Operation aufgerufen wird, die man dort nicht vermutet. Was wirklich passiert wird vor dem Programmierer versteckt, was zu Problemen/Missverständnissen führen kann.

    Versteh mich nicht falsch, ich persönlich finde die Operatorüberladung super, aber ich kann Kritiker auch verstehen.

    Ericfischer:
    Die for() Schleife ist eine Endlosschleife, dass ist dir hoffentlich klar. Außerdem solltest du while() nutzen, wenn du nur den mittleren Teil der for() Schleife nutzt.

  • Ist ja semantischer Schwachsinn, for sollte mandochirgendwie zum Zählen benutzen.
    Wenn man mehrere Variablen zählt, die meinetwegen statt zu inkrementieren verdoppelt oder was abzieht finde ich auch okay. Der Zähler soll ruhig auch mal im Schleifenkörper etwas verändert werden. (Wenn zum Beispiel in einer Situation die Länge eines Vektors verändert wird oder sowas)
    Aber für sowas muss die doch echt nicht herhalten, for sollte doch immer Ausführen in Abhängigkeit von Werte(bereichen) einer Variable bedeuten.

    Wasserleiche
    Ich versteh dich jetzt richtig. :D Wobei natürlich die meisten Operatoren sowieso nicht Standarddefiniert werden. Und Klassen die was mit Zeigern zu tun haben oder vielleicht sogar als einzigen Zweck die Zeigerverwaltung haben brauchen in aller Regel einen eigenen operator=.