3. false und true

false und true

  • T

    @EH
    meines wissens nach ist
    false == 0
    und
    true != false
    also nicht ausschließlich 1 sondern eben irgendwas außer != 0

    0
  • E
     

    #include <iostream>
using namespace std;

int main()
{
  int zahl = true;
  cout << zahl; // 1

  cin.get();   
  return 0;
}

    true == 1 (alles andere ist akademisch 😃 )

    0
  • G

    meines wissens nach ist
    false == 0
    und
    true != false
    also nicht ausschließlich 1 sondern eben irgendwas außer != 0

    Kommt immer drauf an in welchem Kontext man bool Werte betrachtet.
    laut Standard:
    für Zuweisung

    An rvalue of type bool can be converted to an rvalue of type int, with false becoming zero and true becoming one.

    für Auswertung

    A zero value, null pointer value, or null member pointer value is converted to false; any other value is converted to true.

    0
  • R
     

    #include <iostream> 
using namespace std; 
int main() 
{ 
  bool b;
  cout<<++b; //bei mir ist b auch 1
  return 0; 
}

    das gefällt mir irgendwie...wer braucht schon true oder false 😃

    0
  • H

    true can in 1 gecastet werden, ist deswegen aber noch lange nicht 1. true ist true; ein eigenständiger Literal.

    class Foo {
public:
   operator int()
   {
      return what_m == "Cat";
   }
   Foo (const std::string & what)
   { 
      what_m = what;
   }
   ...
privat:
   std::string what_m;
};

Foo bar("Cat");
Foo quer("Dog");

cout << static_cast<int>(bar) << '\n';
cout << static_cast<int>(quer) << '\n';

    Ist Foo("Cat") deswegen jetzt 1?

    0
  • R

    versteh nicht was du damit sagen willst? ich seh da kein bool, kein false und kein true?

    The bool type participates in integral promotions. An r-value of type bool can be converted to an r-value of type int, with false becoming zero and true becoming one.

    so einfach ist das...

    0
  • H

    Hallo,
    nur noch als Ergänzung: Präfix- und Postfix-Increment ist laut Standard deprecated für bool.

    0
  • E

    @HumeSikkins: der Zusammenhang zwischen bool und int ist klar, aber warum geht bei bool ++ und -- nicht (veraltet oder nicht spielt jetzt erst mal keine Rolle; was geht, geht. 🙂 )? Entweder man verbietet beides oder erlaubt beides, ich verstehe den Unterschied noch nicht ganz.

    0
  • H

    Entweder man verbietet beides oder erlaubt beides, ich verstehe den Unterschied noch nicht ganz.

    Naja. Das eine ist invariant gegenüber Wiederholung und das andere nicht.
    Da true alles ungleich null ist, kann man ein bool beliebig inkrementieren,
    das Ergebnis ist true. Egal ob du das hundert mal machts oder einmal.

    Beim dekrementieren müsstest man sich aber etwas einfallen lassen. Denn soll z.B.
    bool b = false;
    b++;
    b++;
    b--;

    true oder false ergeben?
    Oder was ist mit:
    bool b = false;
    b--;

    true oder false?

    Insofern denke ich schon, dass es sinn macht, das Dekrementieren von bools zu verbieten. Das Inkrementieren hat weniger Probleme, ist aber ebenfalls sehr fragwürdig und deshalb mittlerweile missbilligt.

    PS: Ob das wirklich der Grund dafür ist, dass -- auf bools nicht erlaubt ist, weiß ich natürlich nicht.

    PPS: C99 erlaubt übrigens sowohl Inkrement als auch Dekrement. Hier ist b-- (für bool b) immer gleich:
    b = !b;
    also das logische Komplement.

    0
  • E

    Da sind wir ja in eine düstere Ecke geraten, wenn selbst Du mit einem verhaltenen "Naja" beginnst. 😃

    0
  • C
     

    bool b = false;
for(unsigned int i = 1; i < std::pow(2, sizeof(bool) * 8); i++)
  b++;
// Kann folgendes Inkrement bei schlechten Compilern zum Überschreiten des Wertebereichs führen? 
b++;
    0
  • V

    cd9000 schrieb:

    bool b = false;
for(unsigned int i = 1; i < std::pow(2, sizeof(bool) * 8); i++)
  b++;
// Kann folgendes Inkrement bei schlechten Compilern zum Überschreiten des Wertebereichs führen? 
b++;

    bei schlechten compilern mag alles passieren.
    aber bei guten hat ein boot nur 0 oder 1 drin und sonst nix.
    bool(1+1)==1;

    man mache nämlich gerne

    bool a=veca.length();
bool b=vecb.length();

//und später sooft man mag
if(a==b)
    0
  • H

    @RPD:
    Vielleicht hilt dir das beim Verständniss:

    An r-value of type Foo can be converted to an r-value of type int, with state "Cat" becoming one and any other state becoming zero.

    so einfach ist das...

    Das man jetzt schon zum Englischen greifen muss, um etwas verständlich zu machen ist echt tragisch.

    0
  • B

    HumeSikkins schrieb:

    Entweder man verbietet beides oder erlaubt beides, ich verstehe den Unterschied noch nicht ganz.

    Naja. Das eine ist invariant gegenüber Wiederholung und das andere nicht.
    Da true alles ungleich null ist, kann man ein bool beliebig inkrementieren,
    das Ergebnis ist true. Egal ob du das hundert mal machts oder einmal.

    Wenn ++b für jede interne Repräsentation von b true ist, muß der Compiler aufpassen, dass b nicht zufällig gerade genau die Repräsentation hat, die beim inkrementieren 0 ergibt (255 bei byte-großen bools.) Also kann er genausogut ++b als b=true ansehen. Und dann auch --b als b=false.

    Ein Zähler in der Art ++b; ++b; --b; // immer noch true wär daher nicht möglich, beim Überlauf würde ++b ja false ergeben, und das will der Standard anders haben.

    0
  • R

    @Helium
    hab trotzdem noch keinen compiler gesehen der aus true keine 1 macht.

    0
  • B

    RPD schrieb:

    @Helium
    hab trotzdem noch keinen compiler gesehen der aus true keine 1 macht.

    Wenn du mal genau liest, wirst du feststellen, dass Helium das gar nicht bestritten hat. Er weist lediglich auf den Unterschied zwischen "macht daraus eine 1" (bzw. standardesisch "wird zu 1 konvertiert") und "ist 1" hin.

    0
  • ?

    boolalpha |

    true false <--

    0
  • R

    *nochmalgenaugelesen*
    jetzt hab ichs auch verstanden 💡
    *freu* 😃

    0
Anmelden zum Antworten