angenommen wir hätten folgendes Szenario:

class MyClass
{
public:
	template<typename T0, typename T1>
	MyClass(
		T0 Param0,
		T1 Param1
	)
	{
		T0 var0;				// funktioniert
		T1 var1;				// 		""
		decltype(Param0) var2;	//      ""
		auto var4 = Param1;		//		""
	}
};

int main()
{
	MyClass c(4, 4.0);		// var0 == int, var1 == double, var2 == int, var3 == double
}

Nun würde ich gerne außerhalb des Konstruktors Variablen vom Typ T0 und T1 deklarieren. Die Verwendung von MyClass (zu sehen in main()) soll allerdings gleich bleiben.

Folgendes habe ich probiert, ist aber leider nicht möglich:

class MyClass
{
	auto m0, m1;

public:
	template<typename T0, typename T1>
	MyClass(
		T0 Param0,
		T1 Param1
	) : m0(Param0), m1(Param1)
	{
		T0 var0;				// funktioniert
		T1 var1;				// 		""
		decltype(Param0) var2;	//      ""
		auto var4 = Param1;		//		""
	}
};

Eigentlich schade, da zur Kompilierzeit auswertbar. Gibt es einen Workaround oder ähnliches dafür?

Danke vorab.

PS:
Compiler: MSVC10

auto paar = make_pair(2,3.14);
// decltype(paar) == std::pair<int,double>

MyClass a(1, 1);
a = MyClass("1", "1");

Was soll denn dann sizeof(MyClass) sein?

Das wäre nicht auswertbar. Der Compiler müsste ggf. für jede Instanz von MyClass eine eigene Klasse anlegen.

ipsec schrieb:

Was soll der Compiler bei sowas machen?

MyClass a(1, 1);
a = MyClass("1", "1");

Das wäre nicht möglich, da MyClass(int, int) != MyClass(char[], char[]);

Das wäre nicht möglich, da MyClass(int, int) != MyClass(char[], char[]);

Exakt! Und genau für sowas hat Gott (oder von mir aus auch Stroustrup) die Templateklassen erfunden. Also verschiebe das template<typename T0, typename T1> statt an den Konstruktor einfach an die Klasse und die Sache ist praktisch geklärt.

template<typename T0, typename T1>
class MyClass
{
    T0 m0;
    T1 m1;

public:
    MyClass(
        T0 Param0,
        T1 Param1
    ) : m0(Param0), m1(Param1)
    {
    }
};

Ich glaube übrigens, das ist genau das, was du suchst. Jede Variable mit unterschiedlichen Typen hat ihre eigene Klasse und z.B. MyClass<int, int> hat mit MyClass<char[], char[]> nichts zu tun.

Ich glaube übrigens, das ist genau das, was du suchst. Jede Variable mit unterschiedlichen Typen hat ihre eigene Klasse und z.B. MyClass<int, int> hat mit MyClass<char[], char[]> nichts zu tun.

Danke für die gute Absicht, aber das ist mir natürlich klar ;-). Da jedoch beide Template-Argumente ebenfalls Parameter des einzigen Konstruktors sind, habe ich gehofft, dass auch eine Möglichkeit besteht das ganze an den Konstruktor zu verlagern um so die Deklaration einheitlich zu halten.

Mir ist schon klar, weshalb es nicht funktioniert. Ich denke ich werde eine Workaround implementieren. Danke trotzdem.

FrEEzE2046 schrieb:

krümelkacker schrieb:

Was soll denn dann sizeof(MyClass) sein?

Das wäre nicht auswertbar. Der Compiler müsste ggf. für jede Instanz von MyClass eine eigene Klasse anlegen.

Wie ich schon sagte: Dafür sind Klassentemplates da !!!

FrEEzE2046 schrieb:

ipsec schrieb:

Was soll der Compiler bei sowas machen?

MyClass a(1, 1);
a = MyClass("1", "1");

Das wäre nicht möglich, da MyClass(int, int) != MyClass(char[], char[]);

Wie ich schon sagte: Dafür sind Klassentemplates da !!!