//---------------------------------------------------------------------------
#include <iostream>
using namespace std;

char * func ();

int main(int argc, char* argv[])
{

char *s=0;
char *str="0";
str = func();

cout<<  *str ;

system("PAUSE");
}
//---------------------------------------------------------------------------

char * func ()
{
char var[7] = "Hallo";

return var;
}

Und nimm eine andere IDE. DevC++ ist nicht gut.

Und nimm eine andere IDE. DevC++ ist nicht gut.

Woher weisst du das?

volkard schrieb:

Und nimm eine andere IDE. DevC++ ist nicht gut.

Woher weisst du das?

Unter anderem hier her: http://www.c-plusplus.net/forum/237002

Benutz doch std::string

//---------------------------------------------------------------------------
#include <iostream>
#include <string>

using namespace std;

std::string func ();

int main(int argc, char* argv[])
{
	std::string str="0";

	str = func();

	cout<< str;

	system("PAUSE");
}
//---------------------------------------------------------------------------

std::string func ()
{
	std::string var = "Hallo";

	return var;
}

volkard schrieb:

Und nimm eine andere IDE. DevC++ ist nicht gut.

Woher weisst du das?

Oder hier:
http://de.wikipedia.org/wiki/Dev-C%2B%2B

Aktuelle Version 4.9.9.2
(22. Februar 2005)

Veraltet.

Wofür schreibt man std::string str="0"; ?

Ich benutze doch using namespace std; oder ist das schlecht ?

Ich weiss halt nicht was der Nachteil dabei sein könnte.

Wofür schreibt man std::string str="0"; ?

Für nichts.

omg__ schrieb:

Ich benutze doch using namespace std; oder ist das schlecht ?

Geschmackssache. Ich vermeide es, da es nur wenig Vorteil bringt und Bezeichnerkonflikte hervorrufen kann.

#include <iostream> //Für Ein- und Ausgabe
#include <string> //Für Zeichenketten
std::string func(); //Vorwärtsdeklaration der Funktion
int main() //Hauptfunktion ohne Parameter, da ohnehin nicht genutzt
{ 
  std::string Str(func()); //Konstruktoraufruf statt Zuweisung
  std::cout << Str; //Ausgabe
  std::cin.get(); //Auf Eingabe warten, bitte nutzte kein system
}
std::string func() //Funktionsdefinition
{ 
  return "Hallo"; //Implizite Konvertierung von const char* nach std::string
}

volkard schrieb:

Und nimm eine andere IDE. DevC++ ist nicht gut.

Woher weisst du das?

Wenn du in Dev ein Console-Application-rojekt erstellst, dann werden u.a. diese

#include <iostream>

int main(int argc, char *argv[])
{
    system("PAUSE");
}

Zeilen automatisch erstellt.

Bei Wikipedia steht:
http://de.wikipedia.org/wiki/Konstruktoren_und_Destruktoren
Die Aufgabe von Konstruktoren ist, Objekte in einen definierten Anfangszustand zu bringen und so benötigte Ressourcen zu reservieren, insofern diese zum Zeitpunkt der Objekterstellung bereits bekannt sind.

Womit wird denn dann Str hier initialisiert ?

std::string Str(func()); <-- Ist mit einem Konstruktor besser als mit einer Zuweisung ?

std::string foo1("Hallo");
std::string foo2 = "Hallo";

Hier ist zweimal exakt das selbe geschehen.

std::string foo;
foo = "Hallo";

Hier wird erst der Standard-Konstruktor (Parameterlos oder mit Default-Werten) aufgerufen und dann der Zuweisungsoperator.

Also ist hier std::string Str(func());

Str mit dem String Hallo initialisiert ?
Wird hier dann nur der Standard Konstruktor aufgerufen so das der Zuweisungsoperator nicht mehr aufgerufen wird und der Prozessor sich ein Schritt sparen kann ?

Str mit dem String Hallo initialisiert ?
Wird hier dann nur der Standard Konstruktor aufgerufen so das der Zuweisungsoperator nicht mehr aufgerufen wird und der Prozessor sich ein Schritt sparen kann ?

Nein, in der Funktion wird der char*-Konstruktor aufgerufen, um eine temporäre Variable mit dem Literal zu initialisieren. In der Zeile std::string Str(func()); wird der Kopierkonstruktor verwendet, um deine Variable "Str" mit dem Inhalt der temporären Variablen zu füllen.
(wobei der Compiler auch das Recht hat, die Kopie wegzuoptimieren)

Str mit dem String Hallo initialisiert ?

Ja (indirekt).

std::string Foo1; //Standardkonstruktor
Foo1 = "Hallo"; //Zuweisungsoperator
std::string Foo2(Foo1); //Kopierkonstruktor
std::string Foo3("Hallo"); //Konstruktor mit const char* als Parameter
std::string Foo4 = "Hallo"; //Sieht nach Zuweisungsoperator aus ist aber Konstruktor mit const char* als Parameter

omg__ schrieb:

Str mit dem String Hallo initialisiert ?

Ja (indirekt).

std::string Foo1; //Standardkonstruktor
Foo1 = "Hallo"; //Zuweisungsoperator
std::string Foo2(Foo1); //Kopierkonstruktor
std::string Foo3("Hallo"); //Konstruktor mit const char* als Parameter
std::string Foo4 = "Hallo"; //Sieht nach Zuweisungsoperator aus ist aber Konstruktor mit const char* als Parameter

Bei dem letzten Fall wird zwar in der Praxis normalerweise wie du sagtest nur der Konstruktor mit entsprechendem Parameter aufgerufen, aber fest von ausgehen kannst du nicht. Denn eg ist es eine Copy Initialization und keine direct Initialization. Sprich es wird ein temporäres objekt erstellt welches dann mittels kopierkonstruktor dein objekt initialisiert. Aber wie gesagt Compiler dürfen dies im Normalfall in eine direct Initialization umwandeln. Gab hier aber auch schon genug threads dazu, wollte es nur erwähnen;-)

LG freeG