Ich hab ein kleines Problem mit den Templates. Anscheinend gehen bei mir die aktuellen Generationen noch nicht.

template <typename T>
using vlist_t = std::vector<T>;

template <typename T>
using vsize_t = typename vlist_t<T>::size_type;

template <typename T>
using vvalue_t = typename vlist<T>::value_type;

template <typename T = double>
vlist_t<T> ffunction(const vlist_t<T> &x, const vsize_t<T> r = 0){
	vlist_t<T>ret;
	/* Code .... */
	return ret;
}

Ich hab jetzt versuch das so zu lösen. Lässt sich aber nicht kompilieren.

template <typename T>
struct vlist_t{
	typedef std::vector<T> tlist;
};
template <typename T>
struct vsize_t{
	typedef typename vlist_t<T>::tlist::size_type tvsize;
};
template <typename T>
struct vvalue_t{
	typedef typename vlist_t<T>::tlist::value_type tvvalue;
};

template <typename T = double>
vlist_t<T>::tlist ffunction(const vlist_t<T>::tlist &x, const vsize_t<T>::tvsize r = 0){
	vlist_t<T>::tlist ret;
	/* Code .... */
	return ret;
}

Fehlermeldung:

warning C4346: 'vlist_t<T>::tlist' : dependent name is not a type

Ich hab das auch schon mit umstellen und umschreiben ausprobiert. Kann mir hierzu jemand einen Tip geben wie ich das lösen soll. Danke.

wachs

Ich bin mir aber sicher, dass man das lösen kann, mit der richtigen Umstellung. Ein paar Tips dazu wäre für mich sehr hilfreich.

Edit:
Ich hätte hier eine Möglichkeit, aber so müsste ich auf die Template-Eigenschaften der Funktion ffunction verzichten.
Gibt es dazu eventuell eine andere Möglichkeit? Boost vielleicht?

template <typename T>
struct vlist_t{
	typedef std::vector<T> tlist;
};
template <typename T>
struct vsize_t{
	typedef typename vlist_t<T>::tlist::size_type tvsize;
};
template <typename T>
struct vvalue_t{
	typedef typename vlist_t<T>::tlist::value_type tvvalue;
};

typedef vlist_t<double>::tlist _tlist;
typedef vsize_t<double>::tvsize _tvsize;
typedef vvalue_t<double>::tvvalue _tvvalue;

//template <typename T  = double>
_tlist ffunction(const _tlist &x, const _tvsize r = 0){
	_tlist ret;
	/* Code .... */
	return ret;
}

die Compiler-Warnung sagt dir schon, was falsch läuft. Die Bezeichner sind von einem Template-Argument abhängig (hier von T ), daher kann der Compiler nicht wissen, ob es sich um ein Value, ein Typ oder ein Template handelt. Daher muss man so etwas explizit angeben (mit dem Schlüsselwort typename für Typen oder template für Templates). Korrigiert sähe dein Snippet so aus:

template <typename T = double>
typename vlist_t<T>::tlist ffunction(const typename vlist_t<T>::tlist &x, const typename vsize_t<T>::tvsize r = 0){
	typename vlist_t<T>::tlist ret;
	/* Code .... */
	return ret;
}

Für mehr Infos zu dieser Thematik: http://en.cppreference.com/w/cpp/language/dependent_name (insb. zweitletzter Absatz)

Gruss

Das hat jetzt ein ganzes stück weitergeholfen.

Jetzt kriege ich nur noch diese Meldung, die ich nicht ganz verstehe, weil ich ja mit den Definitionen in der Parameterliste der Funktion ffunction Klassenvorlage definiere.

error C4519: default template arguments are only allowed on a class template

Muss ich die ffunction in eine Klasse einbauen?

Edit:
Fehler gefunden

template <typename T /*= double*/>
typename vlist_t<T>::tlist ffunction(const typename vlist_t<T>::tlist &x, const typename vsize_t<T>::tvsize r = 0)

Definitionen von T erlaubt mein Kompiler anscheinend nicht

Das hätte ich gemacht wenn es mir hier und jetzt möglich wäre