in meinem Projekt möchte ich gerne mehrere Enumerations global deklarieren, die teilweise die gleichen Bezeichnungen enthalten, z.B.:

enum A{eins, zwei};
enum B{eins, zwei, drei};

Das macht allerdings, wie ich festgestellt habe Probleme, da sich A und B in die Quere kommen.
Nun habe ich in einem Beitrag den Tipp gefunden, die enums einfach in einem Struct zu "verstecken", um das Problem zu umgehen. Das habe ich mal in einem einfachen Beispiel versucht:

#include <iostream>

using namespace std;

struct LIST {
	enum NUMBERS {one, two};
	NUMBERS count;
};

int main(){
	LIST a;
	a.count=one;
	return 0;
}

Aber irgendwie gefällt auch dieser Code dem Compiler nicht:

Fehler: »one« wurde in diesem Gültigkeitsbereich nicht definiert

Meine Frage also:
Wie bekomme ich es jetzt hin, dass ich count auch außerhalb von LIST benutzen kann, ohne NUMBERS direkt global deklarieren zu müssen?
Oder gibt es vielleicht eine elegantere Lösung für das ursprüngliche Problem?

Vielen Dank schonmal für eure Hilfe

die lösung für deine variante wäre:

struct LIST // Todo: Capslock entfernen, sonst denkt jeder, dass es ein Makro ist
{
    enum NUMBERS {one, two};
    NUMBERS count;
};

int main()
{
    LIST a; // Todo: Konstruktor implementieren
    a.count = LIST::one; // Todo: Zuweisungsoperator definieren um auf .count verzichen zu können
    // return 0; Wird auch implizit gemacht in C++
}

in c++11 gibt es strongly typed enums.

in c++03 gibt es das safe enum idiom.

#include <iostream>
#include<string.h>

using namespace std;

enum figures {one, two, three};

struct list {
	enum NUMBERS {one, two, three} count;
};

std::string function(list::NUMBERS param){
	switch(param){
		case list::one:return"one";
		case list::two:return"two";
		default: return"Fehler";
	}
}

std::string pattern( figures element){
	switch(element){
		case one: return"one";
		case two: return"two";
		case three: return"three";
		default: return"No element";
	}
}

int main(){
	cout<<"Function:"<<function(list::one)<<endl;
	cout<<"Pattern: "<<pattern(one)<<endl;
}

Soweit alles schön und gut, aber mich stört, dass ich in Zeile 31 immer noch list:: verwenden muss. Ich möchte gerne so, wie in der Vorlage (Pattern) nur das Element eingeben müssen.

Also meine Frage:
Weis jemand, wie ich hinbekomme, dass die Eingaben für meine Übergabeparameter von function und pattern die gleichen sind (also function(one))?

Danke schon mal

namespace Numbers
{
   enum Numbers_t
   {
      One,
      Two,
      Three
   };
}

namespace Figures
{
   enum Figures_t
   {
      One,
      Two
   };
}

void f()
{
   using namespace Figures;

   Figures_t fig = Two;
}

int main()
{
   Figures::Figures_t fig = Figures::One;
   Numbers::Numbers_t num = Numbers::Three;
}

Macht den Code an manchen Stellen schöner, an anderen hässlicher. Und bedeutet etwas mehr Tipparbeit. Wo es keine Mehrdeutigkeiten gibt kann man den Namensraum per using-Direktive sichtbar machen.