Flags? klassen_obj->setFlags(flag::schlafen | flag::duschen | flag::essen);

Das funktioniert ja ganz hervorragend! DANKE!

flag::kacken

Pigeon

Das hört sich theoretisch ja ganz toll an nur was ist das Gegenteil von flag::reifen? Ich möchte nicht jedesmal alle 200 attribute in setFlags() neu aufführen wenn ich nur eins rausnehmen möchte....

Andrey

dann kannst du den "DWORD" oder "long" oder "int" oder was auch immer holen, in dem die ganzen flags aneinandergereiht sind, und mit dem ^ XOR operator den unnötigen flag entfernen (oder auch wieder hinzufügen):

//ein flag löschen

01001010 ^
00001000 =
01000010

flags= sitzen|essen|lesen;
flags=flags^essen; //nur noch sitzen und lesen, die chips sind nähmlich alle :(

hustbaer

Oft wird auch eine "changeFlags" Funktion verwendet, die 2 Masken mitbekommt, 1x die Bits welche übernommen werden sollen, und 1x die neuen Zustände für diese Bits:

void foo::changeFlags(unsigned mask, unsigned new_state)
{
    m_flags &= ~mask;
    m_flags |= (new_state & mask);
}

Pigeon

Danke für die antworten, ich habe auch mal eine version gebastelt, die mir aber etwas ungeschickt erscheint... kann man das so lassen, oder sie die if-abfragen umständlich, zumal hidden und selectable gar nicht gebaucht werden, da später im code nur überprüft wird ob es sichtbar ist bzw. selektierbar...

enum PointFlags
{
	visible = 1,
	hidden = 2,
	movable = 4,
	not_movable = 8,
	selectable = 16,
	not_selectable = 32
};

void glPointD::setFlags(int flags)
{
	this->flags = flags;
	if(flags & hidden)
	{
		this->flags = flags ^ visible;
		this->flags = flags ^ hidden;
	}
	if(flags & not_selectable)
	{
		this->flags = flags ^ selectable;
		this->flags = flags ^ not_selectable;
	}	
}

RHBaum

Warum hasst du visible und hidden gleichzeitig, genau so wie selectable und not_selectable ? Das macht doch logisch keinen Sinn !
1 information an 2 unterschiedlichen stellen = redundanz = poese !

Ciao ...

Nimm doch std::bitset, da kannst du dann auch die Größe leichter verändern und vor allem mehr als 32 (64) flags haben.
Außerdem gibts hübsche funktionen gratis. DIe bitweisen Verknüpf. operatoren sind in der Klasse überladen.

viande

Oh, ein ganz klassische Fall für das State-Pattern

enum PointFlags
{
    visible = 1,
    hidden = 2,
    movable = 4,
    not_movable = 8,
    selectable = 16,
    not_selectable = 32
};

Wird zu

struct glPointD_visibility
{
    virtual void do_with_visibility() = 0;
};

struct glPointD_movability
{
    virtual void do_with_movability() = 0;
}:

//...

struct visible_glPointD : glPointD_visibility
{
    void do_with_visibility()
    {
        do_something();
    }
};

struct hidden_glPointD : glPointD_visibility
{
    void do_with_visibility()
    {
        //do nothing
    }
}

class glPointD
{
    glPointD_visibility* visiblity;
}

Es wird immer die jeweilige virtuelle Methode aufgerufen und diese tut entsprechend was anderes (oder auch nichts). Nun können andere Methoden natürlich den Status ändern etc.
Siehe auch:
http://home.earthlink.net/~huston2/dp/state.html

hustbaer

Oh, ein klassischer Fall von Overkill.

Flags? klassen_obj-&gt;setFlags(flag::schlafen | flag::duschen | flag::essen);

Flags? klassen_obj->setFlags(flag::schlafen | flag::duschen | flag::essen);