class klasse {
        ...
        string toStr();
        ...
};

string klasse::toStr() { ... }

Nun wollte ich die Klasse abwärtskompatibel machen:

class klasse {
        ...
        string toStr();
        char* toChar();
        ...
};

string klasse::toStr() { ... }
char* klasse::toChar() {
        string ergebnis = toStr();
        return ergebnis.c_str();
}

Daraufhin aber erhalte ich vom Compiler für die Zeile mit dem Return den freundlichen Hinweis:

invalid conversion from ‘const char*’ to ‘char*’

Wieso ist das Ergebnis der Funktion toStr() konstant,
und was ist das Problem, es als char* zurückzugeben?

Vielen Dank im Voraus für Eure Hinweise.

Lg freeG

Nun wollte ich die Klasse abwärtskompatibel machen:

Gegenfrage: Warum willst du Funktionen doppelt implementieren, wenn du notfalls das Ergebnis von toStr umwandeln kannst, wenn es wirklich nötig ist (Niemand verbietet ein ".toStr().c_str()").

Und warum es ein konstanter Zeiger ist, ist bei etwas nachdenken auch klar: Es wird hier kein neues Array angelegt, sondern auf die Stringinterna zurück gegriffen. Sonst müsste man jedesmal wenn man c_str() aufruft, anschließend eine Speicherfreigabe machen.

In 99% der Fälle reicht aber der konstante Zeiger, und wenn nicht, muss man den Inhalt halt umkopieren (In ein passendes Array).

Ich ahne auch grob, wo das Problem liegt.

Allein, mir fehlt noch wohl

a) das genaue Veständnis der Natur eines konstanten Zeigers (Gegensatz zu seinen variablen Brüdern),

b) die Erkenntnis, was ich hier nun tun kann.

Könnt Ihr mir hier weiterhelfen?

a) das genaue Veständnis der Natur eines konstanten Zeigers (Gegensatz zu seinen variablen Brüdern),

Ein konstanter Zeiger (zumindest in der Form const char* p , die hier relevant ist) kann alles, was auch ein normaler Zeiger kann - außer daß die dahinterliegenden Werte konstant sind.
(daneben gibt es noch die Variante char * const p , da kannst du den Zeiger nach der Initialisierung nicht mehr auf ein neues Ziel umbiegen, und const char * const p , der beides kombiniert)

b) die Erkenntnis, was ich hier nun tun kann.

Den std::string kannst du schon übergeben, aber aus einem temporären Objekt die Daten rauszuziehen ist gefährlich. Wenn die toStr()-Methode einen String zurückgibt, der sowieso schon in der Klasse existiert, hätte ich eventuell eine Lösung:

// Übergabe einer Referenz - sollte natürlich keine lokale Variable aus der Methode zurückgeben
const string& toStr() const;
const char* toChar() const
{
  return toStr().c_str()
}

In anderen Fällen solltest du dich auf die toStr()-Methode beschränken und bei Bedarf direkt daraus das char-Array extrahieren.

Den Rückgabewert als C-String, also als *char, brauche ich, um einen Filestream zu füttern; mit anderen Worten: Ich möchte eine Schnittstelle basteln, wie ich eine Instanz meiner Klasse mit ein paar Texteinträgen in einer Datei codieren kann.

Die gedankliche Arbeit, welche Daten für die Klasse gespeichert werden müssen, steckt in der Funktion toStr().

Letztendlich wollte ich auf

fstream schreiberling(dateiname.c_str(), ios::out);
schreiberling << instanz.toChar();

Vielleicht ist das anders besser?

Warum überlädst du nicht gleich den Stream-Operator?

Du meinst, den Operator fstream::operator<<(char* zeichenkette) ?

Also sollte ich einen fstream::operator<<(klasse instanz) schreiben?

Naja, dazu müsste ich ja eine spezielle Klasse "klstream" von fstream ableiten, und das scheint mir dann doch etwas umständlich ...

314159265358979 schrieb:

Außerdem kann man einen std::string problemlos in eine File schreiben, da braucht man kein .c_str().

Ja, und wie geht das?

Bisher habe ich bei der Suche immer nur die alten Stream-C-String-Geschichten gehört. Das würde mich sehr interessieren!

314159265358979 schrieb:

Warum überlädst du nicht gleich den Stream-Operator?

Du meinst, den Operator fstream::operator<<(char* zeichenkette) ?

Also sollte ich einen fstream::operator<<(klasse instanz) schreiben?

Naja, dazu müsste ich ja eine spezielle Klasse "klstream" von fstream ableiten, und das scheint mir dann doch etwas umständlich ...

Nein, du mußt keine eigene Stream-Klasse dafür überladen, der Kollege Pi wollte eher auf eine globale Operator-Überladung hinweisen:

ostream& operator<<(ostream& out, const meineKlasse& data)
{
  //alle wichtigen Inhalte schreiben, oder
  out << data.toStr();
  return out;
}

314159265358979 schrieb:

Außerdem kann man einen std::string problemlos in eine File schreiben, da braucht man kein .c_str().

Ja, und wie geht das?

Bisher habe ich bei der Suche immer nur die alten Stream-C-String-Geschichten gehört. Das würde mich sehr interessieren!

Es gibt auch eine Überladung des Ausgabe-Operators für std::string - und zur Not kannst du für deine Klassen eigene schreiben (s.o.).