ich habe eine vektor-klasse die als tempalte argument den typ der einträge und die dimensionen als unsigned erwartet. soweit sogut. es wäre für den nutzer konfortabler wenn er schreiben könnte:

vec<float, 3> myvec(5.f, 2.f, 8.f); // kein c++11 daher keine initialiser list
myvec.x = myvec.z - myvec.y; //xyz kommen nur bei vec<T, 3> vor (analog bei 2 und 4)

bedeutet dass ich für alle vec's mit der dimension 3 alle alten member und methoden haben möchte aber zusätzlich einen konstruktor und drei referenzen. wie ist das am einfachsten zu lösen ohne redunanten code?

und auch wenn ein trick von mehreren compilern unterstützt wird würde ich ihn dennoch lieber nicht verwenden, solange er nicht standardkonform ist.

Dann kannst du spezialisiert auf 2d-, 3d- oder 4d-Vektoren Funktionen x(), y(), z() und w() anbieten, die eine Referenz auf das Arrayelement zurueckliefern.

als globale funktionen? die idee gefällt mir. make_vec als globale funktion ist sicher auch nicht schlecht, kann der compiler eh wegoptimieren...

danke dir, auf den weg bin ich nicht gekommen, ich bin immer so beschränkt auf methoden...

#include <iostream>

template <typename T, std::size_t N> 
struct ref_t : public ref_t<T,3>
{
	typedef ref_t<T,3> base;

	template <std::size_t NN>
	ref_t (T (&val)[NN] ) : base(val) {}
};

template <typename T>
struct ref_t <T, 0> 
{
	T& x;

	template <std::size_t N>
	ref_t (T (&val)[N]) : x(val[0]) {}
};

template <typename T>
struct ref_t <T, 1> : public ref_t <T, 0>
{
	typedef ref_t<T,0> base;

	T& y;

	template <std::size_t N>
	ref_t (T (&val)[N]) : base(val), y(val[1]) {}
};

template <typename T>
struct ref_t <T, 2> : public ref_t <T, 1>
{
	typedef ref_t<T,1> base;

	T& z;

	template <std::size_t N>
	ref_t (T (&val)[N]) : base(val), z(val[2]) {}
};

template <typename T>
struct ref_t <T, 3>  : public ref_t<T, 2>
{
	typedef ref_t<T,2> base;

	T& w;

	template <std::size_t N>
	ref_t (T (&val)[N]) : base(val), w(val[3]) {}
};

template <typename T, std::size_t N>
struct my_vec_impl
{
	T value[N];
};

template <typename T, std::size_t N>
class my_fancy_vec : my_vec_impl<T,N>, public ref_t<T,N-1>
{
public:
	typedef my_vec_impl<T,N> 	storage;
	typedef ref_t <T, N-1> 		fancy_bussines_stuff;

// 	using fancy_bussines_stuff;

	my_fancy_vec () : storage(), fancy_bussines_stuff(storage::value) {}

	//...

	T&       operator[] (std::size_t n)        { return storage::value[n]; }
	const T& operator[] (std::size_t n) const  { return storage::value[n]; }

	T*       begin()       { return storage::value; }
	const T* begin() const { return storage::value; }

	T*       end()       { return storage::value+N; }
	const T* end() const { return storage::value+N; }
	//...
};

int main()
{
	my_fancy_vec<double, 10> vector;

	vector.x = 3.11;
	vector.y = 3.12;
	vector.z = 3.13;
	vector.w = 3.14;
	vector[4]= 3.15;
	vector[5]= 3.16;
	vector[6]= 3.17;
	vector[7]= 3.18;
	vector[8]= 3.19;
	vector[9]= 3.20;

	for (auto& iter : vector )
	{
		std::cout << iter << std::endl;
	}

	return 0;
}

Vllt ein bissl umständlich

Code bloat in Reinform, uebererfuellt, warum nicht gleich was absolut generelles wie type_traits aus boost::geometry ...

ich dachte eher an:

template<typename T>
struct vec<T, 3>
{
    std::array<T, 3> ele;

    T& x()
    {
       return ele[0];
    }
    ...
};

oder als freie Funktion

template<typename T>
auto x(T& v) -> decltype<T.ele[0]&>
{
    return v[0];
}

ungetestet.

template<typename T>
struct vec_2d
{
     T x, y;
};

oder

template<typename T>
struct vec_2d
{
     T ele[2];
};

wie du - knivil - dein erstes listing implementieren willst bleibt mir ein rätsel

Indem ich es einfach hinschreibe.

Vllt ein bissl umständlich

Code bloat in Reinform, uebererfuellt, warum nicht gleich was absolut generelles wie type_traits aus boost::geometry ...

schon klar, aber er wollte eben .x .y .z ... haben und code bloat ist was anders.

PS: Boilerplate im übrigen auch nicht