String = String + (char)Int geht nicht

daishi

Dei jetzige Lösung ist aber auch nicht cpp.

Bashar

dafür aber c++

daishi

sprintf ist doch nicht c++

Bashar

Doch.

davie

aber die zeile darunter geht in C nicht.

und nocheinmal sei auf unsere FAQs hingewiesen.
Für Suchfaule.
Die Lösung mit sprintf ist übrigens auch dabei

davie schrieb:

und nocheinmal sei auf unsere FAQs hingewiesen.
Für Suchfaule.

Da schau ich wohl besser das nächste mal erstma rein!
Die ist aber auch viel zu weit unten in der Foren-Überischt!

THX
Evil-Hunter

#include <iostream>

class String
{
	wchar_t *data;

	void CopyStringData(const String &source)
	{
		data = new wchar_t[wcslen(source.data) + 1];
		wcscpy(data, source.data);
	}

public:
	// Konstruktoren:
	String()
	{
		data = new wchar_t[1];
		data[0] = '\0';
	}
	String(const String &source)
	{
		CopyStringData(source);
	}
	String(const wchar_t *text)
	{
		data = new wchar_t[wcslen(text) + 1];

		wcscpy(data, text);
	}
	String(const char *text)
	{
		int size = (int)strlen(text) + 1;

		// temp erstellen:
		wchar_t *temp = new wchar_t[size];
		mbstowcs(temp, text, size);

		// In data schreiben:
		data = new wchar_t[wcslen(temp) + 1];
		wcscpy(data, temp);

		// temp löschen:
		delete[] temp;
	}
	String(const int number)
	{
        data = new wchar_t[33];		// 33 Byte ist das Maximum für _itow

		_itow(number, data, 10);
	}

	// Destruktor:
	~String()
	{
		delete[] data;
		data = NULL;
	}

	// GetWChar: Gibt einen Zeiger auf den String zurück.
	inline wchar_t* GetWChar()
	{
		return data;
	}

	// Length: Gibt die Länge des Strings zurück.
	int Length()
	{
		return (int)wcslen(data);
	}

	// Operatoren '+=' zum Anhängen:
	void operator+= (wchar_t *otherString)
	{
		// Erforderliche Gesamtlänge bestimmen:
		const int length = (int)wcslen(data) + (int)wcslen(otherString) + 1;

		// In einem temporärem String zusammenfügen:
		wchar_t *temp = new wchar_t[length];
		wcscpy(temp, data);
		wcscat(temp, otherString);

        // Den String in das L-Value Objekt übertragen:
		delete[] data;
		data = new wchar_t[length];
		wcscpy(data, temp);

		// Temprären String löschen:
		delete[] temp;
	}
	void operator+= (const String &otherString)
	{
		(*this) += otherString.data;
	}
	void operator+= (const char *otherString)
	{
		String temp(otherString);
		(*this) += temp.data;
	}
	void operator+= (int number)
	{
		String temp(number);
		(*this) += temp.data;
	}

	// Operatoren '=' zum Zuweisen:
	void operator= (const String &otherString)
	{
		CopyStringData(otherString);
	}
	void operator= (const wchar_t *text)
	{
		String temp(text);
		CopyStringData(temp);
	}
	void operator= (const char *text)
	{
		String temp(text);
		CopyStringData(temp);
	}
	void operator= (int number)
	{
		String temp(number);
		CopyStringData(temp);
	}
};

// String + <type>:
inline const String operator+(const String &s1, const wchar_t *s2)
{
    String tmp(s1);
    tmp += s2;
    return tmp;
}
inline const String operator+(const String &s1, const char *s2)
{
    String tmp(s1);
    tmp += s2;
    return tmp;
}
inline const String operator+(const String &s1, int s2)
{
    String tmp(s1);
    tmp += s2;
    return tmp;
}
// String + String:
inline const String operator+(const String &s1, const String &s2)
{
    String tmp(s1);
    tmp += s2;
    return tmp;
}

Für die ganz faulen (was ich bei C++ Strings) verstehen kann, hab ich heute meinen großzügigen Tag

Evtl. solltest du wchar_t durch char ersetzen, wenn du kein Unicode willst.

(Keine Garantie für gar nichts, ist noch in der Entwicklung)

davie

ich hoffe, du machst diese string klasse jetzt nicht, weil du denkst, standard c++ kann nicht mit wchar_t umgehen.
außerdem ist im Konstruktor das data = NULL; etwas *sehr* überflüssiges.

geht das nicht mit strcpy(string1,string2); ?

davie

was geht nicht mit strcpy?
bei std::strings ist der operator+ überladen, so dass man ganz bequem schreiben kann:

string DateiName("Blubber");
string temp = DateiName + ".txt";
temp += "Was auch immer";

davie schrieb:

ich hoffe, du machst diese string klasse jetzt nicht, weil du denkst, standard c++ kann nicht mit wchar_t umgehen.
außerdem ist im Konstruktor das data = NULL; etwas *sehr* überflüssiges.

Nein, ich mache die String-Klasse, weil Standard C++ mit Strings nicht vernünftig umgehen kann
Und ich habe mir angewöhnt, ungültige Pointer immer auf NULL zu setzen. Ich nehme an, du meinst den DEstruktor?

Und wegen deinem '+' von std::string: du kannst nicht <string> + <int> schreiben. Darum ging es ja ^^

Jester

Dann bau doch einfach den entsprechenden operator+ dazu, das ist doch viel einfacher, als gleich nen neue string-Klasse zu schreiben.

MfG Jester

operator void

Optimizer schrieb:

Und wegen deinem '+' von std::string: du kannst nicht <string> + <int> schreiben. Darum ging es ja ^^

Implizite Typumwandlungen sind aber nicht gerade jedermanns Sache.

Ganz objektiv betrachtet leakt deine Klasse außerdem in operator=. Wieder mal was, was ein Smart-Ptr verhindert hätte - boost::scoped_array beißt doch nicht...

Jester schrieb:

Dann bau doch einfach den entsprechenden operator+ dazu, das ist doch viel einfacher, als gleich nen neue string-Klasse zu schreiben.

MfG Jester

Ich will da noch einiges anders machen, wie in der std::string-Klasse. Außerdem lern ich so mal, das new und delete einzusetzen

operator void schrieb:

Ganz objektiv betrachtet leakt deine Klasse außerdem in operator=. Wieder mal was, was ein Smart-Ptr verhindert hätte - boost::scoped_array beißt doch nicht...

Da hast du verdammt recht...
Danke für den Tipp!

also mal ein Bsp. zu strcat

char *name1="Baum";

strcat(name1,"haus");

danach steht in name1 "Baumhaus",
das ist doch die einfachste Lösung oder etwa nicht?

Bashar

berd schrieb:

das ist doch die einfachste Lösung oder etwa nicht?

Nö, es erzeugt undefiniertes Verhalten.