Tips für weitere Funktionen in eigener String-Klasse

[uhsuhz]

Könntet ihr mir tipps geben für weitere Funktionen in meiner eigenen String-klasse?

Bis jetzt habe ich:

#ifndef STRINGCLASS_H
#define STRINGCLASS_H

#include<iostream>

class Stringclass
{
    friend std::ostream& operator<<(std::ostream& os, const Stringclass& sc);
    friend std::istream& operator>>(std::istream& is, Stringclass& sc);
    protected:
        char *string;               //Funktion und Variablen sind für den Anwender
        int size;                   //nicht erreichbar, können aber vererbt werden
        void scnew(int new_size);   //und so benutzt werden.
    public:
        //Konstruktor und Destruktor für Stringclass
        Stringclass();
        ~Stringclass();
        //Operator sind immer für char* und Stringclass überladen
        Stringclass& operator=(const char *c);
        Stringclass& operator=(const Stringclass &sc);
        Stringclass& operator+(const char *c);
        Stringclass& operator+(const Stringclass &sc);
        Stringclass& operator+=(const char *c);
        Stringclass& operator+=(const Stringclass &sc);
        bool operator==(const char* c);
        bool operator==(const Stringclass& sc);
        bool operator!=(const char* c);
        bool operator!=(const Stringclass& sc);
        bool operator< (const char* c);         //gibt true zurück wenn das erste abweichende Zeichen
        bool operator< (const Stringclass& sc); //kleiner ist als das andere zeichen
        bool operator<=(const char* c);         //kleiner oder gleich
        bool operator<=(const Stringclass& sc);
        bool operator> (const char* c);         //größer
        bool operator> (const Stringclass& sc);
        bool operator>=(const char* c);         //größer oder gleich
        bool operator>=(const Stringclass& sc);
        //Funktionen zum bearbeiten von Strings
        Stringclass& reverse();					//dreht die Stringclass um
        bool replace(int index, const char c);
        bool replace(int index, int length, const char *c);
        bool replace(int index, int length, const Stringclass& sc);
        bool insert(int index, const char *c);
        bool insert(int index, const Stringclass& sc);
        bool cut(int index, int length);
        void clear();                                //löscht ganzer String
        void erase(int index);                       //löscht ab index
        //Sonstige Funktionen
        int length();
        int find(const char c, int start = 0);            //suchen in einer Stringclass entweder einen
        int find(const char *c, int start = 0);           //String, eine Stringclass oder ein Zeichen
        int find(const Stringclass& sc, int start = 0);   //optionaler parameter definiert den anfang zum suchen
        int compareto(const Stringclass& sc);           // index der ersten verschiedenen Zeichen
        char* to_char();
};

#endif

So das habe ich bis jetzt.

Ich möchte jetzt auch keinen Code von euch, sondern nur weitere Funktionen, die eventuell nützlich wären.

Außerdem, da ich noh ziemlich neu in C++ bin, könntet ihr mir ja mal sagen wie ihr den code bis jetzt findet von der qualität her.

Danke schon mal im Voraus

[Shade Of Mine]

protected ist wie public: nur verwenden wenn es wirklich sein muss. strings sind aber value typen. und von value typen erbt man nicht. ergo nix protected machen.

dir fehlt ein copyctor, beachte the law of the big three

deine operator+ funktionen sind falsch

generell sollten alle funktionen die nicht zwingend member sein muessen, ausserhalb der klasse definiert werden. darunter zB die vergleichsoperatoren, find, compareto,...

du solltest eine schnittstelle anbieten damit man die funktionalitaet der klasse erweitern kann: iteratoren und operator[]

du koenntest die performance verbessern indem du mehr speicher allokierst als du jetzt brauchst um so schneller anhaengen zu koennen. oder aber du spendierst hier eine 2. klasse, einen stringbuilder der schnelles anhaengen ermoeglicht und nachher einen string liefert (wie eben zB Java StringBuilder)

du solltest auf constant correctness achten

eine implementierung fuer swap fehlt, um 2 string objekte effizient miteinander austauschen zu koennen ohne alles kopieren zu muessen

index, length, etc sollten unsigned int sein, damit verhinderst du automatisch dass jemand negative werte uebergibt

[drakon]

Schau doch mal, wie es dit Standardbibliothek gemacht hat. Findest bestimmt nocht interessante Sachen.

[UTFler]

UTF-8,16 und 32 Support hätte ich gerne, ebenso latin1

Außerdem würde ich gerne auf einzelne Zeichen zugreifen können und mit regulären Ausdrücken suchen und ersetzen können.

[Erhard Henkes]

- alle Zeichen umdrehen (zum rückwärts Lesen üben)
- entschlüsseln mit einem weiteren Schlüsselstring
- Verschlüsseln nach verschiedenen Techniken
- Umwandlung in Zahlenformate
- automatische Rechtschreibprüfung
- Übersetzung in andere Sprachen
- TxtToSpeech
- usw.

[omfg]

lol

[__Stefan__]

Wie wär's damit?

- toupper
- tolower
- reverse
- trim
- trim_front
- trim_back
- capitalize

[Erhard Henkes]

omfg schrieb:

lol

Immer wieder der alte Käse ist doch langweilig.

[drakon]

automatische Rechtschreibprüfung

Das gefällt mir persönlich am besten..

[otze]

Stefan schrieb:

Wie wär's damit?
- toupper
- tolower
- capitalize

Kann schwer ins auge gehen. Das wird nicht umsonst von den streams, insbesondere den locales übernommen. Das ist keine Triviale Angelegenheit, sobald man den standardmäßig garantierten zeichensatz verlässt(der nichtmal den kompletten ASCII umfasst)

- reverse

Dafür gibts nen STL algorithmus.

Mein Vorschlag: wenn man schon nen string selbst baut, sollte man sich der Aufgabe stellen, ihn standardalgorithmus kompatibel zu machen.

Es fehlt also noch das komplette iterator interface der Klasse.
begin/end rbegin/rend usw. Also das wär wirklich was ein Interface in dem das Iterator konzept komplett durchgezogen wäre.

[uhsuhz]

oje... hätt ich doch bloß nichts gepostet^^ bin jetzt total überfordert...

was ist denn an den operator+ funktionen falsch?

außerdem ist schon ne reverse funktion drin...

ach ja und was ist falsch mit den const-anweisungen?

Danke im voraus^^

[Nachrichtentexter]

Ja,so eine std::string Klasse (besser) nachzubauen ist nicht so einfach,wie man sich am Anfang vielleicht denkt.

[uhsuhz]

öhm eigentlich hatte ich ja auch nicht vor sie besser zu programmieren.^^

1).ich versuche mal gerade ein paar tipps durchzuführen, mit dem copy-konstruktor, da kann ich ja eigentlich die operator= funktion aufrufen, oder? die soll ja auch eine neue Stringklasse machen und dann alles rüberkopieren und dann zurückgeben, oder?

2). was ist besser, mir wurde ja angeraten die funktionen wenn es geht außerhalb der klasse zu setzten, soll ich nun friends nehmen um direkt auf die private member zuzugreifen, oder per funktionen auf die elemente, und dann nicht per friends. Beide Wege müssten klappen, ich weiß aber nicht welcher besser ist

[otze]

uhsuhz schrieb:

2). was ist besser, mir wurde ja angeraten die funktionen wenn es geht außerhalb der klasse zu setzten, soll ich nun friends nehmen um direkt auf die private member zuzugreifen, oder per funktionen auf die elemente, und dann nicht per friends. Beide Wege müssten klappen, ich weiß aber nicht welcher besser ist

Sofern es möglich ist, nicht als friend. Wenn es nicht geht, oder zuviel overhead bedeuted, dann natürlich friend

[MFK]

uhsuhz schrieb:

, mit dem copy-konstruktor, da kann ich ja eigentlich die operator= funktion aufrufen, oder? die soll ja auch eine neue Stringklasse machen und dann alles rüberkopieren und dann zurückgeben, oder?

Nein, die Aufgabe des Zuweisungsoperators ist etwas weiter gefasst. Dieser Operator ist insbesondere auch dafür zuständig, den existierenden "alten" Inhalt des Objekts ordentlich freizugeben. Das ist etwas, das der Copy-CTor niemals tun muss (oder darf).

Es gibt den den Ansatz, den Zuweisungsoperator über den Copy-CTor als "Copy & Swap" zu implementieren, d.h. so:

Stringclass& Stringclass::operator=( const Stringclass& rhs )
{
    Stringclass temp( ths );
    /*this->*/Swap( temp );
    return *this;
}

Dazu brauchst du die bereits angesprochene effiziente Swap-Methode. Dieser Ansatz hat den Vorteil, dass du nur den Copy-CTor ausprogrammieren musst, und dass der Zuweisungsoperator dadurch auf die Prüfung auf Selbstzuweisung verzichten kann und exceptionsicher wird.

[__Stefan__]

Stringclass& Stringclass::operator=( const Stringclass& rhs )
{
    Stringclass temp( ths );
    /*this->*/Swap( temp );
    return *this;
}

Oh, das ist clever! Wieder etwas gelernt.

[Shade Of Mine]

uhsuhz schrieb:

oje... hätt ich doch bloß nichts gepostet^^ bin jetzt total überfordert...

ne ne, du musst es anders sehen:
viele möglichkeiten etwas zu tun, genug ideen damit du lange beschäftigt bist

was ist denn an den operator+ funktionen falsch?

der operator+ erstellt ein neues objekt:
a+b liefert c und ändert a und b nicht.
du lieferst aber nur eine referenz und kein neues objekt

ach ja und was ist falsch mit den const-anweisungen?

einige funktionen wie zB length() verändern das objekt nicht und sollten daher als const markiert sein.

damit ich

Stringclass const s("hallo");
return s.length();

machen kann

[uhsuhz]

ach so^^ habs jetzt verstanden, danke für die Hilfe.

Das mit dem operator+ wird mir jetzt auch klar, hab da nicht nachgedacht.

Stringclass& Stringclass::operator=( const Stringclass& rhs )
{
    Stringclass temp( ths ); //<- müsste da nicht rhs stehen, steht jedenfalls oben in der deklaration
    /*this->*/Swap( temp );
    return *this;
}

Sind die anderen const anweisungen denn korrekt?

Danke uhsuhz

[unicoder]

Der string sollte nicht auf ein char == ein Zeichen begrenzt sein, sondern seine Zeichengröße auf den Verwendeten Zeichensatz anpassen.

[uhsuhz]

unicoder schrieb:

Der string sollte nicht auf ein char == ein Zeichen begrenzt sein, sondern seine Zeichengröße auf den Verwendeten Zeichensatz anpassen.

hää versteh ich jetzt nicht ganz^^ vielleicht könntest du das genauer erklären