Enthaltene enums

Barade

Barade

Kellerkind
Mal wieder eine kurze Frage:
Ist das hier:
Code:
class MyClass
{
 static const int myValue = 100;
};
Und das hier:
Code:
class MyClass
{
 enum
 {
   int myValue = 100;
 };
};
Von der Bedeutung her das Gleiche?
Ich lese gerade ein Qt-Buch und kann mich nicht mehr genau an die Bedeutung unbezeichneter Enums erinnern. In den Code-Beispielen werden für Konstante Werte der Klasse immer solche enums verwendet, deshalb wollte ich mich nur nochmal vergewissern.
 
Die zweite Konstruktion habe ich noch nie gesehen; zudem läßt sie sich bei mir auch nicht übersetzen - und wie ich finde, aus gutem Grund.

Zuerst mal ein Praxisbeispiel zur ersten Box:
Code:
class Math {
  public:
      static const double PI = 3.14159265358979323846;
};
In Objekten vom Typ 'Math' soll eine Konstante Math.PI hinterlegt werden.
  • Weil das Ding static ist, wird für die Variable nur einmal Speicherplatz angelegt; alle Objekte sehen auf diese eine Variable, was in diesem Fall Platz spart.
  • Weil const vereinbart wurde, werden Maßnahmen getroffen, daß man nicht einfach den Wert verändern kann.

Nun ein Beispiel zum Sinn von vordefinierten enums:
Code:
  1 #include <iostream>
  2 using namespace std;
  3
  4 class Integer {
  5 public:
  6     typedef enum {
  7         s8  = 127,
  8         u8  = 255,
  9         s16 = 32767,
 10         u16 = 65536
 11     } Type;
 12
 13     Integer(Type t) {myType = t; myValue = 0;}
 14     Type type() const {return myType;}
 15     void setType(Type t) {myType=t;}
 16
 17 private:
 18     Type myType;
 19     long myValue;
 20 };
 21
 22 int main()
 23 {
 24     Integer i(Integer::s8);
 25     if (i.type() != Integer::s8) {
 26         return EXIT_FAILURE;
 27     }
 28     cout << "Mein Maxwert ist " << i.type() << endl;
 29 }
Der Compiler kann bei den vorliegenden Methoden Typprüfung durchführen. Zudem wird überwacht, daß nur gültige Werte übergeben werden. Der Wert von i.type() entspricht zudem den Maximalwert des Datentypes und kann daher mit cout ausgegeben werden.
 
Mein Fehler.
Der int-Ausdruck muss natürlich weggelassen werden.
Es wurde auch nur für int-Konstanten verwendet.
Bzw. wenn ich
Code:
class MyClass
{
 public:
  enum Colour
  {
    blue,
    green,
    yellow
   };
};
schreibe, kann ich dann das Enum Colour über MyClass.Colour verwenden?
So wie ich deinen Code verstanden habe, machst du einfach eine Typedefinition, um direkt einen Namen für das Enum zu verwenden.
 
Die Typdefinition sorgt lediglich dafür, daß der Typ Type bei der Deklaration des Konstruktors und der gezeigten set- und get-Methoden als Rückgabewert oder Parameter bekannt ist. Da es sich bei einem enum um einen int-Wert handelt, funktioniert der folgende Code auch:
Code:
  1 #include <iostream>
  2 using namespace std;
  3
  4 class MyClass
  5 {
  6 public:
  7     enum Colour {
  8         blue,
  9         green,
 10         yellow
 11     };
 12     int colorIntValue(int i) {return i;}
 13
 14 };
 15
 16 int main()
 17 {
 18     MyClass c;
 19     cout << c.colorIntValue(MyClass::blue) << endl;
 20 }
Das hier zeigt aber das Problem, das man sich jetzt eingehandelt hat:
Code:
  1 class MyClass {
  2 public:
  3     enum Colour {
  4         blue,
  5         green,
  6         yellow
  7     };
  8     enum Size {
  9         small,
 10         normal,
 11         huge
 12     };
 13     void setColour(int c) {myColour = c;}
 14 private:
 15     int myColour;
 16 };
 17
 18 int main()
 19 {
 20     MyClass c;
 21     c.setColour(MyClass::small);
 22 }
In Zeile 21 wurde als Farbe 'small' gesetzt, obwohl 'small' keine Farbe sondern eine Größe ist. Da die Typen für Farbe und Größe aber nicht bekannt sind, kann der Compiler keine Prüfungen durchführen.
 
Zuletzt bearbeitet:

Ähnliche Themen

Keine grafische Oberfläche (Debian Installation)

GB-errinerung in QT hat Speicherzugrifsfehler

Samba Ordner&Rechte struktur Hilfe!

Speicherproblem?

smile chat: Eine Mehrbenutzer-Netzwerkanwendung in C++ und Java

Zurück
Oben