Ich habe zum einen Mal ein par #define:

#define QUEUE       10
#define QUEUE_5     20
#define QUEUE_SKY   30
...

und dann habe ich noch eine Klasse, die unter anderem eine ID und einen Namen hat. Der Ctor sieht so aus:

Group::Group(uint groupID) : mGroupID(groupID) {
   switch(groupID) {
      case QUEUE_1:
         mName = "QUEUE_1";
	 break;
      case QUEUE_2:
         mName = "QUEUE_2";
         break;

      ...
      default:
         std::stringstream ss;
	 ss << groupID;
	 name = "QUEUE" + ss.str();
         break;
}

Die Logik dahinter:
Wenn die an den Ctor übergebene ID eine der vordefinierten IDs ist, soll der Name gleich dem #define Namen lauten. Ansonsten soll der Name QUEUE_%id lauten.

Mein Code klappt natürlich, aber das riesige switch ist irgendwie etwas unelegant. Geht das in C++ eleganter/kompakter?

Danke!

MfG SideWinder

static const int QUEUE = 10;

MfG SideWinder

enum QID
{
QUEUE_1
QUEUE_5,
};

const char * QNAMES[] = { "QUEUE_1", "QUEUE_5" };

// Verwendung:
QID id;

QNAMES[id];

Was ist an den #defines so schlimm? Woher weiß ich jetzt, ob ich jetzt echte konstanten (const) oder enum nehmen soll?
Fakt ist: Ich brauche keinen extra Typ für die Konstanten, sprich es wird niemals sowas geben:

void methode(QueueID id);

Wann immer man eine id angeben soll, wird es ein reiner integer sein:

void methode(int id);

Nur sollen eben bestimmte ids vordefiniert sein. In meinem Fall wäre ein enum überflüssig, da ich den Typ ja nie brauche. Oder? Ändere ich am besten meine #define in static consts um?

Ändere ich am besten meine #define in static consts um?

Ob static oder nicht, hängt von der gewünschten Speicherklasse ab, extern wäre eine Alternative. Aber Konstanten sind definitiv angebracht. Makros sind dumme Textersetzungen, die keine Debugsymbole haben und alle Scopes verdrecken. Sie können zwar sehr nützlich sein, aber wenn es Alternativen gibt (typsichere Funktionen und Konstanten), solltest du sie nutzen.

Danke für die schnellen Antworten!

Was ist an den #defines so schlimm? Woher weiß ich jetzt, ob ich jetzt echte konstanten (const) oder enum nehmen soll?
Fakt ist: Ich brauche keinen extra Typ für die Konstanten, sprich es wird niemals sowas geben:

void methode(QueueID id);

Wann immer man eine id angeben soll, wird es ein reiner integer sein:

void methode(int id);

Nur sollen eben bestimmte ids vordefiniert sein. In meinem Fall wäre ein enum überflüssig, da ich den Typ ja nie brauche. Oder? Ändere ich am besten meine #define in static consts um?

Im Prinzip kannst du sowohl const als auch enum verwenden. Allerdings kannst du mit enum einige Fehler ausschließen. Stell dir vor, du hast ganz viele solcher Konstanten für verschiedene Dinge:

const int STATUS_PROGRAM_OK = 0;
const int STATUS_PROGRAM_ERROR = 1;
const int STATUS_PROGRAM_UNKNOWN = 2;

const int STATUS_SERVER_RUNNING = 0;
const int STATUS_SERVER_ERROR = 1;
const int STATUS_SERVER_UNKNOWN = 2;

// usw..

Zusätzlich hast du eine Funktione zum Setzen des Status vom Program und vom Server:

void setProgramStatus(int status);
void setServerStatus(int status);

Jetzt kannst du diese Funktion ganz normal aufrufen und den Status damit setzen:

setProgramStatus(STATUS_PROGRAM_OK);

Nehmen wir an, du hast nun die ganze Zeit mit den Stati von Programm gearbeitet und musst aber nun den Teil für den Serverstatus programmieren. Aus inzwischen gewordener Gewonheit machst du ausversehen:

setServerStatus(STATUS_PROGRAM_ERROR); // Richtig wäre  STATUS_SERVER_ERROR

Damit wäre das erste Problem von Konstante klar: Es findet keine Überprüfung statt, ob es für diesen Zweck auch die korrekte ist. Man kann ja alles übergeben. Zweites Problem erkennt man bei der Deklaration der Konstanten. Man muss selber den Zahlenwert vorgeben. Beide Probleme lassen sich mit enum lösen:

enum ProgramStatus
{
 STATUS_PROGRAM_OK,
 STATUS_PROGRAM_ERROR,
 STATUS_PROGRAM_UNKNOWN
};

enum ServerStatus
{
 STATUS_SERVER_RUNNING,
 STATUS_SERVER_ERROR,
 STATUS_SERVER_UNKNOWN
};

void setProgramStatus(ProgramStatus status);
void setServerStatus(ServerStatus status);

Man kann nun nicht mehr ausversehen den Status des Servers als STATUS_PROGRAM_OK setzen.

MfG SideWinder

const int var = wert;

Define ist deshalb nicht schön, da keine Typüberprüfung stattfindet. Das kann zu mysteriösen Fehlermeldungen führen, usw.

Was ich nicht gelesen habe ist, dass du nur die von dir beschriebenen Werte vordefinieren willst. In dem Fall musst du zwangsläufig mit Konstanten arbeiten

Wieso das?

enum QID
{
   QUEUE = 10,
   QUEUE_5 = 20,
   QUEUE_SKY = 30
};

Ich denke ich werde normale Konstanten (const) nehmen. Dazu noch ein paar Fragen:

1. Auf globaler Ebene bedeutet static, dass die Variable nur in dieser UE zugreifbar ist, oder? Definiere ich dann die static variable im header oder in der .cpp datei?

2. Das static ist ja nicht wirklich erforderlich, oder? Sagen wir ich will eine normale non-static konstante. Dann schreibe ich in den Header das:
   extern const int foo;
   und in die cpp datei das:
   const int foo = 2;
   Stimmt das?

1. Auf globaler Ebene bedeutet static, dass die Variable nur in dieser UE zugreifbar ist, oder? Definiere ich dann die static variable im header oder in der .cpp datei?

Ja, da static interne Bindung erzeugt. (nur in der aktuellen Übersetzungseinheit sichtbar)
Du deklarierst die Variable im Header und definierst sie in einer .cpp.
Im Header:

extern int foo; // Deklaration von foo, da extern gebunden

.cpp:

int foo = 2; // Definition, externe Bindung

2. Das static ist ja nicht wirklich erforderlich, oder? Sagen wir ich will eine normale non-static konstante. Dann schreibe ich in den Header das:
   extern const int foo;
   und in die cpp datei das:
   const int foo = 2;
   Stimmt das?

static bewirkt ja genau das Gegenteil von extern. static erzeugt interne Bindung.