3. templatespezialisierung der besonderen art

templatespezialisierung der besonderen art

  • S

    Vllt ein bissl umständlich, macht aber im wesentlich das was du willst. Ist als Bsp zu vertehen, kenne deine vector implementierung nicht.

    #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;
}
    0
  • K

    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.

    0
  • ?

    ach ich finde den vorschlag von ScottZhang gut, habe es eben für meinen vektor nachimplementiert, meine version stimmt aber noch nicht so ganz bzgl. der const-correctness. ich würde einfach gern die member-schreibweise haben weil sie so intuitiv ist, daher ist mir sein vorschlag auch lieber als das mit den globalen accessern. wie du - knivil - dein erstes listing implementieren willst bleibt mir ein rätsel. leitet die spezialisierte form von vec etwa von einer klasse vec_base oder so ab? denn ich hab keine lust alle methoden von vec für jede spezialisierung neu zu definieren...

    0
  • K

    Spezifiziere vec<T,int> ... und wozu du Lust hast, kann ich nicht wissen. Meine "vec"-Implementierungen sehen fuer gewoehnlich so aus:

    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.

    0
  • S

    knivil schrieb:

    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.

    0
  • K

    Entschuldige ... boilerplate code .. und ich kann es nur an meinen vec-structs messen.

    0
  • S

    ich würde das auch nicht haben wollen, aber wer auf son oberflächigen Bussineskram steht. Nen stinknormaler Zugriff übern Klammeroperator reicht meiner Meinung nach aus, oder wie du es vorschlägst mit ner freien Funktion als alternative wäre auch meine erste Wahl gewesen. Ich schätze mal er hat das aus der Shaderprogrammierung, da addressiert man die Komponenten auch so.

    PS: Boilerplate im übrigen auch nicht 😃

    0
  • K

    Na dann sag mir einen besseren Begriff ... beide sind fuer mich zutreffend.

    0
  • S

    Ich bin mir nicht sicher, geht es denn kürzer wenn man genau dieses Feature will?

    0
  • K

    Genau ... wahrscheinlich nicht ... ich sach immer: viel wuenschen und weniger wollen 🙂

    0
Anmelden zum Antworten