Kann mir einer sagen warum folgende Zeile compiliert (mit VC++ 2003 und VC+ 2005)

class foo
{
   std::string m_s;
public:
   foo(const std::string& r)
   {
      m_s = r;
   }
};

void doSomething()
{
   foo fx(std::string(sdgonodf));
}

Da fehlen die " beim std::string in doSomething. Wird aber trozdem ohne zu mekern geschluckt. Jemand ne idee was da genau passiert

kenn vc++ nich, aber vielleicht interpretiert der einfach alle literale, die er nicht zuordnen kann, als string. macht z.b. der interpreter php auch.

macht er defintiv nicht klapt nur in dem speziellen fall. Ein std::string s = bla; geht nicht.

Ist vielleicht ein Compilerfehler (bzw. eine Art Compilerepidemie ) ?!

nach was wird std::string aufgelöst? fuscht der da irgendnen cast vor den parameter oder sowas?

bis jetzt haste ja nur vc 6 / vc 03 / vc 05 compiler benutzt.

dev++ und codeblocks bringen ja von haus aus keinen eigenen mit.

bzw rufst du die sache überhaupt auf ? weil wenn nicht hats der compiler wahrscheinlich wegoptimiert...

Kann mir eigentlich nur vorstellen dass sdgonodf ein Compilerinternes Symbol ist, was zu einem der string-Konstruktoren passt...

Wie schon gesagt, kannste eingeben was Du willst, geht immer, auch wenn Zahlen mit im Spiel sind (dachte auch erst daran liegt es). Aber Compiler-Variablen beginnen auch eigentlich immer mit mindestens einem Unterstrich.

DaRpH schrieb:

dev++ und codeblocks bringen ja von haus aus keinen eigenen mit.

Stimmt, aber der MinGW sollte das ja eigentlich auch (nicht) packen .

geht übrigens nicht. Liegt an der Klammer. Der Compiler optimiert nicht bevor er parst und wenn man das ganze aufruft gehts genauso.

MS Visual C++ 2005 schrieb:

strangetest.cpp(15) : warning C4930: 'foo fx(std::string)': prototyped function not called (was a variable definition intended?)

Hätte man drauf kommen können

"Be alert for C++‘s most vexing parse"

Guckt euch mal den Code an:

int bla(int(6));

Sollte doch theoretisch das gleiche sein, oder ?

Dachte (auch) erst, dass er 6 hier als Default Parameter ansieht, aber wenn man schreibt:

int bla(int i)
{
   return (i);
}

Gibbets den Error gleich gratis :

Compiler-Log (MS Visual C++ 2005) schrieb:

error C2365: "bla": Erneute Definition; vorherige Definition war "Datenvariable". [...]: Siehe Deklaration von 'bla'

Auch der Aufruf funktioniert nicht. Naja aber is eigentlich auch rille...so sollte man es ja sowieso nit machen .

void doSomething() 
{ 
   //const char* sdgonodf = "hallo";
   //foo fx(std::string(sdgonodf)); 
   int bar(int(b));
   std::cout << bar(12) << std::endl;
}

int bar(int(b))
{
	return b;
}

Mit "6" statt "b" wird es wieder eine Variablendeklaration. Dann ist nach dem was bisher festgestellt wurde klar dass der von Dir gepostete Error kommt.

das bringt zum einen die "tolle freiheit", zum anderen aber auch kopfschmerzen

void doSomething() 
{ 
   //const char* sdgonodf = "hallo";
   //foo fx(std::string(sdgonodf)); 
   int bar(int(b));
   std::cout << bar(12) << std::endl;
}

int bar(int(b))
{
	return b;
}

Genau.
Und dass die "zusätzlichen" Klammern um den Parameternamen OK sind wird auch schnell klar wenn man sich ansieht dass z.B. für sowas diese Klammern (genau an der Stelle) erforderlich sind:

void foo(int (&array)[10]);

EDIT: genau solche Verwirrung kann man gut vermeiden wenn man grundsätzlich so initialisiert:

foo fx = foo(std::string("sdgonodf")); // OK
foo fx = foo(std::string(sdgonodf)); // Fehler