Ich möchte flags innerhalb einer Klasse und innerhalb von Namensräume kapseln.
Das beste was mir da als Lösung eingefallen ist folgendes:

class Klasse
{
  public:
  struct Eigenschaften
  {
     enum
     {
       EigenschaftA = 0;
       EigenschaftB = 0<<0;
       EigenschaftC = 0<<1;
     };
  };

  int eigenschaft;
};

Klasse objekt;
objekt.eigenschaft |= Klasse::Eigenschaften::EigenschaftB;

Gibt es da eine bessere Lösung ohne die Struktur?
Danke für Eure Ratschläge.

wieso im name noch mal eigenschaft?
so würd ichs machen:

struct enum_name
  {
     enum T
     {
       A = 0,
       B = 0<<0,
       C = 0<<1
     };
  };

das die werte ein wenig sinnlos sind, ist dir bekannt?
das erste element hat btw _immer_ den wert 0...

im nächsten standard darf man dann
enum_name::enum_wert schreiben (der msvc konnte das schon immer) - aber im moment ist es nicht standard-konform, wenn man das schreibt - also muss man diesen trick noch ein wenig nutzen^^

bb

meinte natürlich:

enum
{
   EigenschaftA = 0,
   EigenschaftB = 1<<0,
   EigenschaftC = 1<<1,
};

OK, danke.
Echt blöd dass es nicht von vornherein qualifizierte enum-namen gibt.

Japp - das hat man jetzt aber gott sei dank endlich auch erkannt und versucht das nachzurüsten : >
der gcc kann das bestimmt auch schon!?

ich würd dem enum trotzdem einen namen geben - das schadet nie und oft ist es so gar nötig
so könnte man z.bsp. auch einfach ne fkt fuege_eigenschaft_hinzu(enum_name::T wert) schreiben - was ich machen würde

bb

sqrt(-1) schrieb:

OK, danke.
Echt blöd dass es nicht von vornherein qualifizierte enum-namen gibt.

Japp - das hat man jetzt aber gott sei dank endlich auch erkannt und versucht das nachzurüsten : >
der gcc kann das bestimmt auch schon!?

Der ICC kann es, meckert aber.

ich würd dem enum trotzdem einen namen geben - das schadet nie und oft ist es so gar nötig
so könnte man z.bsp. auch einfach ne fkt fuege_eigenschaft_hinzu(enum_name::T wert) schreiben - was ich machen würde

Nur dann kann ich doch keine bit-Operatoren nutzen?

ich würd dem enum trotzdem einen namen geben - das schadet nie und oft ist es so gar nötig
so könnte man z.bsp. auch einfach ne fkt fuege_eigenschaft_hinzu(enum_name::T wert) schreiben - was ich machen würde

Nur dann kann ich doch keine bit-Operatoren nutzen?

das versteh ich nicht...

struct enum_name
{
  enum T
  {
    nothing,
    a = 1<<0,
    b = 1<<1,

    default = nothing
  };
};

#include <iostream>

struct foo
{
public:
  void add(enum_name::T to_add)
  {
    foo_ |= to_add;
  }

  void print()
  {
    if(foo_ & enum_name::a) std::cout << 'a';
    if(foo_ & enum_name::b) std::cout << 'b';

	std::cout << std::endl;
  }

  foo()
  : foo_(enum_name::default)
  {}
private:
  int foo_;
};

int main()
{
  foo bar;
  bar.add(enum_name::a);
  bar.print();
}

so mein ich das...

bb