Flexibler enum



  • Hallo,

    ich komme i.M. hier nicht weiter. Mir fehlt eine Idee um das umzusetzen:

    Ich möchte mit einer Routine 2 Datensätze lesen, wo Farbinformationen ausgelesen werden. Das Problem ist, die Farben haben in den Datensätzen unterschiedlichen Index, z.B. :

    Datensatz 1: 0 = Cyan, 1 = Magenta, 2 = Yellow, 3 = Black

    Datensatz 2: 0 = Black, 1 = Cyan, 2 = Magenta, 3 = Yellow

    enum color
    {
     CYAN,
     MAGENTA,
     YELLOW,
     BLACK
    };
    
    // ... indexColor hat den Wert 0
    if ( indexColor == CYAN )
      {
       // Das past beim DS 1, beim DS 2 würde ich aber hier die falschen Farbwerte,
       // Black auslesen
      }
    

    Ich möchte vermeiden 2 separate Routinen zu schreiben, und suche eine Möglichkeit, das mit einer Routine zu tun, sowas wie einen enum zur Laufzeit zu definieren bzw. zu modifizieren. Ich möchte nicht auf "0" abfragen sondern auf einen Namen z.B. CYAN, damit der Code gut lesbar bleibt. Kann mir hier jemand einen Tip geben ?



  • 1.) Dann kannst du keinen enum benutzen.
    2.) Du musst sowieso zwischen den Datensaetzen unterscheiden.



  • enum color_1
    {
     CYAN_1,
     MAGENTA_1,
     YELLOW_1,
     BLACK_1
    }; 
    
    enum color_2
    {
     BLACK_2,
     CYAN_2,
     MAGENTA_2,
     YELLOW_2
    };
    


  • Wenn für dich die Farbnamen maßgebend sind, musst du auch diese auswerten und nicht andere (sich ändernde) Kriterien, also statt enum besser:

    char *Farben[]={"Cyan","Magenta","Yellow","Black"};
    und dann den (eindeutigen) Index bestimmen mit
    char *gefunden;
    ... Parsen aus Datensatz + Suchen im String-Array ...
    int i = gefunden - Farben;
    


  • Vielen Dank für die Hilfe, aber ich sehe schon dass ich um eine weitere Abfrage und Verzweigung nicht drum herum komme. Manchmal sieht man den Wald vor lauter Bäumen nicht, drum dachte ich hier gibts einen einfachen Weg.



  • enum color
    {
     CYAN,
     MAGENTA,
     YELLOW,
     BLACK
    };
    
    extern int const FR_CMYB[4];
    extern int const FR_BYMC[4];
    
    // In einer .cpp
    
    int const FR_CMYB[] = { 0, 1, 2, 3 };
    int const FR_BYMC[] = { 3, 2, 1, 0 };
    
    // Verwendung
    
    if(indexColor == FR_CMYB[CYAN]) { ... }
    


  • Ist Folgendes zu offensichtlich?

    enum color
    {
     CYAN,
     MAGENTA,
     YELLOW,
     BLACK
    };
    
    typedef int color_indices[4];
    
    void do_sth(const color_indices colors)
    {
    	if (indexColor == colors[CYAN])
    	{
    		//...
    	}
    }
    
    int main()
    {
    	const color_indices c0 = {0, 1, 2, 3};
    	const color_indices c1 = {3, 0, 1, 2};
    	do_sth(c0);
    	do_sth(c1);
    }
    


  • Nachtrag: Vielleicht ist es andersherum besser:

    int FR_CMYB = { CYAN, MAGENTA, YELLOW, BLACK };
    
    ...
    
    if(FR_CMYB[indexColor] == CYAN) { ... }
    

    Das ist aber eine Designfrage.


Anmelden zum Antworten