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

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.

(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...)

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

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

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

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

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?

Hacker uebertreibt mal wieder masslos

Wieso?
Ah, ich sehe was du meinst. sry

Btw: Nenn' mich nicht Hacker.

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)

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.

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.

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

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

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.

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.

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.

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;

Warum wurde der Link zum Buch immer noch von keinem Mod entfernt? So wird er nur weiter dupliziert (schon 4 Posts mittlerweile)...

Immer mit der Ruhe, ein alter Mann ist kein D-Zug Wikipedia-Löschadmin.

Der Offtopicteil und alle Links zweifelhafter Legalität sollten nun vollständig entfernt sein.

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;

Ja, das geht wunderbar. Allerdings ist es ein kleines bisschen ineffizient, weil du zwei mal den selben String suchst, den du doch schon beim ersten mal gefunden hast, mach es in Zukunft lieber so:

std::map<char const*, myColor>::const_iterator iter = myColorMap.find(string); ///Tja, hättest du einen C++11-kompatiblen Compiler, könntest du einfach auto benutzen :p
if(iter != myColorMap.end() )
        cout << "black ==> " << iter->second << endl;
else
        //..

zerärgert schrieb:

Warum wurde der Link zum Buch immer noch von keinem Mod entfernt? So wird er nur weiter dupliziert (schon 4 Posts mittlerweile)...

Immer mit der Ruhe, ein alter Mann ist kein D-Zug Wikipedia-Löschadmin.

???
Ich dachte du bist 30?

SeppJ schrieb:

zerärgert schrieb:

Warum wurde der Link zum Buch immer noch von keinem Mod entfernt? So wird er nur weiter dupliziert (schon 4 Posts mittlerweile)...

Immer mit der Ruhe, ein alter Mann ist kein D-Zug Wikipedia-Löschadmin.

???
Ich dachte du bist 30?

Werd mal 30 und dann beurteile das nochmal

Sone schrieb:

SeppJ schrieb:

zerärgert schrieb:

Warum wurde der Link zum Buch immer noch von keinem Mod entfernt? So wird er nur weiter dupliziert (schon 4 Posts mittlerweile)...

Immer mit der Ruhe, ein alter Mann ist kein D-Zug Wikipedia-Löschadmin.

???
Ich dachte du bist 30?

Werd mal 30 und dann beurteile das nochmal

Ich weiß nicht, ob du mir jetzt Leid tun sollst