//////////////////////////////////////////////////
// Diese Klasse definiert nur das nötigste, also bitte auf Zeiger- oder
// Referenzenübergabehinweise usw. verzichten.
//////////////////////////////////////////////////

class CExample
{
public:
    CExample(char* cstr); // Implementierung nicht wichtig, Hauptsache man weiss, wie aus einem char* ein CExample wird. cstr wird allerdings nicht gelöscht (später noch wichtig)

    char* operator+(CExample TheExample); // Falls mehrere Fehlermeldungen angezeigt werden müssen, kann man diese verknüpfen, um sich mehrere Anzeigen zu sparen.
    // Gibt einem Adressblock auf dem Heap zurück, in dem die fertige Fehlermelgun steht.

    CExample operator=(CExample TheExample); // Kann auch ein char-Zeiger auf Speicher im Heap reservieren, darf diesen aber nicht freigeben.

    //////////////////////////////////////////////////
    // Der Benutzer soll auch in der Lage sein, seine Fehlermeldungen
    // in einen char* umzuwandeln. Dazu der operator char*,
    // der die Adresse eines nulterminierten Strings im Heap 
    // zurückgibt. Hier liget auch mein Problems: um möglichst
    // Kompatibel zu char* zu sein, gibt dieser Operator keinen Verweis
    // auf meinen Fehlermeldungstext und auch kein neues Objekt,
    // sondern einen komplett neuen Text mit neuem Speicher auf dem
    // Heap zurück (genau wie der Additionsopertaotr). Wenn aber
    // in diesem Operator Speicher auf dem Heap reserviert wird,
    // wird dieser weder im operator= noch im Konstruktor freigegeben.
    // Kurz: String auf dem Heap, wird in ein CExample-Objekt verwandelt,
    // Verweis geht verloren, der Speicher bleibt jedoch bestehen.
    //////////////////////////////////////////////////

    operator char*();    
private:
    char* m_ErrorMessage; // Enthält die Fehlermeldung an sich
    // (...) Und noch so einige Elemente, alle hier unwichtig
}

Zur Erläuterung: Die Klasse CExample definiert einen Konstruktor, mit dem man einen char* in ein CExample-Objekt umwandeln kann, und einen operator char*, mit dem man dieses Objekt (eigentlich die gespeicherte Fehlermeldung) wieder in einen char* verwandeln kann. Zusätzlich ein operator+, der die Fehlermeldungen verbinden kann, und ein Zuweisungs-operator=.

Mein Problem:

int main()
{
    CExample Example="Beispiel"; // Example wird leer konstruiert, "Beispiel" wird in ein CExample-Objekt verwandelt und Example zugewiesen.

    char* String=Example; // Hier wird neuer Speicher reserviert, die Fehlermeldung reinkopiert und anschliessend an String zugewiesen.

    // Bis hier geht alles gut. "Beispiel" ist auf dem Stack und wird automatisch gelöscht. String hat einen eigenständigen Wert. Jetzt aber kommt der GAU ...

    CExample SecondExample=Example+"Beispiel"; // SecondExamole wird leer konstruiert. Example und "Beispiel" werden miteinander verknüpft, dazu wird zuerst aus
    // dem String ein CExample, dann wird der zusammengefügten Fehlermeldung als char* Speicher im Heap zugewiesen (um eben den Typ char* 
    // zu unterstützen). Speicher ist reserviert, wird aber weder im Konstrutor (der aufgerufen wird, weil aus dem Speicher ein CExample-Objekt werden soll) 
    // noch im Zuweisungsoperator freigegeben, da der Benutzer selbst bestimmen soll, wann die Fehlermeldung gelöscht sein soll.
}

Muss ich dem Konstruktor anhand einer bool-Variable sagen, wann er einen Parameter zu löschen hat, oder geht das auch anders? Ich bedanke mich schon mal im Vorraus.

Muss ich dem Konstruktor anhand einer bool-Variable sagen, wann er einen Parameter zu löschen hat, oder geht das auch anders?

Dein Konstruktor hat doch keine Ahnung wo der Speicher hinter dem übergebenen char* herkommt. Er kann mit new[] angelegt worden sein, mit malloc oder von einem separaten Speichermanager oder gar Stackspeicher sein. Deshalb wäre es am besten, wenn du dich an den einfachen Grundsatz hältst: wer den Speicher reserviert, ist auch alleine für die Freigabe zuständig.
Am einfachsten kannst du das mit sauberer Kapselung und RAII sicherstellen: ein (String-)Objekt reserviert Speicher im Konstruktor und gibt ihn im Destruktor wieder frei.

Und weil C++ so toll ist, gibt es dafür auch schon eine fertige Klasse. Die nennt sich std::string und nimmt dir all dieses Rumgehampel mit Zeigern, new und delete ab. Das macht dein Programm einfacher, sauberer und vermindert Fehlerquellen, was allgemein als erstrebenswert angesehen wird.

Ebenso würde const-correctness in diesem Fall einiges klarer machen.

Und da du meinst, dass das so nicht geht, bleibt mir wohl nichts anderes übrig, als einen privaten Konstruktor mit zusätzlichem Flagparameter zu deklarieren. Na, trotzdem danke.

Mit der std::string mag ich nicht so gerne programmieren. Damit bleibt die Individualität des Programms irgendwie auf der Strecke, was ich überhaupt nicht gebrauchen kann (später im Code kommt es nämlich echt Dicke, was die Handhabung angeht, da brauche ich volle Kontrolle auf meine Strings).

Was musst du denn machen, was std::string nicht kann?
Ehrlich gesagt halte ich (nach dem bisschen Info was ich habe) deine Fähigkeiten nicht annähernd für so gut, dass dein Code std::string in irgendeiner Disziplin schlagen könnte. Weder von der Performance her, oder dem Design oder der Fehlerfreiheit.
Statt dessen wirst du mehr Zeit mit Debugging verbringen als du konstruktive Arbeit leistest.

Da du aber vermutlich trotzdem glauben wirst, es besser zu wissen und auf deinem Standpunkt beharren wirst, würde ich dir zumindest als Minimallösung empfehlen, eine eigene Stringklasse mit vernünftiger Kapselung zu implementieren.

Aber gut. Wenn du meinst, ich sollte string s verwenden, werde ich deinen Vorschlag ausprobieren.

Was ist schon dabei? Meiner Meinung nach ist std::string keine "wichtige Klasse" (wie die Streams oder die Container), da man sie selbst programmieren kann. Und was man selbst programmieren kann, kann einem individuelle Vorteile einbringen.

Theoretisch kann man alles selbst programmieren...

Was ist schon dabei? Meiner Meinung nach ist std::string keine "wichtige Klasse" (wie die Streams oder die Container), da man sie selbst programmieren kann.

Wenn man unbedingt will, kann man alles selber programmieren. Ich verstehe auch nicht, warum da Streams und die anderen Containerklassen einen Unterschied zu std::string machen sollten. Das ist übrigens auch nur ein Container für Zeichenketten.

Und was man selbst programmieren kann, kann einem individuelle Vorteile einbringen.

Klar. Wenn du gute Gründe hast, warum nicht. Die Realität sieht aber so aus, dass du hier um Hilfe fragst, weil du Probleme mit der Speicherverwaltung hast, die du alleine nicht gelöst kriegst. Das hört sich nicht gerade nach einem Vorteil an.

Wie kann man Dir nur helfen, wenn Du Dich dagegen querstellst Dein Design zu überdenken?

Ohne das, was Du damit anstellen willst, richtig verstanden zu haben, kann ich trotzdem behaupten, dass die Qualität des Designs sehr niedrig ist.

• Du hast RAII nicht verstanden
• Du ignorierst Warnungen des Compilers. Die Konvertierung eines Zeichenliterals in char* ist veraltet und man sollte darauf nicht setzen.
• Du hast "copy initialization" nicht verstanden. Das geht aus einem Kommentar hervor.
• Falls CExample irgendwie verantwortlich für die "Verwaltung" der Zeichenkette sein soll, fehlen selbstdefinierter Copy-Constructor und Destruktor.
• Dein operator+ nimmt die Parameter als Wert entgegen und nicht per Referenz. Dir ist hoffentlich klar, dass "TheExample" logisch gesehen eine Kopie des Arguments ist, ja?

Auch auf den 2. und 3. Blick sieht Deine Klasse nach einem -- bei allem Respekt -- sehr schlechten std::string Ersatz aus.

Als C++ Anfänger könntest Du Dir solche Kritiken ruhig mal näher zu Herzen nehmen.

Gruß,
SP

Nur zur Information, ich habe diese Klasse soweit abgespeckt, wie es ging.

Zuviel des Guten.

Der aus dem Westen ... schrieb:

Die Klasse ist in ihren jetzigen Zustand nicht mal 100-mal so klein wie im Original.

Bedauerlich.

Der aus dem Westen ... schrieb:

Also keine Sorge, ich bin kein blutiger Anfänger, für den du mich hälst.

Ich halte es für wahrscheinlich, dass Du nur glaubst, kein Anfänger zu sein.

Der aus dem Westen ... schrieb:

Ich ignoriere NIE Warnungen des Compilers. Ich bin sogar so verrückt, diesen auf Warnstufe 4 zu stellen.

Dein Compiler generiert also keine Warnung, wenn Du so etwas schreibst

char      * schlecht = "Ich bin ein Literal";
  char const* gut      = "Ich auch";

?

Ich habe gar keine Lust mich mit jemandem zu streiten hier. Aber bevor Du Dich in ein Design verrennst, welches viele als schlecht einstufen würden, sag ich eben meine Meinung.

Wer ist "Anfänger"? Nur, um mal ein paar Beispiele zu nennen: Leute, die glauben, bei string s = "hello"; würde der string::operator= aufgerufen, sind für mich Anfänger. Leute, die einen + operator mit char* foo::operator+(char*) deklarieren und in der Definition neu angeforderten Speicher zurückgeben, sind für mich Anfänger und Beweis dafür, dass RAII nicht verstanden worden ist.

Gruß,
SP