boolean klasse

Machine

zwutz schrieb:

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; } 
};

LordJaxom

namespace useless_and_unsafe_wrappers_for_builtin_datatypes {

   class Boolean {
   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; }
   };

} // namespace useless_and_unsafe_wrappers_for_builtin_datatypes

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

Machine

namespace useless_and_unsafe_wrappers_for_builtin_datatypes 
{
    class CBoolean 
    { 
    public: 
        CBoolean( bool value ) : m_value( value ) {} 
        ~CBoolean();

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

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

} // namespace useless_and_unsafe_wrappers_for_builtin_datatypes

Immer dieser Java-Slang :p

DerKuchen

Da fehlten noch die wichtigsten Funktionen:

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

bool isTrue()
{
    if(m_bool == true && m_bool != false)
    {
        return true;
    }
    else if(m_bool == false && m_bool != true)
    {
        return false;
    }
    else
    {
        assert(false);
    }
}

LordJaxom

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);

drakon

LordJaxom schrieb:

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.

David_pb

Und immer schön auf die const-correctness achten!

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?

David_pb

spam1256 schrieb:

Wo bleibt die synchronisierung?

Muss doch garnichts synchronisiert werden.

Doch wir müssen unser Enterprise-Assessment-Bool-Data-Object vor zugriff schützen egal wie Atomic unsere Values sind.

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

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.

David_pb

quak-quark schrieb:

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

David_pb schrieb:

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é

quak-quark schrieb:

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