Templatespezialisierung

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.

Xebov

Ich bin mir nicht 100%ig sicher, ich glaube aber das man eigentlich ein richtiges Template braucht zu dem die Spezialisierten gehören.

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 ();

Ne, leider noch immer der selbe Fehler.
Mir ist gerade noch aufgefallen, das die '()' falsch stehen... sry

theta

Also ehrlich... schreib doch einfach was die Methoden tun:
GetButtons(), GetLabels()... wo ist das Problem?
Simon

Nexus

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

Nexus schrieb:

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...

Harald21 schrieb:

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

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

Harald21 schrieb:

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...

camper

Harald21 schrieb:

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.

Nexus

Harald21 schrieb:

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.

Hmm stimmt. Dann habe ich mal was dazu gelernt.

Danke für eure Hilfe!

Ob es sinnvoll ist, hängt davon ab, wie das ganze nachher benutzt werden soll, auch wenn ich schon etwas fantasieren muss, um mir einen use case auszudenken, in dem einfache Methoden nicht ausreichten. Etwa könnten andere Vorlagen existieren, die etwas bestimmtes mit allen Unterkomponenten eines bestimmten Typs tun.

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.