"auto" für Klassen Member?

FrEEzE2046

Hallo,

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

Normal programmieren mit ner template Klasse. Für sowas hat man sich sicher nicht auto ausgedacht. Beim Copy-Ctor wäre das für den Compiler sowieso richtig aufwendig.

Was soll denn dann sizeof(MyClass) sein? Das kann so gar nicht funktionieren. Wenn Du die Klasse parametrisieren willst, kannst Du das mit einem Klassentemplate machen. Über ein Funktionstemplate könne man Templateparameter deduzieren lassen. Das kann dann zB so aussehen:

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

ipsec

Das geht nicht (ist auch keine Beschränkung in der Syntax). Was soll der Compiler bei sowas machen?

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

FrEEzE2046

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.

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[]);

ipsec

FrEEzE2046 schrieb:

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.

FrEEzE2046

ipsec schrieb:

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

&quot;auto&quot; für Klassen Member?

"auto" für Klassen Member?