3. string-Klasse

string-Klasse

  • M

    Hallo,

    ich brauche dringend eine string-Klasse mit Konstruktoren,Destruktoren und Operatoren.

    Ich würde mich SEHR freuen, wenn jemand mir weiterhelfen würde, da ich die Klasse wirklich sehr dringend brauchen.

    Vielen Dank im Voraus...

    0
  • G

    mius schrieb:

    Hallo,

    ich brauche dringend eine string-Klasse mit Konstruktoren,Destruktoren und Operatoren.

    Ich würde mich SEHR freuen, wenn jemand mir weiterhelfen würde, da ich die Klasse wirklich sehr dringend brauchen.

    Vielen Dank im Voraus...

    std::string.

    Ach ja, jede Klasse hat Konstruktoren und Destruktoren, außer du verbietest sie(wobei sie ja eigentlich, sofern implementiert, immer noch vorhanden sind, nur halt nicht für dich).

    0
  • A

    Meinste er kommt mit der Info weiter, wenn er nicht mal weiß, das es schon eine String-Klasse gibt? 😃

    Bevor die nächste Frage kommt, welche Include u.ä.:

    http://www.cppreference.com/cppstring/index.html

    😉

    0
  • M

    Zuerst möchte ich mich für die Antworten bedanken.

    Dass die Klassen Konst- &Destruktoren haben ist mir schon bekannt, nur meine Frage war, ob mir jemand die Definitionen auch aufschreiben könnte, da ich noch ein "Neueinsteiger" bin und dies meinen Lehrer am Donnerstag vorführen muss.

    Ich wußte auch nicht, dass eine String-Klasse existiert, anscheinend finden das manche "lustig". Falls die Leute sich lustig über die gestellten Fragen machen wollen, dann können sie es ja direkt sein lassen, wobei dies meine eigene Meinung ist.

    Danke im Voraus..

    0
  • L

    Lustig macht man sich vor allem über äußerst unpräzise gestellte (Glaskugel-)Fragen.

    Eine Definition der Kon- und Destruktoren von std::string findest Du übrigens in der Datei string im Includeverzeichnis Deines C++-Compilers (wäre z.B. eine gültige Antwort auf Deinen Wunsch, Dir die Definitionen zu zeigen, aber das ist bestimmt nicht was Du willst, oder?)

    0
  • E

    ich brauche dringend eine string-Klasse mit Konstruktoren, Destruktoren und Operatoren.

    Klingt ja echt dramatisch. 😉
    Na, dann wollen wir mal Material spucken.
    http://www.volkard.de/vcppkold/die_klasse_string.html
    http://www.c-plusplus.net/forum/viewtopic-var-t-is-141852-and-postdays-is-0-and-postorder-is-asc-and-highlight-is-estring-and-start-is-10.html

    Interessantes Beispiel von "Codehacker":

    #include <conio.h>
#include <iostream>
#include <vector>
#include <cassert>
using namespace std;

class EString
{
    private:
        static const unsigned long FWDBUFFER=15;
        static const unsigned long INPBUFFER=200;

        char* string;
        unsigned long len;
        unsigned long bufsize;
        void replace(const char*);
        void replace(const vector<char>& v);
         void insert(unsigned long, unsigned long, const char*);

    public:
        EString();
        EString(const char*);
        EString(const char);
        EString(const EString&);
        ~EString();

        EString& operator=(const EString&);
        EString& operator=(const char*);
        EString& operator=(const char);

        friend ostream &operator<<(ostream&, const EString&);
        friend istream &operator>>(istream&, EString&);

        EString& operator+=(const EString&);
        EString& operator+=(const char*);
        EString& operator+=(const char);

        friend const EString operator+(const EString&, const EString&);
        const EString operator+(const char*) const;
        const EString operator+(const char) const;

        friend const EString operator+(const char*, const EString&);
        friend const EString operator+(const char, const EString&);

        char &operator[](unsigned long);
        const char &operator[](unsigned long) const;
        EString operator()(unsigned long, unsigned long) const;

        bool operator<(const EString&) const;
        bool operator<=(const EString&) const;
        bool operator==(const EString&) const;
        bool operator!=(const EString&) const;
        bool operator>=(const EString&) const;
        bool operator>(const EString&) const;

};

/*
** Private Methoden (technische Methoden)
*/

void EString::replace(const char *s)
{
    if(string) delete[](string);
    len=strlen(s);
    bufsize=FWDBUFFER+len+1;
    string=new(char[bufsize]);
    assert(string!=0);
    strcpy(string,s);
}

void EString::replace(const vector<char>& v)
{
    if(string) delete[](string);
    len=v.size();
    bufsize=FWDBUFFER+len+1;
    string=new(char[bufsize]);
    assert(string!=0);
    unsigned int x=0;
    for (;x<v.size();x++)
    string[x]=v[x];
    string[x]=0;
}

void EString::insert(unsigned long pos, unsigned long slen, const char *s)
{
    if(!string)
        {
            len=slen;
            bufsize=FWDBUFFER+len+1;
            string=new(char[bufsize]);
            assert(string!=0);
            strcpy(string,s);
            return;
        }
    else
        {
            if((len+slen+1)<=bufsize)
                {
                    for(unsigned long x=len+1;x>=pos+1;x--)
                        string[x+slen-1]=string[x-1];
                    for(unsigned long x=0;x<slen;x++)
                        string[x+pos]=s[x];
                    len+=slen;
                }
            else
                {
                    bufsize=FWDBUFFER+len+slen+1;
                    char *sptr=new(char[bufsize]);
                    assert(sptr!=0);
                    unsigned long y=0,x;
                    for(x=0;x<pos;x++)
                        sptr[y++]=string[x];
                    for(x=0;x<slen;x++)
                        sptr[y++]=s[x];
                    for(x=pos;x<=len;x++)
                        sptr[y++]=string[x];
                    len+=slen;
                    delete[](string);
                    string=sptr;
                }
        }
}

/*
** Konstruktoren und Destruktoren
*/

EString::EString(void)
{
    len=0;
    bufsize=0;
    string=0;
}

EString::EString(const char *s)
{
    string=0;
    replace(s);
}

EString::EString(const char c)
{
    string=0;
    char s[2];
    s[0]=c;
    s[1]=0;
    replace(s);
}

EString::EString(const EString &s)
{
    string=0;
    replace(s.string);
}

EString::~EString()
{
    if(string) delete[](string);
}

/*
** Zuweisung
*/

EString &EString::operator=(const EString &s)
{
    if(this==&s) return(*this);
    replace(s.string);
    return(*this);
}

EString &EString::operator=(const char *s)
{
    replace(s);
    return(*this);
}

EString &EString::operator=(const char c)
{
    char s[2];
    s[0]=c;
    s[1]=0;
    replace(s);
    return(*this);
}

/*
** Ein-/Ausgabe-Operatoren
*/

ostream &operator<<(ostream &ostr, const EString &s)
{
    if(s.len) ostr << s.string;
    return(ostr);
}

istream &operator>>(istream &istr, EString &s)
{
    char c;
  vector<char> inp;

  while(!isspace(c=static_cast<char>(istr.get())))
    inp.push_back(c);
    s.replace(inp);
    return(istr);
}

/*
** Additions-Operatoren
*/

EString &EString::operator+=(const EString &s)
{
    insert(len,strlen(s.string),s.string);
    return(*this);
}

EString &EString::operator+=(const char *s)
{
    insert(len,strlen(s),s);
    return(*this);
}

EString &EString::operator+=(const char c)
{
    insert(len,1,&c);
    return(*this);
}

const EString operator+(const EString &s1, const EString &s2)
{
    EString tmp=s1.string;
    tmp.insert(tmp.len,strlen(s2.string),s2.string);
    return(tmp);
}

const EString EString::operator+(const char *s) const
{
    EString tmp=string;
    tmp.insert(len,strlen(s),s);
    return(tmp);
}

const EString EString::operator+(const char c) const
{
    EString tmp=string;
    tmp.insert(len,1,&c);
    return(tmp);
}

const EString operator+(const char *s, const EString &str)
{
    EString tmp=s;
    tmp.insert(tmp.len,strlen(str.string),str.string);
    return(tmp);
}

const EString operator+(const char c, const EString &str)
{
    EString tmp=c;
    tmp.insert(tmp.len,strlen(str.string),str.string);
    return(tmp);
}

/*
** Indizierungsoperator
*/

char &EString::operator[](unsigned long p)
{
    assert(p<len);
    return(string[p]);
}

const char &EString::operator[](unsigned long p) const
{
    assert(p<len);
    return(string[p]);
}

/*
** Funktionsaufrufoperator
*/

EString EString::operator()(unsigned long p, unsigned long l) const
{
    assert((p<len)&&((p+l)<=len));
    EString tmp="";
    tmp.insert(0,l,string+p);
    return(tmp);
}

/*
** Vergleichsoperatoren
*/

bool EString::operator<(const EString &s) const
{return(strcmp(string,s.string)<0);}

bool EString::operator<=(const EString &s) const
{return(strcmp(string,s.string)<=0);}

bool EString::operator==(const EString &s) const
{return(strcmp(string,s.string)==0);}

bool EString::operator!=(const EString &s) const
{return(strcmp(string,s.string)!=0);}

bool EString::operator>=(const EString &s) const
{return(strcmp(string,s.string)>=0);}

bool EString::operator>(const EString &s) const
{return(strcmp(string,s.string)>0);}

int main()
{
    EString s1 = "Hallo ";
    EString s2 = "schoene ";
    EString s3 = "Welt";
    cout << s1+s2+s3 << endl;
    getch();
}
    0
  • E

    Dass die Klassen Konstruktoren und Destruktoren haben, ist mir schon bekannt. Nur meine Frage war, ob mir jemand die Definitionen auch aufschreiben könnte, da ich noch ein "Neueinsteiger" bin und dies meinem Lehrer am Donnerstag vorführen muss.

    http://www.c-plusplus.net/forum/viewtopic-var-t-is-148647-and-postdays-is-0-and-postorder-is-asc-and-start-is-10.html
    Auszüge daraus:
    Klassen sind nichts anderes als "Baupläne" für Objekte / Instanzen. Das Objekt "SuperHero" ist eine Variable vom Typ "krieger", "Hans" ein Objekt vom Typ "Mensch". Die Klasse ist abstrakt, das Objekt konkret (Adresse des Objekts: this-Zeiger im realen bzw. virtuellen Speicherraum).

    Klassen enthalten Member-Funktionen (Methoden) und Member-Variablen (Attribute).
    Der "Bau" der Objekte erfolgt in der Konstruktor-Funktion (kurz. Konstruktor).
    Der Konstruktor hat den gleichen Namen wie die Klasse.

    Der Zugriff auf Funktionen und Variablen wird bei deren Deklaration erledigt:
    public, protected oder private.

    Bei private kann nur von innerhalb der Klasse zugegriffen werden.
    Bei public kann man auch von außen auf die Daten der Klasse zugreifen.
    Bei protected können abgeleitete Klassen von außen zugreifen.

    Der Destruktor ist die "Abrissbirne". 😉

    Reicht das, oder brauchst Du noch mehr für Deinen Pauker?

    0
  • M

    Danke für die hilfreichen Antworten und für den Quelltext aber mein Lehrer würde schon merken, dass ich das Programm nicht geschrieben habe:)

    Wir haben folgendes in der Schule programmiert bzw. einige Kollegen von mir:

    #include <iostream>
    #include <string.h>

    using namespace std;

    class String
    {
    int len;
    char *s;
    public:
    String();
    ~String();
    String(const char *t);
    String(const String &q);

    const char* get_s()const;

    bool operator<(const String z)const;
    bool operator>(const String z)const;

    String& operator=(const String& z);
    String& operator+=(const String& z);

    };

    int main()
    {
    String T1="String", T2="String";
    cout << "T1 < T2" << " " << (T1<T2) << endl ;

    system("pause");
    }

    String::String()
    {
    s=0;
    len=0;
    }

    String::String(const char *t)
    {
    cout<<"Konstruktor"<<endl;
    s=new char[(len=strlen(t))+1];
    if(!s)
    {
    cout<<"kein Speicher"<<endl;
    exit(1);
    }
    strcpy(s,t);
    }

    String::String(const String &q)
    {
    cout<<"Kopierkonstruktor"<<endl;
    s=new char[(len=q.len)+1];
    if(!s)
    {
    cout<<"kein Speicher"<<endl;
    exit(1);
    }
    strcpy(s, q.s);
    }

    String::~String()
    {
    cout<<"Destruktor"<<endl;
    delete []s;
    s=0;
    }

    bool String::operator< (const String z)const
    {
    return (strcmp(s,z.s))<0;
    }

    bool String::operator> (const String z)const
    {
    return (strcmp(s,z.s))>0;
    }

    const char* String::get_s()const
    {
    return s;
    }

    String& String:: operator=(const String& z)
    {
    if(this==&z){
    return this;
    }
    len=z.len;
    free(s);
    s=(char    )malloc(strlen(z.s)+1);
    strcpy(s,z.s);
    s[strlen(s)]=0;
    return *this;
    }

    String& String::operator+=(const String& z)
    {
    char *temp;
    temp=new char[(len=len+z.len)+1];
    *temp=0;
    strcat(temp,s);
    strcat(temp,z.s);
    *this=temp;
    s[len]=0;
    return *this;
    }

    Der Lehrer hat dies kontrolliert und hätte hier ein paar Fehler entdeckt. Kann jemand vielleicht die Fehler entdecken und ggf. vielleicht noch ein paar Operatoren ergänzen:)?? Das wäre sehr sehr nett, wenn jemand es sogar bis heute Abend erledigen würde, da ich es morgen vorführen müsste 😕

    0
  • Z

    Also, dann wollen wir mal:

    Das hier:

    bool operator<(const String z)const;
bool operator>(const String z)const;

    Sollten freie Operatoren sein. Und dann könnte man auch gleich noch operator<=, operator>=, operator== und operator!= ergänzen.

    Außerdem muß es

    const String& z

    statt

    const String z

    heißen.

    Stream-Operatoren wären auch nicht schlecht, z.B. diese hier:

    std::ostream& operator<< (std::ostream& Stream, const String& s);
std.:istream& operator>> (std::iostream& Stream, String& s);

    Und da wir schon ein += haben, sollten wir auch ein + einführen (implementiert durch Aufruf von += und das ganze natürlich als freier Operator).

    Das hier:

    s[strlen(s)]=0;

    Im Zuweisungsoperator ist kompletter Unsinn.

    Das hier:

    *temp=0;
strcat(temp,s);

    kann man durch einen strcpy-Aufruf ersetzen.

    Außerdem mischst du auf ziemlich wilde Weise malloc/free und new/delete. Das kann schiefgehen.

    Du vergißt an mindestens zwei Stellen den Speicher freizugeben.

    Das hier:

    s=new char[(len=q.len)+1]; 
if(!s)
{
cout<<"kein Speicher"<<endl;
exit(1);
}

    is überflüssig, da new niemals einen 0-Zeiger zurückgeben kann.

    Und dann wäre noch zu erwähnen, daß das ganze nicht Exception sicher ist.

    Das wäre soweit erst mal alles, was wir beim ersten Durchsehen aufgefallen ist.

    0
  • C
    Mod

    hausaufgaben machen wir hier nicht. wir geben hilfe zur selbsthilfe. ein paar tips:

    - <string.h> wird in C++ zu <cstring>
    - operator= passt nicht zu den anderen funktionen hinsichtlich der speicherallokation
    - new gibt kein 0 zurück im fehlerfalle, sondern es wird eine exception geworfen, der test if(!s) ist dort also überflüssig (stattdessen müsste korrekterweise eine fehlerbehandlung in main stattfinden - das kann man in diesem kleinen programm sicher auslassen)
    - weitere operatoren kannst du auf die bereits definierten zurückführen:
    -- wenn a < b ist, was gilt dann nicht für a bezüglich b?

    edit: @Z2: ich sehe nur eine stelle mit einem leck in +=

    0
  • Z

    Hast Recht. Hab mich verguckt. Ist aber auch verdammt schwer zu lesen ohne Syntax Colouring. Bin das gar nicht mehr gewöhnt 😉

    Und da wir schon mal beim Posten sind: ein zusätzlicher []-operator wäre auch nicht schlecht (in zweifacher Ausgabe natürlich, einmal const und einmal nicht-const).

    0
  • C
    Mod

    Z2 schrieb:

    Hast Recht. Hab mich verguckt. Ist aber auch verdammt schwer zu lesen ohne Syntax Colouring. Bin das gar nicht mehr gewöhnt 😉

    ich zitier dann immer, hau tags um den code und guck in die vorschau.

    0
Anmelden zum Antworten