3. konstantes Array aus Strukturen

konstantes Array aus Strukturen

  • P

    Hallo,
    in meinem GUI-Programm kann man die Hintergrundfarben auswählen.
    Es gibt 12 konstante Farben.
    Momentan ist die Farbabfrage (im Programm) wiefolgt gelöst:

    if (farbe == "black"){
red = 0;
green=0;
blue = 0;
} else if( farbe == "white"){
red = 1;
green = 1;
blue = 1;
}else if (farbe ...)
}
draw(red,green,blue,objekt)...

    Ich finde das nicht besonders schön und dadurch wird vorallem der Code stark aufgebläht. Diese Codezeilen kommen nicht nur 1 Mal vor, sondern noch weitere 5 mal... Über die Effizienz kann ich keine Aussage treffen. Da kenne ich mich nicht gut genug aus.

    Meine Idee ist nun, das ganze etwas zu strukturieren und damit lesbarer zu machen:

    // Defines a color
struct color {
	float red;
	float green;
	float blue;
};

// Size of the Color Enum and Array
const int SIZE_OF_MY_COLORS=12;

enum myColors{
	BLACK, WHITE, BLUE, YELLOW, GREEN, PINK, ORANGE, LIGHTGREEN, CYAN, RED, GRAY, PURPLE
};

const int COLORS[SIZE_OF_MY_COLORS];

COLORS[BLACK].red		= 1.0;
COLORS[BLACK].green		= 1.0;
COLORS[BLACK].blue		= 1.0;

COLORS[WHITE].red		= ...
..

GLWidget::main(){
..
draw(COLORS[farbe].red,COLORS[farbe].green,COLORS[farbe].blue);
..
}

    Ich möchte, dass das ganze schon zur compilezeit (ist das der richtige Begriff?) angelegt wird, also nicht in irgendeiner main() oder einem Konstruktor steckt.

    Das ganze kompiliert natürlich noch nicht, aber ich habe trotz längerem Googlen keine Lösung für dieses Problem gefunden.

    Ein weiteres Problem ist auch zu entscheiden, was ich in die Header und was ich in den Sourcefile schreiben soll.

    Und zu guter letzt muss ich noch irgendwie das Problem lösen, dass die farbe als String übergeben wird, in dem Enum soweit ich weiß aber kein String eingesetzt wird. Aber das lässt sich wohl am einfachsten noch lösen.

    Vielen Dank für eure Hilfe

    0
  • S

    Am einfachsten ist eine Struktur mit Non-Type Template-Parametern:

    template<unsigned char R_,
         unsigned char G_,
         unsigned char B_>
struct Colour
{
    static constexpr unsigned char R = R_,//Achtung! Diese Zeile compiliert nur, wenn dein Compiler genug C++11-Unterstützung hat (sonst aus constexpr const machen).
                                   G = G_,
                                   B = B_;

    constexpr Colour() = default;//Achtung! Diese Zeile compiliert nur, wenn dein Compiler genug C++11-Unterstützung hat (sonst weglassen).
};

    Was vielleicht auch nicht schlecht wäre, für eine Struktur die ihre Farbe ändern können soll:

    struct Colour
{
    unsigned char R, G, B;

    Colour(unsigned char const r, 
           unsigned char const g,
           unsigned char const b):
    R(r), G(g), B(b) {}
};

    kaboom!
    Schon kannst du (vorausgesetzt du hast einen C++11-kompatiblen Compiler):

    Colour a;
a = {255, 0, 0};

    o.ä. schreiben, ohne irgendwelche Operatoren zu überladen.

    Ein weiteres Problem ist auch zu entscheiden, was ich in die Header und was ich in den Sourcefile schreiben soll.

    Na, deklarationen in den Header, Definitionen in die Source 😕
    Falls du nicht die Regeln kennst, es gibt einen schönen Beitrag dazu von wxSkip (ich finde in aber gerade nicht).

    Und zu guter letzt muss ich noch irgendwie das Problem lösen, dass die farbe als String übergeben wird, in dem Enum soweit ich weiß aber kein String eingesetzt wird.

    Ja, aber wieso überhaupt?

    Es gibt 12 konstante Farben.

    Dann nimmst du mein Klassentemplate von oben und machst folgendes:

    Header:

    extern Colour<0, 0, 0> black;
extern Colour<255, 0, 0> red;
//....

    Source:

    Colour<0, 0, 0> black;
Colour<255, 0, 0> red;
//...

    Und übergibst so:

    template<unsigned char R, unsigned char G, unsigned char B>
void functionMitFarbparameter(Colour<R, G, B>)
{
    //Hier arbeitest du mit R, G, B
    std::cout << R;
    //....

    Oder das darunter, und machst folgendes:

    Header:

    extern Colour const black;
//...

    Source:

    Colour const black(0, 0, 0);
//...

    Und übergibst einfach call-by-value an die Funktion.

    0
  • I

    Also ein solches Array (Statisches C-Array) wird glaub ich schon in der Compilezeit angelegt.
    Was ist denn die Fehlermeldung?

    (PS: Wenn du deinem Struct einen Konstruktor gibst, kannst du einfach

    COLORS[BLACK] = color(1.0,1.0,1.0);

    schreiben.
    )

    (Außerdem, premature optimisation...)

    0
  • S

    IrgendeinName schrieb:

    Also ein solches Array (Statisches C-Array) wird glaub ich schon in der Compilezeit angelegt.

    Ähm, NEIN.

    Edit: Höchstens so eins:

    constexpr int arr[]{1, 2, 3, ...};
    0
  • P

    puh, erstmal vielen Dank für die ausführliche Antwort.

    Leider habe ich keine Ahnung, was templates sind. Ich werde mich mal in das Thema einlesen.

    0
  • S

    Phys1k3r schrieb:

    Ich werde mich mal in das Thema einlesen.

    Glaub mir, das ist es definitiv Wert!
    Generische Programmierung ist mitunter ein Hauptkonzept von C++.

    Was ich dir empfehle ist: C++ Templates - The Complete Guide
    P.S.: Der Titel verspricht auf keinen Fall zu viel 😉

    0
  • P

    Hey,
    interessant ist das wirklich und irgendwann wird das auch mal gemacht, aber momentan fehlt dazu einfach die Zeit.

    Andere Frage, ich benutze Visual Studio 2008, hat das überhaupt eine c++11 Unterstützung?

    0
  • S

    Phys1k3r schrieb:

    Hey,
    interessant ist das wirklich und irgendwann wird das auch mal gemacht, aber momentan fehlt dazu einfach die Zeit.

    Andere Frage, ich benutze Visual Studio 2008, hat das überhaupt eine c++11 Unterstützung?

    Nö. Das 11 im Namen kommt Schließlich von 2011, und auch wenn einige Features AFAIK schon vorher von Compilern unterstützt wurde (weil sie schon vorher bekannt wurden), ist 2008 wohl noch etwas zu früh.

    Steig doch auf VS2012 um, wo ist das Problem?

    0
  • K

    Hacker uebertreibt mal wieder masslos 🙄

    0
  • S

    Kellerautomat schrieb:

    Hacker uebertreibt mal wieder masslos 🙄

    Wieso? 😞
    Ah, ich sehe was du meinst. 😞 sry

    Btw: Nenn' mich nicht Hacker.

    0

  • Hallo Phys1k3r,

    lass dich nicht von Sone (früher Hacker) verwirren - er meint er wäre der tolle Hecht, weil er jetzt einen C++11 Compiler benutzt.

    Es geht auch ganz einfach (so wie es schon unter C funktioniert hat):

    const int COLORS[SIZE_OF_MY_COLORS] =
{
    { 0, 0, 0 },
    { 1, 1, 1 },
    { 0, 0, 1 },
    // ...
}

    Noch ein Tipp:
    du kannst auch SIZE_OF_MY_COLORS automatisch vom Compiler berechnen lassen:

    enum myColor // Einzahl ist besser als Name (s.u.)
{
    BLACK, WHITE, BLUE, YELLOW, GREEN, PINK, ORANGE, LIGHTGREEN, CYAN, RED, GRAY, PURPLE,
    SIZE_OF_MY_COLORS
};

    Nur für die Konvertierung eines Strings in das entsprechende 'enum' empfehle ich dir std::map zu benutzen:

    #include <map>

std::map<const char*, myColors> myColorMap;

int main()
{
  myColorMap["black"] = BLACK;
  myColorMap["white"] = WHITE;
  // ...
}

    Zugriff auf Map, s. http://www.cplusplus.com/reference/stl/map/find

    (alternativ statt 'const char *' kannst du selbstverständlich auch 'std::string' benutzen)

    0
  • S

    Th69 schrieb:

    lass dich nicht von Sone (früher Hacker) verwirren - er meint er wäre der tolle Hecht, weil er jetzt einen C++11 Compiler benutzt.

    Sag mal bist du bescheuert oder was?

    std::map<const char*, myColors) myColorMap;

    Ich bin sicher, das ist eine einleuchtende Logik. 🙄
    Wenn der Anfänger Templates schon nicht verstehen kann/will, brauchst du ihm nicht gleich einen STL-Container um die Ohren zu hauen, und ihn gleich damit zu konfrontieren. Dazu noch mit syntaktisch falscher Deklaration. Gleich kommt er wieder, weil sein Compiler kryptische Fehlermeldungen ausspuckt.
    Andererseits, wenn schon ne map, dann wieso nicht gleich... std::(tr1::)array ?

    <irony>

    Neeeiin! Das geht doch mit C schon, wieso C++ verstehen wenn es auch mit C-Arrays geht!? Das hört sich nach kompliziertem Blödsinn an, denn Hacker versucht dich zu verwirren und entmutigen! Ja, benutz weiter deine C-"Äquivalente" and never change a running system!

    Und schöne Bezeichner hast du dir da ausgedacht. Da kommt zuerst das oft für metasyntaktische Variablenidentifier genutzte präfix my , dass bestimmt in so gut wie jedem professionellem Projektcode vorkommt. Dann natürlich ohne Präfix die Enumeratoren BLACK , WHITE , usw. genial! Das mann eigentlich ein universales Präfix davorsetzt um Enumeratoren eindeutig als solche und als Enumeratoren einer bestimmten Enumeration zu identifizieren ist C++-Gefrickel und wird dazu auch nur von Anfängern gemacht. Und überhaupt: strongly-typed enumerations erwähnen tun auch nur Forentrolle, nöch? 🙂

    Aber mal abgesehen davon ist dein Konzept einfach umwerfend. Zuerst die Tatsache, dass der mapped_type der map keinerlei Informationen enthält, die nicht schon der String hat. Also Redundanz pur, oder? Nein! Nach wie vor ein Geniestreich!
    Dazu die Tatsache, dass die map erst in der main() befüllt wird! Was für eine Kohäsionsmaximierung!
    Wieso nicht vorschlagen, dass C++11 dank aggregate/uniform-initialisation eine viel schönere Schreibweise bereitstellt?
    Ohh, da haben wir schon wieder das Wort "C++" drinnen, und das wollen wir doch nicht. Also bloß weg damit.

    </irony>

    Edit: Ich merke schon, 90% von dem was ich geschrieben hab' ist Blödsinn. 🙄

    0
  • O

    Sone schrieb:

    Sag mal bist du bescheuert oder was?

    Ich glaube, er ist nicht nur geistig gesund, sondern hat auch Ahnung.

    std::map<const char*, myColors) myColorMap;

    Ich bin sicher, das ist eine einleuchtende Logik. 🙄
    Wenn der Anfänger Templates schon nicht verstehen kann/will, brauchst du ihm nicht gleich einen STL-Container um die Ohren zu hauen

    Siehst du hier eine einfachere Lösung, ohne viel Aufwand,die das Problem des Threaderstellers löst? Komm, raus damit.
    Ausserdem warst du es, der Template Programmierung ins Spiel brachte. Und zwar auf einem wesentlich höheren Anforderungsniveau als "einfach mal std::map verwenden".
    //edit ich würde aber statt const char* wirklich std::string verwenden, sonst gibts komisches Verhalten. Oder nen anderen key-compare verwenden.

    und ihn gleich damit zu konfrontieren. Dazu noch mit syntaktisch falscher Deklaration.

    Als ob du dich niemals vertippt hättest. Lächerlich. Sogar für deine Maßstäbe.

    Andererseits, wenn schon ne map, dann wieso nicht gleich... std::(tr1::)array ?

    1. Weil array das Problem vor C++11 nicht so elegant löst wie ein C-array. Probier es aus. Zeig uns, wie du all diese Farben so kurz definierst, wie durch eine einfache verschachtelte Array-Definition.
    2. Weil array vor C++11 bei keinem Compiler verfügbar sein muss (technical report != standard).

    Der Rest ist einfach nur Schrott und ich hab aufgehört deinen Post nach ca 2 weiteren Sätzen zu lesen.

    0
  • P

    *räusper* contenance...

    0

  • Sone schrieb:

    Am einfachsten ist eine Struktur mit Non-Type Template-Parametern...

    Schwachfug, die eindeutige Fragestellung mit haufenweise Templatemüll zu beantworten.

    Sone schrieb:

    IrgendeinName schrieb:

    Also ein solches Array (Statisches C-Array) wird glaub ich schon in der Compilezeit angelegt.

    Ähm, NEIN.

    Doch, wobei das originale "Array" des Fragers nur ein vermaledeites VLA Zeugs ist, und somit eben nicht zur Compilezeit arbeitet.

    // Defines a color
struct color {
    float red;
    float green;
    float blue;
};

// Size of the Color Enum and Array
const int SIZE_OF_MY_COLORS=12;  // das ist nur eine Laufzeitkonstante, und keine zur Compilezeit bekannte

enum myColors{
    BLACK, WHITE, BLUE, YELLOW, GREEN, PINK, ORANGE, LIGHTGREEN, CYAN, RED, GRAY, PURPLE
};

// hier mal eine Implementierung deines angefragten Arrays
// versuche mal, so globales Zeugs zu minimieren, auch wenn es const ist und es dir zunächst plausibel erscheint
const color COLORS[]={
{1,2,3}, // BLACK
{4,5,6}, // WHITE
{7,8,9}, // BLUE
...
{1,1,1}  // PURPLE
};

int main()
{
...
size_t SIZE_OF_MY_COLORS=sizeof(COLORS)/sizeof(*COLORS);
    0

  • Phys1k3r schrieb:

    Andere Frage, ich benutze Visual Studio 2008, hat das überhaupt eine c++11 Unterstützung?

    Nein, aber zumindest TR1 kannst du für den Compiler mit dem Featurepack noch nachinstallieren, da ist dann auch ein tr1::array Typ dabei:
    http://www.microsoft.com/en-us/download/details.aspx?id=6922

    0

  • Th69 schrieb:

    Noch ein Tipp:
    du kannst auch SIZE_OF_MY_COLORS automatisch vom Compiler berechnen lassen:

    enum myColor // Einzahl ist besser als Name (s.u.)
{
    BLACK, WHITE, BLUE, YELLOW, GREEN, PINK, ORANGE, LIGHTGREEN, CYAN, RED, GRAY, PURPLE,
    SIZE_OF_MY_COLORS
};

    Hübsch aber unrobust und somit für Anfänger ungeeignet.
    Z.B. bei

    enum myColor // Einzahl ist besser als Name (s.u.)
{
    BLACK=1, WHITE, BLUE, YELLOW, GREEN, PINK, ORANGE, LIGHTGREEN, CYAN, RED, GRAY, PURPLE,
    SIZE_OF_MY_COLORS
};

    dürften nur sehr wenige Compiler warnen.

    0
  • P

    Hallo,
    ich habe jetzt den Code von Wutz genommen, da er simpel ist und funktioniert.

    Jedoch verstehe ich den Nutzen dieser Codezeile nicht:

    size_t SIZE_OF_MY_COLORS=sizeof(COLORS)/sizeof(*COLORS);

    Das mit std::map<const char*, myColors) myColorMap; werde ich vielleicht nutzen. Ich muss noch abwägen, ob ich den kompletten Code umschreibe und die Strings komplett herausnehme (was länger dauert, aber sicherlich schöner ist) oder ob ich Zeit spare und Strings weiter verwende.

    0
  • Mod

    Phys1k3r schrieb:

    Jedoch verstehe ich den Nutzen dieser Codezeile nicht:

    size_t SIZE_OF_MY_COLORS=sizeof(COLORS)/sizeof(*COLORS);

    Das ist die Gesamtgröße des Arrays geteilt durch die Größe des ersten Elementes, also die Anzahl der Elemente im Array.

    Arrays zerfallen beim kleinsten Anzeichen von Gefahr zu einem Zeiger auf ihr erstes Element, sogenannter array to pointer decay (Man darf aber nie den Fehler machen, anzunehmen, Arrays und Pointer wären das gleiche!). Daher ist sizeof(*COLORS) ausgeschrieben das gleiche wie sizeof(*&COLORS[0]) . Hingegen ist sizeof(COLORS) eine der wenigen Ausnahmen vom array decay und man erhält die Größe des gesamten Arrays. Insgesamt ist das ein Standardweg, um die Elementzahl eines Arrays zur Compilezeit zu ermitteln, ohne dass man dessen Länge oder Typ kennen braucht.

    ⚠ Achtung: Das geht natürlich nicht, wenn man nur einen Zeiger auf ein Array vorliegen hat. Dann würde man mit sizeof die Größe des Zeigers erhalten. In C++ stellt sich diese Problematik aber in der Regel gar nicht erst, siehe dieser Thread.

    0
  • P

    Hallo,
    das mit den Maps funktioniert soweit auch ganz gut.

    Es ist eigentlich ziemlich simpel und ich denke, ich werde das vorerst so lassen.

    std::map<std::string, int> myColorMap;

    Eine Frage habe ich noch, welche Exception wird geworfen, wenn die Map den String nicht finden kann.

    Ich würde das gerne mit try und catch abfangen.

    Die c++ Reference schreibt etwas von einem Iterator, was mich nicht direkt weiterbringt.

    EDIT: Habe gerade herausgefunden, dass überhaupt keine Exception geworfen wird..
    Naja, erstmal weiter googlen und hoffen, dass hier noch eine einfache Antwort kommt 😞

    EDIT 2:
    habe mir jetzt so einen Code zusammengebastelt:

    Kann man das so durchgehen lassen?

    // This is just for test issues
		std::string string =  "pfgurple";

		if(myColorMap.find(string) != myColorMap.end() )
			cout << "black ==> " << myColorMap.find(string)->second << endl;
		else
			cout << "ColorString was not found in colorMap" << endl;
    0
Anmelden zum Antworten