Nun, ich hab gelesen dass das nicht im Standard vorgesehen ist. Aber kennt jemand eine Alternative und die Begründung wieso sowas nicht erlaubt ist?

class Screen
	{
	public:
		///-----------------------------------
		/// BUTTON
		///-----------------------------------
		template<> // <--- Fehler
		std::list<Button> Get_List<Button> const () { return this->ButtonList ; }
		///-----------------------------------
		/// LABEL
		///-----------------------------------
		template<> // <--- Fehler
		std::list<Label> Get_List<Label> const () { return this->LabelList ; }

	private:
		std::list<Button> ButtonList ;
		std::list<Label> LabelList ;
	};

Wäre dankbar für jede Hilfe.

Also in etwa so

template<typename T_Type>
std::list<T_Type> Get_List<T_Type> const ();
template<>
std::list<Button> Get_List<Button> const ();
template<>
 std::list<Label> Get_List<Label> const ();

Was möchtest du genau erreichen? Weshalb nimmst du nicht zwei Funktionen GetButtonList() und GetLabelList() ?

Nagut, wollte es eigentlich mit Templates machen, aber gut.

Wenn das schon nicht geht, will ich zumindestens wissen wieso nicht. Mit leeren Händen will ich nicht gehen...

Mir ist gerade noch aufgefallen, das die '()' falsch stehen... sry

Die Klammern standen schon richtig, nur das const stand falsch.

Wenn das schon nicht geht, will ich zumindestens wissen wieso nicht. Mit leeren Händen will ich nicht gehen...

Es heißt doch schon "Templatespeizialisierung". Um etwas spezielles zu bekommen muss doch erstmal etwas allgemeineres existieren. Und das tut es bei dir nicht. Macht auch wenig Sinn, denn die allgemeine Templatefuntion könnte nichts tun...

Bei folgenden Code bekomme ich beim GCC: error: explicit specialization in non-namespace scope ‘class Screen’
Beim VC++ lässt sich der Code fehlerlos kompilieren.

Nun, ich hab gelesen dass das nicht im Standard vorgesehen ist. Aber kennt jemand eine Alternative und die Begründung wieso sowas nicht erlaubt ist?

class Screen
	{
	public:
		///-----------------------------------
		/// BUTTON
		///-----------------------------------
		template<> // <--- Fehler
		std::list<Button> Get_List<Button> const () { return this->ButtonList ; }
		///-----------------------------------
		/// LABEL
		///-----------------------------------
		template<> // <--- Fehler
		std::list<Label> Get_List<Label> const () { return this->LabelList ; }

	private:
		std::list<Button> ButtonList ;
		std::list<Label> LabelList ;
	};

Wäre dankbar für jede Hilfe.

Zunächst einmal wird ein Primärtemplate benötigt. Vermutlich hast du das hier nur der Kürze wegen weggelassen.
Möglich wäre die Definition der Spezialisierungen außerhalb der Klassendefinition.

Nagut, wollte es eigentlich mit Templates machen, aber gut.

Du willst es mit Templates machen, nur um Templates verwendet zu haben? Sprachmittel setzt man normalerweise ein, wenn sie sinnvoll sind. Und das trifft auf Templates in diesem Kontext nicht zu.

Danke für eure Hilfe!

Wie dem auch sei, das ganze ginge etwa so:

class A {
public:
  A(int x, double d) : x(x), d(d) { }

  template<typename T> T get();

private:
  int x;
  double d;
};

template<> int    A::get<int   >() { return x; }
template<> double A::get<double>() { return d; }

...wobei dann der Aufruf mit einem nicht implementierten Typ einen Linkerfehler hervorruft.