Boost Strong Typedef für nicht-primitive Typen

pyhax

Hallo,

gibt es irgendwo so etwas wie http://www.boost.org/doc/libs/1_49_0/libs/serialization/doc/strong_typedef.html für nicht-primitive Typen (Eigene Klassen, STL Container) ?

SeppJ

~~Wie wäre es mit Boost? Ich glaube die haben ein strong typedef Makro im Serialization-Teil.~~

edit: Ich glaube ich hatte nicht genau verstanden, was du meinst.

pyhax

Hab mir jetzt selber was gebastelt: (Leider unterstützt noch kein Compiler inheriting constructors)

#include <iostream>
#include <vector>
#include <type_traits>

template <typename T, typename Id>
struct StrongType : T {
	template <typename Arg, typename ... Args>
	StrongType(Arg&& arg, Args&&... args) : T(std::forward<Arg>(arg), std::forward<Args>(args)...) {}

	template <typename V>
	StrongType(std::initializer_list<V> init) : T(init) {}

	StrongType& operator=(StrongType& const other) {
		T::operator=(other);
	}
};

int main() {
	struct a__{};
	struct b__{};
	typedef StrongType<std::vector<int>, a__> a;
	typedef StrongType<std::vector<int>, b__> b;
	a avec = {1,2,3,4,5,6};
	b bvec = {1,2,3};
	std::cout << avec.size() << std::endl;
	avec = bvec;
}

SeppJ

Dieses hier sollte schon einmal ein Stück weiterhelfen. Das kann man dann auch insgesamt als Makro definieren, dann hat man die gleiche Syntax wie bei Boost:

#include <vector>

template <typename T> struct StrongTypedef : public T
{
  explicit StrongTypedef(const T& t): T(t) {}
  StrongTypedef(): T() {};
  StrongTypedef& operator=(const T &rhs) { T::operator=(rhs); return *this;} 
  operator const T & () const {return *this; }
  operator T & () { return *this; } 
};

typedef StrongTypedef<std::vector<int> > a;

void f(std::vector<int> x);  // (1) function to handle simple integers
void f(a x);    // (2) special function to handle integers of type a 
int main(){
  std::vector<int> x(1);
  a y;
  y = x;      // other operations permitted as a is converted as necessary
  f(x);       // chooses (1)
  f(y);       // chooses (2)
  y.push_back(1);
}

Das sollte funktionieren, solange die Implmentierung in einer abgeleitete Klasse ohne eigene Member keinen zusätzlichen Speicher belegt. Ansonsten stirbt man am möglicherweise nicht-virtuellen Destruktor der Basisklasse. Und man hätte nun noch die wunderschöne Aufgabe, per Templatemagie alle existierenden Operatoren der Basisklasse auch auf die Typedefklasse zu übertragen.

Und vermutlich habe ich irgendwas wichtiges übersehen, da ich nach meiner ersten. falschen Antwort dies hier so hopplahop zusammengeschrieben habe.

edit: Jetzt warst du selber schneller mit der gleichen Idee. In C++11 geht's natürlich eine Nummer schöner, wie du schon siehst.
edit2: Dir fehlt noch ein return bei der Zuweisung.

pyhax

Ja, das return hat mein Compiler mir auch schon gemeldet. Außerdem hatte ich noch einen Schreibfehler:

StrongType& const

SeppJ schrieb:

Und man hätte nun noch die wunderschöne Aufgabe, per Templatemagie alle existierenden Operatoren der Basisklasse auch auf die Typedefklasse zu übertragen.

Mit Boost.Preprocessor sollte das gehen, dazu habe ich im Moment keine Lust