Metaprogramming dereference pointer

[th0rex]

Hallo Leute.

Ich habe mir mal vorgenommen mich mit Template Meta Programmierung auseinanderzusetzen. Wollte mal versuchen z.B. einen T** zu T zu dereferenzieren. Nur habe ich irgendwie keine Ahnung wie ich das anstellen soll. Ich kann von T** auf T* oder von T* auf T dereferenzieren (also auch von T** auf T nur das dafür müsste ich die Funktion 2 mal hintereinander aufrufen), aber ich würde gerne eine Funktion haben die N mal dereferenziert. Hat jemand eine Ahnung wie man das implementieren könnte ? Als Funktionsdefinition würde ich sowas benutzen:

template<typename T, int i, int n>
typename ptr_holder<T, i - n>::type dereference_ptr(typename ptr_holder<T, i>::type pointer)
{
	// ???
}

Hier ist der code den ich bis jetzt habe:

template<typename T, int i>
struct ptr_holder
{
	typedef typename boost::add_pointer<typename ptr_holder<T, i - 1>::type>::type type;
};

template<typename T>
struct ptr_holder < T, 1 >
{
	typedef typename boost::add_pointer<T>::type type;
};

template<typename T>
struct ptr_holder < T, 0 >
{
	typedef T type;
};

template <typename T, int i>
typename ptr_holder<T, i - 1>::type dereference_ptr(typename ptr_holder<T, i>::type pointer)
{
	return *pointer;
}

int main(int argc, char** ppArgv)
{
	ptr_holder<char, 2>::type ppTest = new char*("Test");
	ptr_holder<char, 1>::type pTest = dereference_ptr<char, 2>(ppTest);
	std::cout << pTest << std::endl;
        return 0;
}

Ich hoffe jemand kann mir helfen. Würde mich auch sehr über Verbesserungsvorschläge von meinem jetzigen Code freuen.

[Tasiro]

Funktionen können nicht partiell spezialisiert werden, nur Klassen. Daher die Helfer-Klasse.
Die ptr_holder-Klasse ist nicht notwendig. Theoretisch ist es nicht einmal notwendig, dass die zu dereferenzierende Klasse ein Zeiger ist, wie viele Iteratoren zeigen. Aber das richtig zu implementieren (mit const und rvalue-this) ist nicht ganz einfach.

 Code

template <std::size_t n, typename T>
struct deref_helper;

template <typename T>
struct deref_helper <0, T> {
	using type = T;
	// Alternative:
	//typedef type T;

	static T deref (T && value) {
		return value;
	}
};

template <std::size_t n, typename T>
struct deref_helper <n, T *> {
	using type = typename deref_helper <n - 1, T>::type;
	// Alternative:
	//typedef typename deref_helper <n - 1, T>::type type;

	static type deref (T * pointer) {
		return deref_helper <n - 1, T>::deref (* pointer);
	}
};

template <std::size_t n, typename T>
struct deref_helper <n, T []> {
	using type = typename deref_helper <n - 1, T>::type;

	static type deref (T * pointer) {
		return deref_helper <n - 1, T>::deref (* pointer);
	}
};

template <std::size_t n, typename T, std::size_t size>
struct deref_helper <n, T [size]> {
	using type = typename deref_helper <n - 1, T>::type;

	static type deref (T * pointer) {
		return deref_helper <n - 1, T>::deref (std::move (* pointer));
	}
};

typedef short int unsigned;

template <std::size_t n, typename T>
auto deref (T && value) {
	return deref_helper <n, T>::deref (std::move (value));
}