If-Anweisung: auf bekannten/zulässigen Wert überprüfen

Ein herzliches Hallo in die Runde!

Ich muss eine Variable, die die Prozess-Priorität eines zu startenden Prozesses bestimmt ,überprüfen und mir ist leider kein anderer Weg eingefallen als dieser hier:

DWORD prirorityClass; // In winbase.h definierte Prioritäts-Klasse

        // Hier wird irgendwo priorityClass irgendwie initialisiert...

        // Überprüfe auf zulässige/bekannte Prioritäts-Klasse:

	if (priorityClass != ABOVE_NORMAL_PRIORITY_CLASS &&
		priorityClass != BELOW_NORMAL_PRIORITY_CLASS &&
		priorityClass != HIGH_PRIORITY_CLASS &&
		priorityClass != IDLE_PRIORITY_CLASS &&
		priorityClass != NORMAL_PRIORITY_CLASS &&
		priorityClass != REALTIME_PRIORITY_CLASS){

		return false; // unbekannte Prioritäts-Klasse
	}

Kann man diese Sicherheitsabfrage auch irgendwie anderes programmieren?

priorityCLass als enum zu definieren geht leider nicht, da die Variable schon definierte (winbase.h) Werte annehmen muss.

Gibt es in c++ eine If-Anweisung, die Abfragt, ob eine Variable einen von einer bestimmten Menge an Werte besitzt?

Nachtrag:

Diese Variante ist mir noch eingefallen:

switch(priorityClass){

		case ABOVE_NORMAL_PRIORITY_CLASS:
		case BELOW_NORMAL_PRIORITY_CLASS:
		case HIGH_PRIORITY_CLASS:
		case IDLE_PRIORITY_CLASS:
		case NORMAL_PRIORITY_CLASS:
		case REALTIME_PRIORITY_CLASS: break;

		default: return false; 
	}

Habt Ihr eine bessere Idee?

Vielen Dank im Voraus!

Gruß Roger

drakon

Wenn sich die Werte garantiert nie verändern werden, finde ich, kann man das gut so lassen. Anderseits kannst du eine Funktion draus machen, welche innerhalb in einer Schleife alle Werte überprüft und dann true/false zurückgibt.

Pseudocode:

bool check ( value )
{
 for ( jedes element in einer liste)
  if ( value == element )
    return true;

return false; 
}

Sofern die Werte, wie ABOVE_NORMAL_PRIORITY_CLASS usw. schön nacheinander sind, geht das relativ einfach, da du dann diese Werte als Index benutzen kannst, anderseits musst du zuerst ein Array/Liste draus machen.

Hallo drakon,

danke für Deine Antwort.

Extra Funktion hatte ich auch kurz überlegt, aber da ich das nur an einer Stelle brauche, werde ich es wohl so stehen lassen.

Auszug aus der winbase.h:

#define NORMAL_PRIORITY_CLASS             0x00000020
#define IDLE_PRIORITY_CLASS               0x00000040
#define HIGH_PRIORITY_CLASS               0x00000080
#define REALTIME_PRIORITY_CLASS           0x00000100
#define BELOW_NORMAL_PRIORITY_CLASS       0x00004000
#define ABOVE_NORMAL_PRIORITY_CLASS       0x0000800

0

Drehleiter

Weil die Werte durch eizelne Bits dargetellt werden kannst Du sie binär "verodern" und dann mit dem vergleichs Wert binär "verunden" (ungetestet):

if (!(priorityClass &(
         ABOVE_NORMAL_PRIORITY_CLASS |
         BELOW_NORMAL_PRIORITY_CLASS |
         HIGH_PRIORITY_CLASS         |
         IDLE_PRIORITY_CLASS         | 
         NORMAL_PRIORITY_CLASS       | 
         REALTIME_PRIORITY_CLASS
    )))
{ 
    return false; // unbekannte Prioritäts-Klasse 
}

Hallo Drehleiter!

Ja, das ist auch eine elegante Möglichkeit. Da aber die switch-Variante leichter zu lesen ist, werde ich die nehmen.

asc

Roger Wilco schrieb:

Ja, das ist auch eine elegante Möglichkeit. Da aber die switch-Variante leichter zu lesen ist, werde ich die nehmen.

Ich kenne diese Angaben zwar nicht (Arbeite nicht mit der WindowsAPI wenn es sich vermeiden lässt), aber was mich verwundert ist die Binärcodierung. Sowas verwendet man eigentlich nur, wenn mehrere Angaben parallel gesetzt sein können (und dann hilft nur binäre Maskierung beim Vergleich).

cu André

asc schrieb:

..., aber was mich verwundert ist die Binärcodierung. Sowas verwendet man eigentlich nur, wenn mehrere Angaben parallel gesetzt sein können (und dann hilft nur binäre Maskierung beim Vergleich).

cu André

Hi André,

Du hast Recht, es können mehrere Flags parallel gesetzt werden - ich nutze hier aber nur die Flags der Prioritätsklasse und da kann nur eine festgelegt werden.