Eine rein theoretische Frage für euch:
Nehmen wir an ich habe eine Klasse und möchte ihr ein bestimmtes Verhalten beibringen, dann ist es etwas aufwändig für jede "eigenschaft" eine Funktion zu vergeben. ( setDuschen(true); ). Mir ist daher dieses | bei der verarbeitung von Dateien (ios::in) und in einigen GUI Toolkits aufgefallen, bei denen man festlegen kann ob zB ein Listeneintrag verschiebbar/löschbar etc. ist. Ich habe noch keien Programmieransatz -> keinen Code ... Wie kann man dieses | verwenden und wie nennt sich dies und was ist es? (zB const int duschen; im namespace flag?)

Bitte klärt mich auf!

das klappt dann mit enums auch und du kannst mit einem & (und) operator diese werte abfragen

0011&0010=0010

und so die einzelnen bits/flags herausfinden

ein enum kann z.b. sein
enum autoteil
{
tuer = 1,
frontscheibe =2,
motor =4,
reifen =8,
dach = 16
};

und mit
int cabrio = tuer|frontscheibe|motor|reifen;
kombinierst du die flags dann.

//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 :(

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

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

Ciao ...

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