überladung

unskilled

#include <string>
struct foo
{
	template<typename T>
	void x(const T &, bool = true)
	{}

	template<typename T>
	void x(const std::string &, const T &, bool = false)
	{}
};

const char* bar = "X";

int main()
{
	foo f;
	f.x<std::string>("asd", bar);
}

MSVC schrieb:

test\main.cpp(19) : warning C4800: 'const char *' : forcing value to bool 'true' or 'false' (performance warning)

wieso wird hier nicht der (non-explicit) CTor von std::string aufgerufen sondern die adresse lieber in nen bool umgewandelt? kann man das iwie elegant verhindern?
die default-parameter anzugeben ist unmöglich...
das die überladungen so doof gewählt sind, kann ich leider auch nicht wirklich ändern -.- falls es aber keine andere möglichkeit gibt, muss ich das wohl...

danke schon mal,
bb

camper

unskilled schrieb:

wieso wird hier nicht der (non-explicit) CTor von std::string aufgerufen sondern die adresse lieber in nen bool umgewandelt?

Weil die Umwandlung mittels ctor einen höheren Rang hat als Standardumwandlung in ein bool. Es gibt verschiedene Möglichkeiten, sofern du die Signaturen ändern kannst.

unskilled

camper schrieb:

unskilled schrieb:

wieso wird hier nicht der (non-explicit) CTor von std::string aufgerufen sondern die adresse lieber in nen bool umgewandelt?

Weil die Umwandlung mittels ctor einen höheren Rang hat als Standardumwandlung in ein bool. Es gibt verschiedene Möglichkeiten, sofern du die Signaturen ändern kannst.

hmm.. naja - wenns sonst nicht geht, werd ichs wo ändern müssen^^
was wären denn deine vorschläge?

bb

pumuckl

mach aus bar explizit einen temporären std::string:

f.x("asd", std::string(bar));

Sollte dann klappen.

unskilled

pumuckl schrieb:

mach aus bar explizit einen temporären std::string:
f.x("asd", std::string(bar));
Sollte dann klappen.

ja - so hab ichs zwar momentan im quellcode, aber ich finds iwie hässlich... ><
aber wenn du keinen anderen vorschlag hast, werd ichs wo so lassen müssen!?

bb

camper

unskilled schrieb:

was wären denn deine vorschläge?

Füge weitere Überladungen hinzu, die spezieller sind und die kritischen Fälle abdecken, oder eliminiere die Überladung für bestimmte Argumente (enable_if). Schließlich könnte man den Funktionsaufruf an einen Funktor weiterleiten und mit partieller Spezialiserung statt Überladung arbeiten (etwas mehr Schreibaufwand, dafür leichter richtig hinzubekommen). Was vorzuziehen ist, hängt vom konkreten Einsatz ab. z.B.

struct foo
{
    template<typename T>
    void x(const T &);

    template<typename T, typename U>
    enable_if<is_same<U,bool> > x(const T &, const U&);

    template<typename T>
    disable_if<is_same<T,bool> > x(const std::string &, const T &, bool = false);
};