Frage zu Rückgabewert

EOutOfResources

omg__ schrieb:

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.

EOutOfResources

Hier die aufgepepte Version:

#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
}

EOutOfResources schrieb:

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.

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

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 ?

EOutOfResources

omg__ schrieb:

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.

Aufrufe für:
std::string foo;
foo = "Hallo";
1. Standart Konstruktor
2. 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 ?

CStoll

omg__ schrieb:

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)

EOutOfResources

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

Danke für die Antworten ich werd mir glaub ich das ganze auch nochmal im Disassembler mit verschiedenen Compiler Einstellungen anschauen.

fr33g

EOutOfResources schrieb:

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