simpler wrapper um built in type

unskilled

hallo,

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

pumuckl

unskilled schrieb:

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

unskilled

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

pumuckl

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

unskilled

pumuckl schrieb:

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

pumuckl

unskilled schrieb:

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

unskilled

pumuckl schrieb:

(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

unskilled

so wie beschrieben klappts ganz gut. sind zwar auch wieder paar unnötige zeilen, aber naja...
sieht jetzt in etwa so aus:

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