Veränderliche Variable in Switch Anweisung?

[Tio T. (misterten)]

Hallihallo,

ich habe so etwas wie

void test(void)
{   static unsigned char wert, offset;

    switch (wert)
    {   case 1: [..]
                break;

        case (1 + offset): [..]
                break;
    }
}

Leider bekomme ich dabei die Fehlermeldung

case label does not reduce to an integer constant

. Ich würde es ja verstehen, wenn meine Variable auch eine Konstante 
wäre, ist sie aber nicht. Habe auch schon versucht, diese global zu 
deklarieren, hat aber die gleiche Fehlermeldung gebracht.

Kann ich das nur mit einer If Abfrage lösen? Oder wie kann ich das doch 
noch mit der switch Anweisung klären? Ist mir übersichtlicher und 
sicherer, habe schon 10 Switch-Werte...

Grüße

[Klaus F. (kfalser)]

case (1 + offset): [..]

ist die Zeile mit dem Problem.
Die Fehlermeldung sagt es schon: der angegebene Wert nach dem case muss 
eine Konstante sein.
Wenn deine Vergleichewerte wirklich veränderlich sind, dann mußt Du es 
mit einer if..else Kette lösen.

[Stefan E. (sternst)]

Tio T. schrieb:

> Ich würde es ja verstehen, wenn
> meine Variable auch eine Konstante wäre, ist sie aber nicht.

Hä? Es ist doch genau das Problem, dass es keine Konstante ist. Ein 
case-Label muss eine Compiletime-Konstante sein.

[Tio T. (misterten)]

Schade, hatte ich schon befürchtet. Naja, wollte mal sicher gegangen 
sein. Danke!!! :-)

[Tio T. (misterten)]

@Stefan: Achsoo... Okay, werde wie gesagt meinen großen Switch Absatz 
umschreiben müssen... heul Aber macht ja Spaß sowas. :D

[Ralf (Gast)]

Hallo,
man kann natürlich innerhalb des Switch-Kontext eine Default Anweisung 
angeben und innerhalb der Default-Anweisung eine if then else Abfrage 
platzieren.

switch {wert}
{
 case 1:
 break;

 case 2:
 break;

 default:
  if(...){
  }else{
   (...)
  }
 break;

}

[Matthias L. (Gast)]

case 1:

case (1 + offset):

Wie unterscheidest du zwischen den beiden CASE, wenn offset=0 ist ?

[Ralf (Gast)]

Hier geht es ja unter anderem auch darum die Übersichtlichkeit zu 
bewahren.
Dies kann man dadurch erreichen, dass der berechnete Teil in der 
Default-Anweisung steht. Es ist darauf zu achten, dass es keine 
Überschneidung bei den Defaultwerten zu den berechneten Werten gibt, 
dies sollte man im Vorfeld sicherstellen. Wenn es trotzdem zu einer 
Überschneidung kommt, haben die definierten Werte Priorität.

[Klaus W. (mfgkw)]

je nachdem, welche Werte vorkommen, hilft vielleicht eine
Krücke dieser Art:

void test(void)
{   static unsigned char wert, offset;

    // für die festen Werte:
    switch (wert)
    {   case 1: [..]
                break;
        // ...
    }
    // für die restlichen:
    switch (wert-offset)
    {   case 1: [..] // wert == 1 + offset
                break;
        // ...
    }
}

[Tio T. (misterten)]

Ja, sieht gut aus. Oder, was mir auch noch einfällt:

void test(void)
{   static unsigned char wert, offset;

    switch (wert)
    {   case 1: //..
                break;

        case 2: switch (offset)
                {   case 1: //..
                            break;
                }
                break;
    }
}

Hintergrund des Ganzen: Der Wert Offset spielt nur genau dann eine 
Rolle, wenn der Wert einen einzigen, bestimmten Wert hat. Daher würde 
ich das nicht in den Default-Zweig unterbringen wollen.


@Matthias: Du hast Recht. Wenn Offset denn dann Null wäre hätte die 
Switch Anweisung einen doppelten Fall, was nicht zulässig ist. Ich hatte 
gehofft, den Compiler dahin gehend auszutricksen, als dass ich im 
vorangehenden Code schon dafür gesorgt hätte, dass Offset nie Null 
werden kann.

[Karl H. (kbuchegg)]

Tio T. schrieb:
> @Matthias: Du hast Recht. Wenn Offset denn dann Null wäre hätte die
> Switch Anweisung einen doppelten Fall, was nicht zulässig ist. Ich hatte
> gehofft, den Compiler dahin gehend auszutricksen, als dass ich im
> vorangehenden Code schon dafür gesorgt hätte, dass Offset nie Null
> werden kann.

Was Matthias meinte war die Begründung, warum die Sprache fordert, dass 
es sich um Konstante handeln muss und diese eindeutig sein müssen.

Das du dafür sorgst, dass dieser 'Doppelfall' nicht auftreten kann ist 
zwar löblich, aber der Compiler kann das nicht überprüfen. Der macht ja 
keine Auswertung welche Logik du fabriziert hast.