returnwert einer function

char * getDate()
{
time_t datum;
struct tm *tmzgr;
char woche[30];

datum = time(NULL);
tmzgr = localtime(&datum);
strftime(woche,30,"%c",tmzgr);

return (woche);
}

Hallo, was mache ich hier falsch? Ich möchte diese function in der main() verwenden. z.b. cout << getDate(); um das datum auszugeben.

vielen dank im voraus

DrGreenthumb

Du gibst ein lokales Array zurück. Das Problem ist, dass bei verlassen der Funktion das char woche[30]-Array zerstört wird.

Entweder du machst das Array static, oder noch besser, du gibst nicht char* zurück, sondern einen std::string.

#include <string>

std::string  getDate()
{
time_t datum;
struct tm *tmzgr;
char woche[30];

datum = time(NULL);
tmzgr = localtime(&datum);
strftime(woche,30,"%c",tmzgr);

return (woche);
}

Vielen Dank für die schnelle Antwort. Es klappt !

Noch besser ist natuerlich, du gibts keine "komplexen" Klassen als Rueckgabewerte zurueck
@DrGreenthumb
Schau dir mal an, was der KopieKonstruktor von std::string so alles macht

@NewGuest
Wenn Du mit std::string arbeiten willst, dann uebergieb deiner Funktion lieber ne Referenz auf nen std::string Instanz und befuelle sie einfach nur ....

#include <string>

int getDate(std::string& astr_time)
{
time_t datum;
struct tm *tmzgr;
char woche[30];

datum = time(NULL);
tmzgr = localtime(&datum);
strftime(woche,30,"%c",tmzgr);
astr_time = woche;

// vielleicht nen Fehlercode Zurueckgeben 
return 0;
}
}

Fuer Testcode und nicht allzukritische Anwendungen lang die alte Loesung aber allemal ... trotzdem sollte man sich sowas ned angewoehnen

Ciao .....

DrGreenthumb

trotzdem sollte man sich sowas ned angewoehnen

hm, das hab ich mir schon längst angewöhnt.
Ist mir viel zu nervig string x; get(x); schreiben zu müssen statt string x(get());.

Außerdem gibts ja jetzt noch das: http://fara.cs.uni-potsdam.de/~kaufmann/?page=GenCppFaqs&faq=Optimize#Answ

Inwiefern kann man sich darauf verlassen?

Würde nämlich gerne auch list<string> große_liste = get() schreiben dürfen.
Aber wenn diese Optimierung letztendlich vom Compiler-Hersteller abhängt, wärs blöd seinen Code darauf aufzubauen.

HumeSikkins

Hallo,
das ist hier alles nicht eindeutig, da std::string total unterschiedlich implementiert sein kann. Es ist z.B. eine referenzgezählte Implementation möglich. In diesem Fall hätte ein Copy-Ctor nahezu überhaupt keine Kosten.

Aber auch ohne ist für <XYZ>s Lösung kein großer Vorteil zu erwarten. Schließlich ist der Aufruf von Standard-Ctor + op= nicht großartig billiger als der Aufruf von Copy-Ctor + Dtor. Und durch RVO kann die Erstellung eines temporären Objekts auch noch umgangen werden.

Für einen einmaligen Aufruf der Form:

string s;
getDate(s);

vs.

string s(getDate())

gibt es mit Sicherheit keinen Unterschied.
Für 10000-Aufrufe direkt hintereinander ist die Wahrscheinlichkeit groß, dass die erste Variante etwas schneller ist, da nur ein String-Objekt erzeugt wird und dieses auch ab dem zweiten Aufruf die passende Größe hat. Es muss als keine dynamische Speicherallokation mehr passieren.

Hat man allerdings eine Stringimplementation die von der "small-string-optimization" gebrauch macht, fällt dieser Vorteil hier gleich wieder weg.

Nur mal als Beispiel:
Für den VC6 erhalte ich bei 100000 Aufrufen im Debug-Modus:
1. Value-Return: 5.49
2. Referenzparameter + Wiederverwendung des Zielstrings: 5.0
3. Referenzparmaeter + immer frischer Zielstring: 5.48

Im Releasemode:
1. Value-Return: 4.55
2. Referenzparameter + Wiederverwendung des Zielstrings: 4.45
3. Referenzparmaeter + immer frischer Zielstring: 4.55

Ich würde in diesem Fall also dazu raten die Variante zu verwenden, die man hübscher findet.

Es gibt natürlich Situationen wo <XYZ>s Vorschlag berechtigt ist. Falls zum Beispiel in der Funktion sehr große Datenmengen in einen (STL) Container gepackt werden, ist eine Übergabe per Referenz (+ vorherigem reserve) in der Regel deutlich performanter als die value-Rückgabe eines neuen Containers.

[ Dieser Beitrag wurde am 02.04.2003 um 15:01 Uhr von HumeSikkins editiert. ]

[ Dieser Beitrag wurde am 02.04.2003 um 15:03 Uhr von HumeSikkins editiert. ]

Am Beispiel von std::string mögen die Meinungen sicher auseinander gehen, auf Grund der unterschiedlichen Implementierungen ....

Aber hab grad nen Beispiel in der Praxis .....

Es wird nen Logfile erzeugt, das pro minute bis zu 50 MB daten erzeugt
(Fragt ned nach dem Sinn ! )
Bei hoeherer Last (mehr Input pro Zeit) geht der Rechner in die Knie, sprich er kann die Daten ned mehr so schnell verarbeiten, 100% Prozessorauslastung ... usw.

Bei der Ursachenforschung stosse ich auf folgenden Ueberltaeter !
Ne Methode: CComBSTR get_ManagerIdentString(long al_ManagerID, long al_TypId);
In der Funktion wird der String zusammengebaut, mit CComBSTR Funktionen und zum schluss wird der CComBSTR per Rueckgabewert "zurueckkopiert", und nen CComBSTR zu kopieren scheint echt "teuer" zu sein .....

Caio ....

Helium

Sollte man aber (unabhängig vom vorherigen Streitthema) nicht das ganze eher so gestalten:

#include <string>

std::string getDate()
{
   time_t datum = time(0);
   tm *tmzgr = localtime(&datum);

   char woche[30];
   strftime(woche,30,"%c",tmzgr);

   return woche;
}

HumeSikkins

@Helium
Sicher