Ctor bei basic_string<char> und operator+

[PuerNoctis]

Eeeeeeeinen guten Abend wünsche ich erstmal ^^

Ich hatte gerade ein Problem bei einer Implementierung einer eigenen String-Klasse, dass ich nicht ganz verstehe, und vielleicht kann mir hier der ein oder andere einen Hinweis geben, warum ich dieses Problem hatte. Prinzipiell ist meine Klasse ein simpler std::string den ich um einpaar Funktionen erweitern will. Die Definition sieht wie folgt aus:

typedef C_STRING_T : public std::string
{
// [...]
}String_t;

Was ich normalerweise bei einem std::string immer gern verwendet habe, war die Möglichkeit diverse const char* und andere std::string mit dem passenden Ctor zu verknüpfen um daraus einen neuen String zu schaffen, wie folgt:

std::string strWelt = "Welt";
std::string strNeu = std::string("Hallo " + strWelt);

Versuche ich dieses Stück Code mit einem String vom Typ meiner Klasse zu verwenden,

String_t strWelt = "Welt";
String_t strNeu = String_t("Hallo " + strWelt);

meckert der Compiler das Fehlen eines passenden Ctor an. Das liegt einzig und allein an dem const char*, denn wenn ich LHS und RHS bei der "+"-Operation vertausche, geht's (die jeweiligen Operatoren sind implementiert).

Folgende Ctor's habe ich definiert:

explicit C_STRING_T(void);
C_STRING_T(const C_STRING_T& str);
C_STRING_T(const C_STRING_T& str, size_t pos, size_t n = npos);
C_STRING_T(const char* s, size_t n);
C_STRING_T(const char* s);
C_STRING_T(size_t n, char c);

Der Ctor der mir fehlt, und nach dessen Implementierung der Code compiled wird, ist

C_STRING_T(const std::string& str);

So.... jetzt versteh' ich leider nicht ganz, warum der Compiler genau diesen braucht. Wieso wird in beiden Fällen der const char[6] = "Hallo " als std::string interpretiert, und bei Verwendung meiner Klasse nicht als String_t (denn hier hätte ich ja den passenden Ctor)? Müsste da nicht ein globaler "+"-Operator für const char* existieren?

Gruß
PuerNoctis

[Ad aCTa]

Lass das Vorhaben. Du solltest niemals von std::basic_string<char> erben, dafür wurde diese Klasse nicht konzipiert. (Keine virtuellen Funktionen z.B.)

Was willst du erreichen? Wenn du gemische Arithmetik von einer eigenen String-Klasse willst, musst du global den Operator + definieren und als Parameter 2 Stringobjekte. Der Compiler wird dann beim Auftreten eines char*s implizit den Copy-Konstruktor aufrufen.

Aber definiere erst mal 'nen eigenen String (verwaltetes dynamisches Char-Array)

[PuerNoctis]

Aja, alles klar, danke für die Antwort.
Sinn und Zweck der Vererbung war, dass ich den bestehenden basic_string<char> um einige Methoden erweitern wollte, die ich persönlich gerne hätte um "gemütlicher" programmieren zu können (z.B. simple ToUpper/Lower Methoden, oder sprintf) -- re-implementieren will ich da auch nichts, daher stört mich das Fehlen von virtuellen Methoden auch nicht.

Das mit dem globalen "+"-Operator werde ich mal ausporbieren.

Danke

[Ad aCTa]

Nur bitte erbe nicht von string , das ist ein recht übles Ding.

[Nexus]

Nur um Funktionalität hinzuzufügen, kannst du globale Funktionen definieren. Viele Leute sind der Ansicht, dass std::string sowieso bereits zu viele Methoden hat. In C++ ist (z.B. im Gegensatz zu Java) nicht alles eine Klasse, und entsprechend macht es keinen Sinn, alles so hinzubiegen.

Ich würde das so lösen:

void transform_to_upper(std::string& str);

[PuerNoctis]

Oke, danke für die Antworten
Ich werde dann von 'ner Vererbung absehen und das mit globalen Funktionen lösen.