mfg

lol der fragt nach ner klasse und du gibst ihm ein struct.

Ein struct ist eine Klasse..

Ansichtssache

Hmm. Nö.

ISO/IEC 14882 9/4 schrieb:

4 A structure is a class defined with the class-key struct; its members and base classes (clause 10) are public
by default (clause 11).

lol der fragt nach ner klasse und du gibst ihm ein struct.

class boolean{ public: bool b; };

zufrieden?

123 schrieb:

lol der fragt nach ner klasse und du gibst ihm ein struct.

class boolean{ public: bool b; };

zufrieden?

jetzt fehlen der klasse nur noch ein paar mett hoden

class CBoolean
{ 
private: 
    bool m_bool; 

public:
    bool GetBool() { return m_bool; }
    void SetBool(bool b) { m_bool = bool; }
};

wenn es so weitergeht, haben wir hier bald ein Boolean-Framework stehen ^^

wär doch mal was ich mach mal weiter:

class CBoolean 
{ 
private: 
    bool m_bool; 

public: 
    bool GetBool() { return m_bool; } 
    void SetBool(bool b) { m_bool = bool; }

    void ToggleBool() { m_bool = !m_bool; } 
};

EDIT:
Hier wäre doch jetzt auch ein binärer !-Operator toll

Immer dieser Java-Slang :p

namespace useless_and_unsafe_wrappers_for_builtin_datatypes {

   class Boolean {
   private:
    	bool m_value;

   public:
      Boolean( bool value ) : m_value( value ) {}

      operator unspecified-bool-type() const { return m_value; }

      Boolean operator!() { return Boolean( !m_value ); }
      Boolean& operator=( bool rhs ) { m_value = rhs; return *this; }

      bool IsTrue() {
      	return m_value == true;
      }

      bool IsNotTrue() {
      	return m_value != true;
      }

      bool IsFalse() {
      	return m_value == false;
      }

      bool IsNotFalse() {
      	return m_value != false;
      }
   };

} // namespace useless_and_unsafe_wrappers_for_builtin_datatypes

Eine Alternative wäre das hier

assert(m_bool == true || m_bool == false);
assert(m_bool && m_bool == true);
assert(!m_bool && m_bool == false);

Du hast vergessen, den Wertebereich auf Gültigkeit sowie die Funktionstüchtigkeit des Compilers zuvor zu überprüfen:

assert(m_bool == true || m_bool == false);
assert(m_bool && m_bool == true);
assert(!m_bool && m_bool == false);

Du wolltest du blos deine 4000 haben.

Im übrigen hatten wir das alles bereits einmal (um genau zu sein 2 mal.)

Ich finde, dass die Rückgabewerte noch einen eigenen Datentypen bekommen. Das geht so ja wirklich nicht.

namespace useless_and_unsafe_wrappers_for_builtin_datatypes {

   class Boolean {
   private:
        bool m_value;

   public:
      Boolean( bool value ) : m_value( value ) {}

      operator unspecified-bool-type() const { return m_value; }

      Boolean operator!() const { return Boolean( !m_value ); }
      Boolean& operator=( bool rhs ) { m_value = rhs; return *this; }

      bool IsTrue() const {
          return m_value == true;
      }

      bool IsNotTrue() const {
          return m_value != true;
      }

      bool IsFalse() const {
          return m_value == false;
      }

      bool IsNotFalse() const {
          return m_value != false;
      }
   };

} // namespace useless_and_unsafe_wrappers_for_builtin_datatypes

Wo bleibt die synchronisierung?

Muss doch garnichts synchronisiert werden.

überhaupt sollte sie über virtuelle schnittstellen verfügen und polymorph sein.

Das ist eine gute idee! Z.B. eine political_bool klasse, die in 50% der fälle hät was sie verspricht.

Das ist eine gute idee! Z.B. eine political_bool klasse, die in 50% der fälle hät was sie verspricht.

Dieses Verhalten könnte man über ein "Policy based" Design realisieren! :p

Dieses Verhalten könnte man über ein "Policy based" Design realisieren! :p

Und dann fehlt natürlich noch die Umsetzung von Entwurfsmustern, z.B. Observer. Wenn wir diesen dann auch noch ein "Policy based" Design geben könnte dies in etwa wie folgt sein:

Lobbiisten-Observer: Meldet nur eine Änderung wenn es zu seinen Ansichten passt.
Manager-Observer: Meldet nur eine Änderung wenn er grad nichts wichtigeres zu tun hat.
Spam-Observer: Meldet sich auch mal zwischenzeitlich, egal ob sich etwas ändert oder nicht
...

cu André

pvtbl schrieb:

überhaupt sollte sie über virtuelle schnittstellen verfügen und polymorph sein.

Das ist eine gute idee! Z.B. eine political_bool klasse, die in 50% der fälle hät was sie verspricht.

es gibt jetzt boost::tribool, wo auch "indeterminate" bzw. "maybe" unterstützt wird
sorry, dass ich so was in einer solch ernsthaften unterhaltung poste