class UltraLangerKlassenNameDenIchNichtStaendigTippenWill {
public:
  enum Param{cA,cB,cC,cD};
  void DoSomething(Param p);
};

int main ()
{
  UltraLangerKlassenNameDenIchNichtStaendigTippenWill u;
  u.DoSomething(cA); //FEHLER
  u.DoSomething(UltraLangerKlassenNameDenIchNichtStaendigTippenWill::cA); //OK
}

Wie kann ich verhindern dass ich jedesmal das enum qualifizieren muss? Ich hasb mit using UltraLangerKlassenNameDenIchNichtStaendigTippenWill::Param; versucht, aber da meint der Compiler dass UltraLangerKlassenNameDenIchNichtStaendigTippenWill kein Namespace ist.
Gibts ne Moeglichkeit ausser kuerzungs-typedefs, die Tipperei zu umgehen?

Gibts ne Moeglichkeit ausser kuerzungs-typedefs, die Tipperei zu umgehen?

Da fällt mir im Moment kein einfacher ein - obwohl: Du könntest einen Haufen enum-Werte in Konstanten packen, die du außerhalb deiner Klasse angelegt hast.

class kurz
{
public:
  enum Param{cA,cB,cC,cD};
};

class UltraLangerKlassenNameDenIchNichtStaendigTippenWill {
public:

  void DoSomething(kurz::Param p);
};

int main ()
{
  UltraLangerKlassenNameDenIchNichtStaendigTippenWill u;
  u.DoSomething(kurz::cA);

}

Eine weitere möglichkeit wäre eine weitere Klasse zu definiren.

Dann kann er auch gleich nen Namespace namens "kurz" definieren. :p

3. Warum tust du Enums in Klassen? Weil du die Enums zuordnen willst? Macht das nicht schon der Enum-Kopf?????
3.1. Wenn der Enum-Kopf nicht reicht, warum tust du nicht alles in einen Namespace? Auch wenn der lang ist, kann man den mit using kürzen.

Was meinst du mit enum-Kopf? Und wie soll der hier weiterhelfen?

u.cA?

Ist das nicht ausreichend?

typedef UltraLangerKlassenNameDenIchNichtStaendigTippenWill kurz;

Fellhuhn schrieb:

u.cA?

Ist das nicht ausreichend?

doch

Er sagte doch bereits (erster Post) das er keine typedefs will.

Asche auf mein Haupt. Ich hatte es falsch verstanden.

class UltraLangerKlassenNameDenIchNichtStaendigTippenWill {
public:
  enum Param{cA,cB,cC,cD};
  void DoSomething(Param p);
};

int main ()
{
  typedef UltraLangerKlassenNameDenIchNichtStaendigTippenWill U;
  U u;
  u.DoSomething(U::cA);
}

Das ist IMO meist akzeptabel, da dadurch nicht der global-namespace mit typedefs vollgerotzt wird.

@Artchi:
Enum Konstanten kann man leider nicht über den Namen des enums ansprechen, d.h. die sauen einem den Namespace voll in dem man sie definiert. Das ist meist unerwünscht, vor allem wenn das irgendwelche Optionen sind die dann einfach "binary" oder "replace" oder so heissen sollten.
Hat man 2 gleiche Enums im gleichen Namespace die eine enum-Konstante namens "binary" definieren ... geht das schlicht und einfach nicht. Was eben doof ist.
Daher steckt man enums oft in Klassen.
Oft sogar in Dummy-Klassen die nix tun ausser einen Scope für den/die/das Enum bereitzustellen. Also ca. so:

struct FileFlags {
    enum Flags {
       open = 1,
       binary = 2,
       // ...
    };
};