Switch und #defines

SideWinder

BTW: In C++ definiert man keine Konstanten als Makros, sondern - wer hätte es gedacht - als Konstanten.

static const int QUEUE = 10;

MfG SideWinder

Zunächst ein Hinweis: Die Defines sind sehr unschön. Du kannst das auch mit enum lösen.

enum QID
{
QUEUE_1
QUEUE_5,
};

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

// Verwendung:
QID id;

QNAMES[id];

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?

Nexus

RealMadridHasser schrieb:

Ä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.

RealMadridHasser schrieb:

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.

SideWinder

Allerdings hat er das Problem, dass es auch einen ganzen Haufen von Optionen gibt, die er nicht als Konstante aufzählen will bzw. gar nicht kann!

MfG SideWinder

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, also.

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.

wx++

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

Danke!

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

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?
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?

drakon

RealMadridHasser schrieb:

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

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.