Templateklassen für C-Strings spezialisieren

[kaiserludi]

Ich habe folgendes kleines Helfer-Template:

Code: Alles auswählen

template<typename Etype, unsigned int N=1> struct ValueToObject{static Object get(Etype value){return ValueObject<Etype>(value);}};
template<unsigned int N> struct ValueToObject<Object, N>{static Object get(Object value){return value;}};
template<unsigned int N> struct ValueToObject<char*, N>{static Object get(const char* value){return ValueToObject<JString>::get(JString(value));}};
template<unsigned int N> struct ValueToObject<const char[N], N>{static Object get(const char value[N]){return ValueToObject<JString>::get(JString(value));}};

Dabei geht es mir um die Spezialisierung für <const char[N], N>.
Folgender Code funktioniert auch soweit:

Code: Alles auswählen

static void test(void)
{
	ValueToObject<const char[10], 10>::get("123456789");
}

Hier bekomme ich aber verständlicherweise den Fehler "C2784 : could not deduce template argument for 'const Etype [N]' from 'const char [10]'" :

Code: Alles auswählen

/*template<typename Etype>
static void test(const Etype& val)
{
	ValueToObject<Etype>::get(val);
}*/
template<typename Etype, unsigned int N>
static void test(const Etype val[N])
{
	//ValueToObject<const Etype[N]>::get(val);
}

static void tester(void)
{
	//test(Object());
	test("012345789");
}

Allerdings stehe ich gerade auf dem Schlauch, wie ich aus dem übergebenem Parameter für Etype nun rausbekomme, ob es sich um einen const char [M] handelt und wie ich dem Compiler in diesem Fall klar mache, dass er sich N aus M holen soll, oder wie ich es anders hin bekomme, dass ich an die API einfach Object() oder 2.0f oder eben auch "string" übergeben kann und intern dann korrekt determiniert wird, wann der Code für String-Literale aufgerufen werden soll und wann nicht.

[CodingCat]

Zur Deduktion von Array-Längen musst du Referenzen auf Arrays entgegennehmen: const Etype (&val)[N]

[kaiserludi]

8-) Es funktioniert. Danke.

PS:
Mir fällt gerade auf, es geht ja auch so:

Code: Alles auswählen

struct ValueToObject
{
	template<typename Ftype> static Object get(Ftype value){return ValueObject<Ftype>(value);}
	static Object get(Object value){return value;}
	static Object get(const char* value){return ValueToObject::get(JString(value));}
	template<unsigned int N> static Object get(const char value[N]){return ValueToObject::get(JString(value));}
};

Da spar ich mir die explizite Übergabe des Typen als Templateparameter :)