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

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

#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;
}

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

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