ich brauche ein (unterscheidbares) typedef für mehrere typen:
tag, monat, jahr.

ich suche eine elegantere lösung, als 3 klassen mit jeweils 20 selbst überladenen operatoren zu schreiben. (auch mit makros fällt mir da nichts eleganteres ein)
was nicht geht, sind einfache typedefs, da auch folgendes gehen sollte:

struct date_t
{
  day_t day;
  month_t month;
  year_t year;

  date_t& operator+=(day_t to_add);
  date_t& operator+=(month_t to_add);
  date_t& operator+=(year_t to_add);
};

hat jmd ne bessere idee als die 3 klassen mit je 100den zeilen?

bb

hat jmd ne bessere idee als die 3 klassen mit je 100den zeilen?

Such mal nach boost's BOOST_STRONG_TYPEDEF, das dürfte in deine Richtung gehen

mit anderen worten: es gibt keine elegante möglichkeit?!

Elegant ist Geschmackssache. Ich halte das Ding für recht elegant, auch wenns ein Makro ist

unskilled schrieb:

mit anderen worten: es gibt keine elegante möglichkeit?!

Elegant ist Geschmackssache. Ich halte das Ding für recht elegant, auch wenns ein Makro ist

neja... ich verwende dann nur dafür boost _und_ muss trotzdem noch mathematische operatoren (wie z.bsp. op%) überladen.
gefällt mir alles nicht aber werds wo einfach nachbauen müssen

bb

neja... ich verwende dann nur dafür boost _und_ muss trotzdem noch mathematische operatoren (wie z.bsp. op%) überladen.

warum? dafür gibts doch den eingebauten Konvertierungsoperator? Oder welche mathematischen Operatoren meinst du?

(btw., wenn du doch mathematische Operatoren implementieren musst, schau dir boost.Operators an, gibt auch einen Artikel im Magazin...)

(btw., wenn du doch mathematische Operatoren implementieren musst, schau dir boost.Operators an, gibt auch einen Artikel im Magazin...)

muss ich nicht. muss nur dafür sorgen, dass die vorhandenen aufgerufen werden. boost.operators kenn ich.

jo, klar. wenn ich den einfach überlade und darauf hoffe, dass er verwendet wird, kann sich der compiler nicht zwischen dem built in op und dem (nicht vorhandenen) op entscheiden.
und ich mag nicht (als nutzer der "lib") jedes mal von hand konvertieren müssen, wenn ich rechnen möchte...

hier noch mal kurz die anforderungen:

//jeweils integrale datentypen
//operatoren: ++, --, +, -(binär), *, /, %
//operatoren: ==, !=, <, <=, >=, >
day_t;
month_t;
year_t;

//darüber hinaus müssen die typen unterscheidbar sein:
void foo(month_t);
void bar(year_t);

ich brauche also nen strong-typedef, dass alle operatoren des zu grunde liegenden numerischen typs aufruft.
wie ein strong_typedef , welches von ordered_euclidian_ring_operators oder so ableiten müsste. nur eben, dass ich dann noch immer operatoren wrappen müsste.
also bau ich mir einfach ne wrapper-basis-klasse, von der ich die 3 typen erben lasse.

bb

template<class BASE, class NUM_TYPE>
struct wrapper
{
  wrapper(NUM_TYPE value_) : value(value_) {}

  friend bool operator==(BASE lhs, BASE rhs) {return lhs.value == rhs.value;}
/*...*/
private:
  NUM_TYPE value;
};

struct type : wrapper<type, unsigned>
{
  type(unsigned value_) : wrapper<type, unsigned>(value_) {}
};

bis auf die tatsache, dass gcc mit -Weffc++ nun warnt, weil wrapper keinen virtuellen dtor hat, aber aus irgend nem grund glaubt, dass das jede (öffentliche) basisklasse bräuchte. ziemlich gut^^

bb