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

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

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

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

lol

Immer wieder der alte Käse ist doch langweilig.

automatische Rechtschreibprüfung

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

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.

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^^

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

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

, 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.

Oh, das ist clever! Wieder etwas gelernt.

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

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

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

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

char kann maximal 255 verschiedene zeichen darstellen. Der Unicodezeichensatz beispielsweise hat aber 100000 Zeichen. du verstehst das Problem?

Also habe jetzt mal angefangen die klasse zu schreiben, hab jetzt mal die konstruktore und den destruktor geschrieben, würde gerne wissen ob die schon mal ok sind, also vom aufbau her:

#ifndef STRINGCLASS_H
#define STRINGCLASS_H

typedef unsigned int UINT;

class Stringclass
{
private:
    char* data;
    UINT size;
public:
    Stringclass();
    ~Stringclass();
    Stringclass(const Stringclass&);

};

#endif

#include "Stringclass.h"

Stringclass::Stringclass()
{
    size = 0;
    data = new char[size];
}

Stringclass::~Stringclass()
{
    delete[] data;
}

Stringclass::Stringclass(const Stringclass& sc)
{
    size = sc.size;
    data = new char[size];
    for(UINT i=0;i<size;i++)
        data[i] = sc.data[i];
}

Die funktionen funktionnieren zwar alle, aber vielleicht könnte mal es ja anders schreiben oder es könnten fehler später auftreten.

for(UINT i=0;i<size;i++)
        data[i] = sc.data[i];

Sowas wirst du in der klasse oefters brauchen. du solltest das also in eine funktion auslagern. idealerweise gibt es dafuer zB std::memcpy oder std::copy. Du kannst es natuerlich auch selber schreiben der Uebung wegen, aber eine eigene funktion sollte es schon sein (denn doppelten code will man nie haben. immer wenn du code mehr als einmal brauchst, schreit dass nach abstraktion)

PS:
ignoriere das Unicode Problem (also dass char nur 256 Zeichen beinhalten kann) erstmal. das thema ist zu komplex und laengt nur vom eigentlichen thema ab.

PS:
ignoriere das Unicode Problem (also dass char nur 256 Zeichen beinhalten kann) erstmal. das thema ist zu komplex und laengt nur vom eigentlichen thema ab.

richtig, ich glaub allerdings auch nicht, dass unicoder den Vorschlag ernst meinte :). Andererseits ist es interessant(zumindest wars das für mich), sich mit unicode zu beschäftigen, und einen wtf moment nach dem anderen beim durchlesen der featureliste zu haben

void mycopy(const char* from, char* to, UINT size, UINT to_begin = 0)
{
    for(UINT i=0; i<size;i++)
        to[i+to_begin] = from[i];
}

Stringclass::Stringclass()
:size(0)
{
    data = new char[size]; 
}

Stringclass::Stringclass(const Stringclass& sc)
:size(sc.size)
{
    data = new char[size];
    mycopy(sc.data,data,size);
}

Stringclass::Stringclass(UINT scsize, const char* scdata)
:size(scsize)
{
    data = new char[size];
    mycopy(scdata,data,size);
}

Stringclass::~Stringclass()
{
    delete[] data;
}

Stringclass& Stringclass::operator=(const Stringclass& sc)
{
    Stringclass temp(sc);
    this->myswap(temp);
    return *this;
}

char& Stringclass::operator[](UINT index) const
{
    return this->data[index];
}

UINT Stringclass::get_size() const
{
    cout << "Funktion: get_size" << endl;
    return size;
}

Also zu dem Code besteht jetzt nur eine frage, kann man "data = new char[size]" in die Initialisierungsliste des konstruktors packen?

So jetzt kommen die Fragen^^

Also hab mal zuerst ne swap methode geschrieben.Funktionnieren tut es, aber schön sieht das nicht aus, meiner meinung nach, da ich den standart copykonstruktor selber programmieren musste, damit temp auf sc verweist.So brauche ich dann nicht den inhalt, sondern nur den zeiger auf data zu kopieren, ich muss nur den zeiger von temp auf 0 zum Schluss setzen, damit ich den speicher von this nicht lösche.Hab das mal aufgemalt:
http://img179.imageshack.us/img179/9462/swapda4.jpg

void Stringclass::myswap(Stringclass& sc)
{
    Stringclass temp;
    temp.size = sc.size;
    temp.data = sc.data;
    sc.size = this->size;
    sc.data = this->data;
    this->size = temp.size;
    this->data = temp.data;
    temp.data = 0;
}

und dann noch den sc-realloc:

void Stringclass::sc_realloc(UINT newsize)
{
    Stringclass temp(newsize,this->data);
    myswap(temp);
}