Anonymous Enum VS static const Member

volkard

Keine Begründung?

dir sollte reichen, daß ich es so meine. du kommst dann schon selber auf begründungen, wenn du weißt, was das ergebnis ist.

Und sag jetzt net weil du das gesagt hast

muss wohl wieder ein wenig an meinem namen arbeiten.

es geht um
static size_t const PAGESIZE=4096;

das soll ein size_t sein. man will auch mit ihm rechnen können. es soll kein int sein. benutzt man irgendwann man typeof (oder auto) wie in for(typeof(Page::PAGESIZE) i=0;i!=Page::PAGESIZE;++i), hätte ich in meiner schleife genau den richtigen typ. mit eurem enum-geraffele, habt ihr nur schätztypen oder mußt mit lokalen typedefs nachrüsten oder das problem ignoriren oder java benutzen, weil es da keine probleme gibt. alles suboptimal.

so müsste es auch gehen, bei integers.

struct foobar
{
  static int const ANumber = 10;
};

volkard

vielleicht. schrieb:

so müsste es auch gehen, bei integers.
struct foobar
{
  static int const ANumber = 10;
};

ich ging davon aus, daß das mit 1 gemeint war.
war das gemeint?

evilissimo

Es ist generell gemeint es können auch durch aus mehrere sein, man weiß ja nie, für was man das braucht. Aber ich denke das man konsequent sein sollte und halte es daher für irrelevant ob es nun um einen Wert oder mehrere geht.

MfG

finix

Kommt wohl ganz auf den Verwendungszweck an. Wenn der enum-Wert "für sich alleine steht", als einzelne Konstante, das enum sozusagen als static const int Ersatz ist offensichtlich ( ) Variante 1 zu bevorzugen (IMO). Das scheint ja genau der Fall zu sein nach dem du fragst (korrigier mich falls nicht ).

Und der berühmte "enum-Hack" ist eigentlich nur für solche Fälle:

struct foo
{
  enum { size_of_something = 42 };
  // ...
  int whatever[size_of_something];
};

Wo du also bei der Deklaration schon einen bekannten, konstanten Wert benötigst; aber selbst in diesem Fall: wenn es dein Compiler unterstützt würde ich den static const int Wert direkt im Header definieren.

Das Beispiel macht auch schön einen weiteren Vorteil deutlich - wenn du bei der Deklaration den Wert noch nicht brauchst hast du die Definition des Wertes schön in der Implementationsdatei, musst also den Header nicht ändern um am Wert herumzuschrauben.

evilissimo

finix schrieb:

Das Beispiel macht auch schön einen weiteren Vorteil deutlich - wenn du bei der Deklaration den Wert noch nicht brauchst hast du die Definition des Wertes schön in der Implementationsdatei, musst also den Header nicht ändern um am Wert herumzuschrauben.

Dann könnte ich auch Template Parameter verwenden wenn ich mir nicht schlüssig bin, und kann dann den Wert einsetzen wenn ich es für richtig halte

finix

evilissimo schrieb:

finix schrieb:

Das Beispiel macht auch schön einen weiteren Vorteil deutlich - wenn du bei der Deklaration den Wert noch nicht brauchst hast du die Definition des Wertes schön in der Implementationsdatei, musst also den Header nicht ändern um am Wert herumzuschrauben.

Dann könnte ich auch Template Parameter verwenden wenn ich mir nicht schlüssig bin, und kann dann den Wert einsetzen wenn ich es für richtig halte

Kannst du diesen Trick kurz näher erläutern? Interessiert mich brennend...

edit:
Kurz zur Erläuterung...

// foo.hpp
struct foo
{
  static const int bar;
};

// foo.cpp
const int foo::bar(42);

So, weil foo so toll ist hast du es in ~2mio anderen Klassen und Funktionen verwendet, welche natürlich alle von foo.hpp abhängig sind.
Ändert sich jetzt foo::bar, musst du lediglich foo.cpp neu kompilieren, linken, fertig.

Mit dem enum müsstest du auch alle anderen neu kompilieren.

Mit nem int oder was auch immer als Template Parameter - naja, das wäre, offensichtlich, eine ganz andere Situation...

evilissimo

template < int ArraySize >
  struct foo
  {
    // ...
    int whatever[ArraySize];
  };

finix

Nur weil sie so toll sind muss man ja nicht gleich aus allem ein Template machen.. davon ab, wie kommst du jetzt von außen an ArraySize?

Aber ich meinte eigentlich auch den Fall, siehe oben & meinen ursprünglichen Post, den genau umgekehrten Fall, wenn du den Wert nicht gleich brauchst

evilissimo

Nun gut, man kann das so machen:

template < int ArraySize >
  struct foo
  {
    // ...
    const int get_size(){return ArraySize;}
    int whatever[ArraySize];
  };

Ja mir ist klar das Templates nicht das Allheilmittel sind. Ich spiele gerne damit rum aber verwenden tue ich sie nicht wirklich oft ( mal von boost und der STL abgesehen )

Es war ja nur eine weitere Möglichkeit die größe anzugeben wenn man sich nicht schlüssig ist. Das wollte ich damit nur zeigen.

BR