Operator Überladung

Hallo

string_klasse.h

class String {
private:
	char *buffer;
	unsigned len;
public:
	// Deklaration der Methoden(Fähigkeiten) von String

	// Zugriffsmethode 
	char *get_String() const;

	// Operator Überladung
	String operator+=(const String &str1);
};

string_klasse.cpp

// Definition der Methoden(Fähigkeiten) von String

// Zugriffsmethode
char *String::get_String() const { return buffer; }

// Operator Überladung
String String::operator+=(const String &str1) {
	// tmp gleich mit aktuellen Objekt initialisieren
	String tmp(*this);

	// Aktuelles Objekt löschen
	delete [] buffer;

	// Gesamtlänge beider Objekte ermitteln
	len = tmp.len + str1.len;

	// Speicher reservieren
	buffer = new char[len]+1;

	// linker Operand in buffer kopieren
	strcpy(buffer, tmp.buffer);

	// rechten Operand anhängen
	strcat(buffer, str1.buffer);

	// Zurück und fertig
	return buffer;
}

main.cpp

String str("Adam");

	str += " und Eva";

	cout << str.get_String();

zum Problem
Schaut bitte mal auf den main.cpp Abschnitt. Ich möchte gerne an den Text Adam mit dem neuen überladenen Operator "+=" den Text " und Eva" anhängen.

Die Ausgabe stimmt soweit. Allerdings kommt auch ein Fehler, den ich als JPG Bild festgehalten habe. Wie ist dieser zu beheben?

http://home.tiscali.de/myflash/operator_ueberladen.JPG

delete[] buffer ist falsch. sorry, atm keine zeit für genauere Antwort...

// Speicher reservieren
buffer = new char[len]+1;

Laut meinem C++ Buch ist die obige Zeile total in Ordnung.

Wenn man das so umschreibt

// Speicher reservieren
buffer = new char[len+1];

klappts ohne Fehlermeldung. Das scheint wohl der Fehler zu sein.

Trotzdem danke.

MfG
#smY

C++ Forumbot

Dieser Thread wurde von Moderator/in Jochen Kalmbach aus dem Forum C++/CLI mit .NET in das Forum C++ verschoben.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

*D*Evil

template<typename T>
class basic_string 
{
    T* m_data;
    std::size_t m_length;

public:
    basic_string(const char* str) : m_length(std::strlen(str)) { m_data = new T[m_length + 1]; std::strcpy(m_data, str); }
    basic_string() : m_length(0) { m_data = new T[m_length + 1]; m_data[0] = 0;
    basic_string(basic_string const& rhs) : m_length(rhs.m_length) { m_data = new T[m_length + 1]; std::strcpy(m_data, rhs.m_data); }
    basic_string& operator=(basic_string const& rhs) { m_length = rhs.m_length; m_data = new T[m_length + 1]; std::strcpy(m_data, rhs.m_data); return *this; }
    ~basic_string() { delete [] m_data }

public:
    const char* c_str() const { return m_data; }
    std::size_t length() const { return m_length; }

public:
    friend std::ostream& operator <<(std::ostream& out, basic_string<T> const& data) { out << data.m_data; return out; }

    basic_string operator += (basic_string const& rhs);
};

also get_string sollte schon einen const char zurück geben ... sonnst kann es dir passieren das len nachher nichtmehr stimmt! (falls jemand was an deinem String dann verändert)

#include <iostream>

int main()
{
    std::cout << basic_string<char>("Hallo Welt!") << std::endl;
}

Bearbeitung
Hab dir mal kurz die großen 3 reingepackt

CStoll

#smY schrieb:

// Speicher reservieren
buffer = new char[len]+1;
Laut meinem C++ Buch ist die obige Zeile total in Ordnung.

syntaktisch ist die in Ordnung, technisch nicht. Du unterschlägst erstens den Platz für den Null-Terminator und überpringst zweitens das erste Byte des angeforderten Speicherbereiches.

PS: Ich hoffe für dich, deine String-Klasse hat die "großen drei" implementiert (Copy-Ctor, op= und Dtor)

PPS: Was spricht dagegen, std::string zu verwenden?